TypeScript Prompt MCP Server

Okay, I understand. Here are some pre-defined prompt templates you can use for AI assistants to generate comprehensive plans for TypeScript projects, API architectures, and GitHub workflows. I've included variations and options to make them more flexible. **1. TypeScript Project Plan:** * **Template 1 (General):** ``` Create a comprehensive plan for a TypeScript project named "[Project Name]" that aims to [briefly describe the project's purpose]. The plan should include: * **Project Goals and Objectives:** Clearly defined goals and measurable objectives. * **Technology Stack:** Recommended libraries, frameworks, and tools (e.g., React, Angular, Node.js, Express, testing frameworks, linting tools). Justify each choice. * **Project Structure:** A proposed directory structure and module organization. * **Coding Standards and Conventions:** Guidelines for code style, naming conventions, and documentation. * **Testing Strategy:** A plan for unit, integration, and end-to-end testing. Specify testing frameworks and methodologies. * **Build and Deployment Process:** Steps for building, packaging, and deploying the application. Include CI/CD considerations. * **Dependencies Management:** How dependencies will be managed (e.g., npm, yarn, pnpm). * **Error Handling and Logging:** Strategies for handling errors and logging information. * **Security Considerations:** Potential security vulnerabilities and mitigation strategies. * **Scalability Considerations:** How the application can be scaled to handle increased load. * **Future Enhancements:** Potential future features or improvements. * **Initial Setup Instructions:** Step-by-step instructions for setting up the development environment. The target audience for this project is [describe the target audience, e.g., small businesses, individual users, enterprise clients]. The project should be [describe desired qualities, e.g., maintainable, scalable, performant, secure]. ``` * **Template 2 (Specific Framework):** ``` Develop a detailed plan for a TypeScript project using [Framework Name] (e.g., React, Angular, NestJS) to build [briefly describe the application]. The plan should cover: * **Project Goals and Objectives:** Clearly defined goals and measurable objectives. * **Framework-Specific Architecture:** How to leverage [Framework Name]'s architecture (e.g., components, services, modules) for this project. * **State Management:** Recommended state management solution (e.g., Redux, Zustand, Context API) and justification. * **Routing:** How routing will be implemented (e.g., React Router, Angular Router). * **Data Fetching:** Strategies for fetching data from APIs (e.g., Axios, Fetch API, GraphQL). * **UI Component Library:** Recommended UI component library (e.g., Material UI, Ant Design, Chakra UI) and justification. * **Testing Strategy:** A plan for unit, integration, and end-to-end testing, specific to [Framework Name]. Specify testing frameworks and methodologies (e.g., Jest, Cypress, Testing Library). * **Build and Deployment Process:** Steps for building, packaging, and deploying the application, optimized for [Framework Name]. Include CI/CD considerations. * **Dependencies Management:** How dependencies will be managed (e.g., npm, yarn, pnpm). * **Error Handling and Logging:** Strategies for handling errors and logging information. * **Security Considerations:** Potential security vulnerabilities and mitigation strategies. * **Scalability Considerations:** How the application can be scaled to handle increased load. * **Future Enhancements:** Potential future features or improvements. * **Initial Setup Instructions:** Step-by-step instructions for setting up the development environment. The target audience for this project is [describe the target audience, e.g., small businesses, individual users, enterprise clients]. The project should be [describe desired qualities, e.g., maintainable, scalable, performant, secure]. ``` * **Template 3 (Backend API):** ``` Create a comprehensive plan for a TypeScript backend API project named "[API Name]" that will [briefly describe the API's purpose]. The plan should include: * **API Goals and Objectives:** Clearly defined goals and measurable objectives. * **Technology Stack:** Recommended libraries, frameworks, and tools (e.g., Node.js, Express, NestJS, database, ORM, testing frameworks, linting tools). Justify each choice. * **API Architecture:** A proposed architecture (e.g., REST, GraphQL, gRPC). Explain the chosen architecture's benefits for this project. * **Database Design:** A high-level database schema and data model. Specify the database technology (e.g., PostgreSQL, MongoDB, MySQL). * **Authentication and Authorization:** A plan for securing the API, including authentication and authorization mechanisms (e.g., JWT, OAuth). * **API Documentation:** How the API will be documented (e.g., OpenAPI/Swagger). * **Error Handling and Logging:** Strategies for handling errors and logging information. * **Testing Strategy:** A plan for unit, integration, and end-to-end testing. Specify testing frameworks and methodologies. * **Build and Deployment Process:** Steps for building, packaging, and deploying the API. Include CI/CD considerations. * **Dependencies Management:** How dependencies will be managed (e.g., npm, yarn, pnpm). * **Security Considerations:** Potential security vulnerabilities and mitigation strategies (e.g., input validation, rate limiting). * **Scalability Considerations:** How the API can be scaled to handle increased load (e.g., load balancing, caching). * **Rate Limiting:** A strategy for rate limiting API requests. * **Monitoring and Alerting:** How the API will be monitored and how alerts will be generated. * **Future Enhancements:** Potential future features or improvements. * **Initial Setup Instructions:** Step-by-step instructions for setting up the development environment. The API will be consumed by [describe the consumers of the API, e.g., web applications, mobile apps, other APIs]. The API should be [describe desired qualities, e.g., performant, secure, reliable, well-documented]. ``` **2. API Architecture Plan:** * **Template 1 (General):** ``` Design a robust and scalable API architecture for [briefly describe the application or system the API will support]. The architecture should address the following requirements: * **API Style:** Choose an appropriate API style (e.g., REST, GraphQL, gRPC) and justify the choice based on the project's needs. * **Data Format:** Specify the data format (e.g., JSON, XML, Protocol Buffers). * **Authentication and Authorization:** Describe the authentication and authorization mechanisms (e.g., JWT, OAuth, API keys). Consider different user roles and permissions. * **Rate Limiting:** Implement a rate limiting strategy to prevent abuse and ensure fair usage. * **Versioning:** Plan for API versioning to allow for future changes without breaking existing clients. * **Error Handling:** Define a consistent error handling strategy, including error codes and messages. * **Documentation:** Specify how the API will be documented (e.g., OpenAPI/Swagger, Postman collections). * **Caching:** Implement caching strategies to improve performance and reduce load on the backend. * **Security:** Address common security vulnerabilities, such as injection attacks, cross-site scripting (XSS), and cross-site request forgery (CSRF). * **Scalability:** Design the architecture to be scalable to handle increasing traffic and data volume. Consider load balancing, horizontal scaling, and database optimization. * **Monitoring and Logging:** Implement monitoring and logging to track API performance and identify potential issues. * **Deployment:** Describe the deployment strategy (e.g., cloud-based, on-premise). * **Technology Stack:** Recommend specific technologies and tools for implementing the API (e.g., Node.js, Express, NestJS, databases, message queues). The API will be used by [describe the consumers of the API]. The key performance indicators (KPIs) for the API are [list the KPIs, e.g., response time, error rate, throughput]. ``` * **Template 2 (Microservices):** ``` Design a microservices-based API architecture for [briefly describe the application or system]. The architecture should address the following: * **Service Decomposition:** Identify the key services and their responsibilities. Explain the rationale behind the service decomposition. * **Communication:** Specify the communication protocols between services (e.g., REST, gRPC, message queues). Justify the choice. * **Service Discovery:** Implement a service discovery mechanism to allow services to locate each other. * **API Gateway:** Design an API gateway to handle external requests and route them to the appropriate services. * **Authentication and Authorization:** Implement authentication and authorization across the microservices. * **Data Management:** Describe how data will be managed across the microservices. Consider data consistency and eventual consistency. * **Monitoring and Logging:** Implement centralized monitoring and logging for all microservices. * **Deployment:** Describe the deployment strategy for the microservices (e.g., containers, Kubernetes). * **Fault Tolerance:** Design the architecture to be fault-tolerant and resilient to failures. * **Technology Stack:** Recommend specific technologies and tools for implementing the microservices (e.g., Docker, Kubernetes, message queues, databases). The system will handle [describe the scale and complexity of the system]. The key challenges in this architecture are [list the key challenges, e.g., data consistency, distributed tracing, security]. ``` **3. GitHub Workflow Plan:** * **Template 1 (General):** ``` Create a GitHub workflow plan for a [TypeScript/JavaScript/Python/etc.] project named "[Project Name]". The plan should include: * **Branching Strategy:** Define a branching strategy (e.g., Gitflow, GitHub Flow, Trunk-Based Development). Explain the rationale behind the chosen strategy. * **Pull Request Process:** Describe the pull request process, including code review guidelines and approval requirements. * **Continuous Integration (CI):** Implement CI to automatically build, test, and lint the code on every pull request and push. Specify the CI tools (e.g., GitHub Actions, Jenkins, CircleCI). * **Automated Testing:** Integrate automated testing into the CI pipeline. Specify the testing frameworks and types of tests (e.g., unit tests, integration tests, end-to-end tests). * **Code Linting and Formatting:** Enforce code style and formatting using linters and formatters (e.g., ESLint, Prettier). * **Code Coverage:** Track code coverage to ensure adequate test coverage. * **Continuous Deployment (CD):** Implement CD to automatically deploy the application to production after successful CI. Specify the deployment environment and strategy. * **Release Management:** Define a release management process, including versioning and tagging. * **Issue Tracking:** Use GitHub Issues to track bugs, features, and tasks. * **Security Scanning:** Integrate security scanning tools to identify vulnerabilities in the code and dependencies. * **Documentation Generation:** Automate the generation of documentation from the code. * **Dependency Management:** Automate dependency updates and vulnerability scanning. The project is [describe the project's size and complexity]. The goal of the workflow is to [describe the goals, e.g., improve code quality, automate deployments, reduce errors]. ``` * **Template 2 (GitHub Actions Specific):** ``` Design a GitHub Actions workflow for a [TypeScript/JavaScript/Python/etc.] project named "[Project Name]". The workflow should: * **Trigger:** Specify the triggers for the workflow (e.g., pull requests, pushes to main branch, scheduled events). * **Jobs:** Define the jobs in the workflow, including their dependencies and execution order. * **Steps:** Specify the steps in each job, including the commands to execute and the actions to use. * **Environment Variables:** Use environment variables to configure the workflow. * **Secrets:** Store sensitive information (e.g., API keys, passwords) as secrets. * **Caching:** Use caching to speed up the workflow. * **Artifacts:** Store build artifacts (e.g., compiled code, documentation) for later use. * **Notifications:** Send notifications on workflow completion or failure. * **Error Handling:** Implement error handling to gracefully handle failures. * **Specific Tasks:** Include steps for [list specific tasks, e.g., running unit tests, building the application, deploying to AWS, publishing to npm]. Provide a YAML configuration file for the GitHub Actions workflow. The project is [describe the project's size and complexity]. The goal of the workflow is to [describe the goals, e.g., automate deployments, improve code quality, reduce errors]. ``` **Key Considerations for Using These Templates:** * **Be Specific:** The more specific you are in your prompt, the better the results will be. Provide as much context as possible about the project, its goals, and its requirements. * **Iterate:** Don't expect the AI to generate the perfect plan on the first try. Review the output carefully and iterate on the prompt to refine the plan. * **Customize:** These are just templates. Customize them to fit the specific needs of your project. * **Review and Validate:** Always review and validate the AI-generated plan to ensure that it is accurate, complete, and feasible. Don't blindly trust the AI. * **Consider the AI's Limitations:** AI assistants are good at generating text, but they may not have a deep understanding of software development principles or best practices. Use your own expertise to evaluate the AI's suggestions. By using these templates and following these guidelines, you can effectively leverage AI assistants to generate comprehensive plans for your TypeScript projects, API architectures, and GitHub workflows. Good luck!