workspace-architect 1.3.0

package/assets/prompts/create-specification.prompt.md

@@ -0,0 +1,127 @@
+---
+mode: 'agent'
+description: 'Create a new specification file for the solution, optimized for Generative AI consumption.'
+tools: ['changes', 'search/codebase', 'edit/editFiles', 'extensions', 'fetch', 'githubRepo', 'openSimpleBrowser', 'problems', 'runTasks', 'search', 'search/searchResults', 'runCommands/terminalLastCommand', 'runCommands/terminalSelection', 'testFailure', 'usages', 'vscodeAPI']
+---
+# Create Specification
+
+Your goal is to create a new specification file for `${input:SpecPurpose}`.
+
+The specification file must define the requirements, constraints, and interfaces for the solution components in a manner that is clear, unambiguous, and structured for effective use by Generative AIs. Follow established documentation standards and ensure the content is machine-readable and self-contained.
+
+## Best Practices for AI-Ready Specifications
+
+- Use precise, explicit, and unambiguous language.
+- Clearly distinguish between requirements, constraints, and recommendations.
+- Use structured formatting (headings, lists, tables) for easy parsing.
+- Avoid idioms, metaphors, or context-dependent references.
+- Define all acronyms and domain-specific terms.
+- Include examples and edge cases where applicable.
+- Ensure the document is self-contained and does not rely on external context.
+
+The specification should be saved in the [/spec/](/spec/) directory and named according to the following convention: `spec-[a-z0-9-]+.md`, where the name should be descriptive of the specification's content and starting with the highlevel purpose, which is one of [schema, tool, data, infrastructure, process, architecture, or design].
+
+The specification file must be formatted in well formed Markdown.
+
+Specification files must follow the template below, ensuring that all sections are filled out appropriately. The front matter for the markdown should be structured correctly as per the example following:
+
+```md
+---
+title: [Concise Title Describing the Specification's Focus]
+version: [Optional: e.g., 1.0, Date]
+date_created: [YYYY-MM-DD]
+last_updated: [Optional: YYYY-MM-DD]
+owner: [Optional: Team/Individual responsible for this spec]
+tags: [Optional: List of relevant tags or categories, e.g., `infrastructure`, `process`, `design`, `app` etc]
+---
+
+# Introduction
+
+[A short concise introduction to the specification and the goal it is intended to achieve.]
+
+## 1. Purpose & Scope
+
+[Provide a clear, concise description of the specification's purpose and the scope of its application. State the intended audience and any assumptions.]
+
+## 2. Definitions
+
+[List and define all acronyms, abbreviations, and domain-specific terms used in this specification.]
+
+## 3. Requirements, Constraints & Guidelines
+
+[Explicitly list all requirements, constraints, rules, and guidelines. Use bullet points or tables for clarity.]
+
+- **REQ-001**: Requirement 1
+- **SEC-001**: Security Requirement 1
+- **[3 LETTERS]-001**: Other Requirement 1
+- **CON-001**: Constraint 1
+- **GUD-001**: Guideline 1
+- **PAT-001**: Pattern to follow 1
+
+## 4. Interfaces & Data Contracts
+
+[Describe the interfaces, APIs, data contracts, or integration points. Use tables or code blocks for schemas and examples.]
+
+## 5. Acceptance Criteria
+
+[Define clear, testable acceptance criteria for each requirement using Given-When-Then format where appropriate.]
+
+- **AC-001**: Given [context], When [action], Then [expected outcome]
+- **AC-002**: The system shall [specific behavior] when [condition]
+- **AC-003**: [Additional acceptance criteria as needed]
+
+## 6. Test Automation Strategy
+
+[Define the testing approach, frameworks, and automation requirements.]
+
+- **Test Levels**: Unit, Integration, End-to-End
+- **Frameworks**: MSTest, FluentAssertions, Moq (for .NET applications)
+- **Test Data Management**: [approach for test data creation and cleanup]
+- **CI/CD Integration**: [automated testing in GitHub Actions pipelines]
+- **Coverage Requirements**: [minimum code coverage thresholds]
+- **Performance Testing**: [approach for load and performance testing]
+
+## 7. Rationale & Context
+
+[Explain the reasoning behind the requirements, constraints, and guidelines. Provide context for design decisions.]
+
+## 8. Dependencies & External Integrations
+
+[Define the external systems, services, and architectural dependencies required for this specification. Focus on **what** is needed rather than **how** it's implemented. Avoid specific package or library versions unless they represent architectural constraints.]
+
+### External Systems
+- **EXT-001**: [External system name] - [Purpose and integration type]
+
+### Third-Party Services
+- **SVC-001**: [Service name] - [Required capabilities and SLA requirements]
+
+### Infrastructure Dependencies
+- **INF-001**: [Infrastructure component] - [Requirements and constraints]
+
+### Data Dependencies
+- **DAT-001**: [External data source] - [Format, frequency, and access requirements]
+
+### Technology Platform Dependencies
+- **PLT-001**: [Platform/runtime requirement] - [Version constraints and rationale]
+
+### Compliance Dependencies
+- **COM-001**: [Regulatory or compliance requirement] - [Impact on implementation]
+
+**Note**: This section should focus on architectural and business dependencies, not specific package implementations. For example, specify "OAuth 2.0 authentication library" rather than "Microsoft.AspNetCore.Authentication.JwtBearer v6.0.1".
+
+## 9. Examples & Edge Cases
+
+    ```code
+    // Code snippet or data example demonstrating the correct application of the guidelines, including edge cases
+    ```
+
+## 10. Validation Criteria
+
+[List the criteria or tests that must be satisfied for compliance with this specification.]
+
+## 11. Related Specifications / Further Reading
+
+[Link to related spec 1]
+[Link to relevant external documentation]
+
+```

package/assets/prompts/create-spring-boot-java-project.prompt.md

@@ -0,0 +1,163 @@
+---
+mode: 'agent'
+description: 'Create Spring Boot Java Project Skeleton'
+---
+
+# Create Spring Boot Java project prompt
+
+- Please make sure you have the following software installed on your system:
+
+  - Java 21
+  - Docker
+  - Docker Compose
+
+- If you need to custom the project name, please change the `artifactId` and the `packageName` in [download-spring-boot-project-template](./create-spring-boot-java-project.prompt.md#download-spring-boot-project-template)
+
+- If you need to update the Spring Boot version, please change the `bootVersion` in [download-spring-boot-project-template](./create-spring-boot-java-project.prompt.md#download-spring-boot-project-template)
+
+## Check Java version
+
+- Run following command in terminal and check the version of Java
+
+```shell
+java -version
+```
+
+## Download Spring Boot project template
+
+- Run following command in terminal to download a Spring Boot project template
+
+```shell
+curl https://start.spring.io/starter.zip \
+  -d artifactId=${input:projectName:demo-java} \
+  -d bootVersion=3.4.5 \
+  -d dependencies=lombok,configuration-processor,web,data-jpa,postgresql,data-redis,data-mongodb,validation,cache,testcontainers \
+  -d javaVersion=21 \
+  -d packageName=com.example \
+  -d packaging=jar \
+  -d type=maven-project \
+  -o starter.zip
+```
+
+## Unzip the downloaded file
+
+- Run following command in terminal to unzip the downloaded file
+
+```shell
+unzip starter.zip -d ./${input:projectName:demo-java}
+```
+
+## Remove the downloaded zip file
+
+- Run following command in terminal to delete the downloaded zip file
+
+```shell
+rm -f starter.zip
+```
+
+## Change directory to the project root
+
+- Run following command in terminal to change directory to the project root
+
+```shell
+cd ${input:projectName:demo-java}
+```
+
+## Add additional dependencies
+
+- Insert `springdoc-openapi-starter-webmvc-ui` and `archunit-junit5` dependency into `pom.xml` file
+
+```xml
+<dependency>
+  <groupId>org.springdoc</groupId>
+  <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+  <version>2.8.6</version>
+</dependency>
+<dependency>
+  <groupId>com.tngtech.archunit</groupId>
+  <artifactId>archunit-junit5</artifactId>
+  <version>1.2.1</version>
+  <scope>test</scope>
+</dependency>
+```
+
+## Add SpringDoc, Redis, JPA and MongoDB configurations
+
+- Insert SpringDoc configurations into `application.properties` file
+
+```properties
+# SpringDoc configurations
+springdoc.swagger-ui.doc-expansion=none
+springdoc.swagger-ui.operations-sorter=alpha
+springdoc.swagger-ui.tags-sorter=alpha
+```
+
+- Insert Redis configurations into `application.properties` file
+
+```properties
+# Redis configurations
+spring.data.redis.host=localhost
+spring.data.redis.port=6379
+spring.data.redis.password=rootroot
+```
+
+- Insert JPA configurations into `application.properties` file
+
+```properties
+# JPA configurations
+spring.datasource.driver-class-name=org.postgresql.Driver
+spring.datasource.url=jdbc:postgresql://localhost:5432/postgres
+spring.datasource.username=postgres
+spring.datasource.password=rootroot
+spring.jpa.hibernate.ddl-auto=update
+spring.jpa.show-sql=true
+spring.jpa.properties.hibernate.format_sql=true
+```
+
+- Insert MongoDB configurations into `application.properties` file
+
+```properties
+# MongoDB configurations
+spring.data.mongodb.host=localhost
+spring.data.mongodb.port=27017
+spring.data.mongodb.authentication-database=admin
+spring.data.mongodb.username=root
+spring.data.mongodb.password=rootroot
+spring.data.mongodb.database=test
+```
+
+## Add `docker-compose.yaml` with Redis, PostgreSQL and MongoDB services
+
+- Create `docker-compose.yaml` at project root and add following services: `redis:6`, `postgresql:17` and `mongo:8`.
+
+  - redis service should have
+    - password `rootroot`
+    - mapping port 6379 to 6379
+    - mounting volume `./redis_data` to `/data`
+  - postgresql service should have
+    - password `rootroot`
+    - mapping port 5432 to 5432
+    - mounting volume `./postgres_data` to `/var/lib/postgresql/data`
+  - mongo service should have
+    - initdb root username `root`
+    - initdb root password `rootroot`
+    - mapping port 27017 to 27017
+    - mounting volume `./mongo_data` to `/data/db`
+
+## Add `.gitignore` file
+
+- Insert `redis_data`, `postgres_data` and `mongo_data` directories in `.gitignore` file
+
+## Run Maven test command
+
+- Run maven clean test command to check if the project is working
+
+```shell
+./mvnw clean test
+```
+
+## Run Maven run command (Optional)
+
+- (Optional) `docker-compose up -d` to start the services, `./mvnw spring-boot:run` to run the Spring Boot project, `docker-compose rm -sf` to stop the services.
+
+## Let's do this step by step

package/assets/prompts/create-spring-boot-kotlin-project.prompt.md

@@ -0,0 +1,147 @@
+---
+mode: 'agent'
+description: 'Create Spring Boot Kotlin Project Skeleton'
+---
+
+# Create Spring Boot Kotlin project prompt
+
+- Please make sure you have the following software installed on your system:
+
+  - Java 21
+  - Docker
+  - Docker Compose
+
+- If you need to custom the project name, please change the `artifactId` and the `packageName` in [download-spring-boot-project-template](./create-spring-boot-kotlin-project.prompt.md#download-spring-boot-project-template)
+
+- If you need to update the Spring Boot version, please change the `bootVersion` in [download-spring-boot-project-template](./create-spring-boot-kotlin-project.prompt.md#download-spring-boot-project-template)
+
+## Check Java version
+
+- Run following command in terminal and check the version of Java
+
+```shell
+java -version
+```
+
+## Download Spring Boot project template
+
+- Run following command in terminal to download a Spring Boot project template
+
+```shell
+curl https://start.spring.io/starter.zip \
+  -d artifactId=${input:projectName:demo-kotlin} \
+  -d bootVersion=3.4.5 \
+  -d dependencies=configuration-processor,webflux,data-r2dbc,postgresql,data-redis-reactive,data-mongodb-reactive,validation,cache,testcontainers \
+  -d javaVersion=21 \
+  -d language=kotlin \
+  -d packageName=com.example \
+  -d packaging=jar \
+  -d type=gradle-project-kotlin \
+  -o starter.zip
+```
+
+## Unzip the downloaded file
+
+- Run following command in terminal to unzip the downloaded file
+
+```shell
+unzip starter.zip -d ./${input:projectName:demo-kotlin}
+```
+
+## Remove the downloaded zip file
+
+- Run following command in terminal to delete the downloaded zip file
+
+```shell
+rm -f starter.zip
+```
+
+## Unzip the downloaded file
+
+- Run following command in terminal to unzip the downloaded file
+
+```shell
+unzip starter.zip -d ./${input:projectName:demo-kotlin}
+```
+
+## Add additional dependencies
+
+- Insert `springdoc-openapi-starter-webmvc-ui` and `archunit-junit5` dependency into `build.gradle.kts` file
+
+```gradle.kts
+dependencies {
+  implementation("org.springdoc:springdoc-openapi-starter-webflux-ui:2.8.6")
+  testImplementation("com.tngtech.archunit:archunit-junit5:1.2.1")
+}
+```
+
+- Insert SpringDoc configurations into `application.properties` file
+
+```properties
+# SpringDoc configurations
+springdoc.swagger-ui.doc-expansion=none
+springdoc.swagger-ui.operations-sorter=alpha
+springdoc.swagger-ui.tags-sorter=alpha
+```
+
+- Insert Redis configurations into `application.properties` file
+
+```properties
+# Redis configurations
+spring.data.redis.host=localhost
+spring.data.redis.port=6379
+spring.data.redis.password=rootroot
+```
+
+- Insert R2DBC configurations into `application.properties` file
+
+```properties
+# R2DBC configurations
+spring.r2dbc.url=r2dbc:postgresql://localhost:5432/postgres
+spring.r2dbc.username=postgres
+spring.r2dbc.password=rootroot
+
+spring.sql.init.mode=always
+spring.sql.init.platform=postgres
+spring.sql.init.continue-on-error=true
+```
+
+- Insert MongoDB configurations into `application.properties` file
+
+```properties
+# MongoDB configurations
+spring.data.mongodb.host=localhost
+spring.data.mongodb.port=27017
+spring.data.mongodb.authentication-database=admin
+spring.data.mongodb.username=root
+spring.data.mongodb.password=rootroot
+spring.data.mongodb.database=test
+```
+
+- Create `docker-compose.yaml` at project root and add following services: `redis:6`, `postgresql:17` and `mongo:8`.
+
+  - redis service should have
+    - password `rootroot`
+    - mapping port 6379 to 6379
+    - mounting volume `./redis_data` to `/data`
+  - postgresql service should have
+    - password `rootroot`
+    - mapping port 5432 to 5432
+    - mounting volume `./postgres_data` to `/var/lib/postgresql/data`
+  - mongo service should have
+    - initdb root username `root`
+    - initdb root password `rootroot`
+    - mapping port 27017 to 27017
+    - mounting volume `./mongo_data` to `/data/db`
+
+- Insert `redis_data`, `postgres_data` and `mongo_data` directories in `.gitignore` file
+
+- Run gradle clean test command to check if the project is working
+
+```shell
+./gradlew clean test
+```
+
+- (Optional) `docker-compose up -d` to start the services, `./gradlew spring-boot:run` to run the Spring Boot project, `docker-compose rm -sf` to stop the services.
+
+Let's do this step by step.

package/assets/prompts/create-technical-spike.prompt.md

@@ -0,0 +1,231 @@
+---
+mode: 'agent'
+description: 'Create time-boxed technical spike documents for researching and resolving critical development decisions before implementation.'
+tools: ['runCommands', 'runTasks', 'edit', 'search', 'extensions', 'usages', 'vscodeAPI', 'think', 'problems', 'changes', 'testFailure', 'openSimpleBrowser', 'fetch', 'githubRepo', 'todos', 'Microsoft Docs', 'search']
+---
+
+# Create Technical Spike Document
+
+Create time-boxed technical spike documents for researching critical questions that must be answered before development can proceed. Each spike focuses on a specific technical decision with clear deliverables and timelines.
+
+## Document Structure
+
+Create individual files in `${input:FolderPath|docs/spikes}` directory. Name each file using the pattern: `[category]-[short-description]-spike.md` (e.g., `api-copilot-integration-spike.md`, `performance-realtime-audio-spike.md`).
+
+```md
+---
+title: "${input:SpikeTitle}"
+category: "${input:Category|Technical}"
+status: "🔴 Not Started"
+priority: "${input:Priority|High}"
+timebox: "${input:Timebox|1 week}"
+created: [YYYY-MM-DD]
+updated: [YYYY-MM-DD]
+owner: "${input:Owner}"
+tags: ["technical-spike", "${input:Category|technical}", "research"]
+---
+
+# ${input:SpikeTitle}
+
+## Summary
+
+**Spike Objective:** [Clear, specific question or decision that needs resolution]
+
+**Why This Matters:** [Impact on development/architecture decisions]
+
+**Timebox:** [How much time allocated to this spike]
+
+**Decision Deadline:** [When this must be resolved to avoid blocking development]
+
+## Research Question(s)
+
+**Primary Question:** [Main technical question that needs answering]
+
+**Secondary Questions:**
+
+- [Related question 1]
+- [Related question 2]
+- [Related question 3]
+
+## Investigation Plan
+
+### Research Tasks
+
+- [ ] [Specific research task 1]
+- [ ] [Specific research task 2]
+- [ ] [Specific research task 3]
+- [ ] [Create proof of concept/prototype]
+- [ ] [Document findings and recommendations]
+
+### Success Criteria
+
+**This spike is complete when:**
+
+- [ ] [Specific criteria 1]
+- [ ] [Specific criteria 2]
+- [ ] [Clear recommendation documented]
+- [ ] [Proof of concept completed (if applicable)]
+
+## Technical Context
+
+**Related Components:** [List system components affected by this decision]
+
+**Dependencies:** [What other spikes or decisions depend on resolving this]
+
+**Constraints:** [Known limitations or requirements that affect the solution]
+
+## Research Findings
+
+### Investigation Results
+
+[Document research findings, test results, and evidence gathered]
+
+### Prototype/Testing Notes
+
+[Results from any prototypes, spikes, or technical experiments]
+
+### External Resources
+
+- [Link to relevant documentation]
+- [Link to API references]
+- [Link to community discussions]
+- [Link to examples/tutorials]
+
+## Decision
+
+### Recommendation
+
+[Clear recommendation based on research findings]
+
+### Rationale
+
+[Why this approach was chosen over alternatives]
+
+### Implementation Notes
+
+[Key considerations for implementation]
+
+### Follow-up Actions
+
+- [ ] [Action item 1]
+- [ ] [Action item 2]
+- [ ] [Update architecture documents]
+- [ ] [Create implementation tasks]
+
+## Status History
+
+| Date   | Status         | Notes                      |
+| ------ | -------------- | -------------------------- |
+| [Date] | 🔴 Not Started | Spike created and scoped   |
+| [Date] | 🟡 In Progress | Research commenced         |
+| [Date] | 🟢 Complete    | [Resolution summary]       |
+
+---
+
+_Last updated: [Date] by [Name]_
+```
+
+## Categories for Technical Spikes
+
+### API Integration
+
+- Third-party API capabilities and limitations
+- Integration patterns and authentication
+- Rate limits and performance characteristics
+
+### Architecture & Design
+
+- System architecture decisions
+- Design pattern applicability
+- Component interaction models
+
+### Performance & Scalability
+
+- Performance requirements and constraints
+- Scalability bottlenecks and solutions
+- Resource utilization patterns
+
+### Platform & Infrastructure
+
+- Platform capabilities and limitations
+- Infrastructure requirements
+- Deployment and hosting considerations
+
+### Security & Compliance
+
+- Security requirements and implementations
+- Compliance constraints
+- Authentication and authorization approaches
+
+### User Experience
+
+- User interaction patterns
+- Accessibility requirements
+- Interface design decisions
+
+## File Naming Conventions
+
+Use descriptive, kebab-case names that indicate the category and specific unknown:
+
+**API/Integration Examples:**
+
+- `api-copilot-chat-integration-spike.md`
+- `api-azure-speech-realtime-spike.md`
+- `api-vscode-extension-capabilities-spike.md`
+
+**Performance Examples:**
+
+- `performance-audio-processing-latency-spike.md`
+- `performance-extension-host-limitations-spike.md`
+- `performance-webrtc-reliability-spike.md`
+
+**Architecture Examples:**
+
+- `architecture-voice-pipeline-design-spike.md`
+- `architecture-state-management-spike.md`
+- `architecture-error-handling-strategy-spike.md`
+
+## Best Practices for AI Agents
+
+1. **One Question Per Spike:** Each document focuses on a single technical decision or research question
+
+2. **Time-Boxed Research:** Define specific time limits and deliverables for each spike
+
+3. **Evidence-Based Decisions:** Require concrete evidence (tests, prototypes, documentation) before marking as complete
+
+4. **Clear Recommendations:** Document specific recommendations and rationale for implementation
+
+5. **Dependency Tracking:** Identify how spikes relate to each other and impact project decisions
+
+6. **Outcome-Focused:** Every spike must result in an actionable decision or recommendation
+
+## Research Strategy
+
+### Phase 1: Information Gathering
+
+1. **Search existing documentation** using search/fetch tools
+2. **Analyze codebase** for existing patterns and constraints
+3. **Research external resources** (APIs, libraries, examples)
+
+### Phase 2: Validation & Testing
+
+1. **Create focused prototypes** to test specific hypotheses
+2. **Run targeted experiments** to validate assumptions
+3. **Document test results** with supporting evidence
+
+### Phase 3: Decision & Documentation
+
+1. **Synthesize findings** into clear recommendations
+2. **Document implementation guidance** for development team
+3. **Create follow-up tasks** for implementation
+
+## Tools Usage
+
+- **search/searchResults:** Research existing solutions and documentation
+- **fetch/githubRepo:** Analyze external APIs, libraries, and examples
+- **codebase:** Understand existing system constraints and patterns
+- **runTasks:** Execute prototypes and validation tests
+- **editFiles:** Update research progress and findings
+- **vscodeAPI:** Test VS Code extension capabilities and limitations
+
+Focus on time-boxed research that resolves critical technical decisions and unblocks development progress.