diff --git a/README.md b/README.md
index a900624d..78c2c91b 100644
--- a/README.md
+++ b/README.md
@@ -4,13 +4,13 @@ Enhance your GitHub Copilot experience with community-contributed instructions,
## 🎯 GitHub Copilot Customization Features
-GitHub Copilot provides three main ways to customize AI responses and tailor assistance to your specific workflows, team guidelines, and project requirements:
+GitHub Copilot provides four main ways to customize AI responses and tailor assistance to your specific workflows, team guidelines, and project requirements:
-| **📋 [Custom Instructions](#-custom-instructions)** | **🎯 [Reusable Prompts](#-reusable-prompts)** | **🧩 [Custom Chat Modes](#-custom-chat-modes)** |
-| --- | --- | --- |
-| Define common guidelines for tasks like code generation, reviews, and commit messages. Describe *how* tasks should be performed
**Benefits:**
• Automatic inclusion in every chat request
• Repository-wide consistency
• Multiple implementation options | Create reusable, standalone prompts for specific tasks. Describe *what* should be done with optional task-specific guidelines
**Benefits:**
• Eliminate repetitive prompt writing
• Shareable across teams
• Support for variables and dependencies | Define chat behavior, available tools, and codebase interaction patterns within specific boundaries for each request
**Benefits:**
• Context-aware assistance
• Tool configuration
• Role-specific workflows |
+| **📋 [Custom Instructions](#-custom-instructions)** | **🎯 [Reusable Prompts](#-reusable-prompts)** | **🧩 [Custom Chat Modes](#-custom-chat-modes)** | **📁 [Collections](#-collections)** |
+| --- | --- | --- | --- |
+| Define common guidelines for tasks like code generation, reviews, and commit messages. Describe *how* tasks should be performed
**Benefits:**
• Automatic inclusion in every chat request
• Repository-wide consistency
• Multiple implementation options | Create reusable, standalone prompts for specific tasks. Describe *what* should be done with optional task-specific guidelines
**Benefits:**
• Eliminate repetitive prompt writing
• Shareable across teams
• Support for variables and dependencies | Define chat behavior, available tools, and codebase interaction patterns within specific boundaries for each request
**Benefits:**
• Context-aware assistance
• Tool configuration
• Role-specific workflows | Curated bundles of domain-specific instructions, prompts, and chat modes organized by technology or workflow
**Benefits:**
• Complete solution packages
• Domain-specific expertise
• Pre-configured workflows |
-> **💡 Pro Tip:** Custom instructions only affect Copilot Chat (not inline code completions). You can combine all three customization types - use custom instructions for general guidelines, prompt files for specific tasks, and chat modes to control the interaction context.
+> **💡 Pro Tip:** Custom instructions only affect Copilot Chat (not inline code completions). You can combine all four customization types - use custom instructions for general guidelines, prompt files for specific tasks, chat modes to control interaction context, and collections for domain-specific workflows.
## 📝 Contributing
@@ -199,6 +199,16 @@ Custom chat modes define specific behaviors and tools for GitHub Copilot Chat, e
> 💡 **Usage**: Create new chat modes using the command `Chat: Configure Chat Modes...`, then switch your chat mode in the Chat input from _Agent_ or _Ask_ to your own mode.
+## 📁 Collections
+
+Curated collections of prompts, instructions, and chat modes organized by specific domains or workflows:
+
+| Collection | Description | Contents |
+| ---------- | ----------- | -------- |
+| [Plan](collections/plan/README.md) | A curated collection of GitHub Copilot customizations focused on plan workflows and best practices. | 6 prompts |
+
+> 💡 **Usage**: Each collection contains domain-specific customizations. Navigate to a collection folder to find its specialized prompts, instructions, and chat modes.
+
## 📚 Additional Resources
- [VS Code Copilot Customization Documentation](https://code.visualstudio.com/docs/copilot/copilot-customization) - Official Microsoft documentation
diff --git a/collections/plan/README.md b/collections/plan/README.md
new file mode 100644
index 00000000..b8c0e6b9
--- /dev/null
+++ b/collections/plan/README.md
@@ -0,0 +1,27 @@
+# 🎯 Plan Collection
+
+A curated collection of GitHub Copilot customizations focused on plan workflows and best practices.
+
+## 📄 About This Collection
+
+This collection provides specialized prompts, instructions, and chat modes tailored for plan-related development tasks.
+
+## 🎯 Prompts
+
+Ready-to-use prompt templates for this collection:
+
+| Title | Description | Install |
+| ----- | ----------- | ------- |
+| [Epic Architecture Specification Prompt](prompts/plan-epic-arch.prompt.md) | Prompt for creating the high-level technical architecture for an Epic, based on a Product Requirements Document. | [](https://vscode.dev/redirect?url=vscode%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-epic-arch.prompt.md) [](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-epic-arch.prompt.md) |
+| [Epic Product Requirements Document (PRD) Prompt](prompts/plan-epic-pm.prompt.md) | Prompt for creating an Epic Product Requirements Document (PRD) for a new epic. This PRD will be used as input for generating a technical architecture specification. | [](https://vscode.dev/redirect?url=vscode%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-epic-pm.prompt.md) [](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-epic-pm.prompt.md) |
+| [Feature Implementation Plan Prompt](prompts/plan-feature-implementation.prompt.md) | Prompt for creating detailed feature implementation plans, following Epoch monorepo structure. | [](https://vscode.dev/redirect?url=vscode%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-feature-implementation.prompt.md) [](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-feature-implementation.prompt.md) |
+| [Feature PRD Prompt](prompts/plan-feature-prd.prompt.md) | Prompt for creating Product Requirements Documents (PRDs) for new features, based on an Epic. | [](https://vscode.dev/redirect?url=vscode%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-feature-prd.prompt.md) [](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-feature-prd.prompt.md) |
+| [GitHub Issue Planning & Project Automation Prompt](prompts/plan-github.prompt.md) | Issue Planning and Automation prompt that generates comprehensive project plans with Epic > Feature > Story/Enabler > Test hierarchy, dependencies, priorities, and automated tracking. | [](https://vscode.dev/redirect?url=vscode%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-github.prompt.md) [](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-github.prompt.md) |
+| [Test Planning & Quality Assurance Prompt](prompts/plan-test.prompt.md) | Test Planning and Quality Assurance prompt that generates comprehensive test strategies, task breakdowns, and quality validation plans for GitHub projects. | [](https://vscode.dev/redirect?url=vscode%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-test.prompt.md) [](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Achat-prompt%2Finstall%3Furl%3Dhttps%3A%2F%2Fraw.githubusercontent.com%2Fgithub%2Fawesome-copilot%2Fmain%2Fcollections%2Fplan%2Fprompts%2Fplan-test.prompt.md) |
+
+> 💡 **Usage**: Use `/prompt-name` in VS Code chat, run `Chat: Run Prompt` command, or hit the run button while you have a prompt open.
+
+## 🔗 Related
+
+- [Main Repository](../../) - Browse all available customizations
+- [Contributing Guide](../../CONTRIBUTING.md) - How to contribute to this collection
diff --git a/collections/plan/prompts/README.md b/collections/plan/prompts/README.md
new file mode 100644
index 00000000..808de4fd
--- /dev/null
+++ b/collections/plan/prompts/README.md
@@ -0,0 +1,138 @@
+# GitHub Copilot Prompt Library
+
+This directory contains specialized prompt files designed to work with GitHub Copilot to streamline the development process using a comprehensive hierarchical breakdown approach.
+
+## Core Planning Workflow
+
+This streamlined workflow covers the essential planning stages from epic definition through project management setup, with integrated testing and quality assurance.
+
+### Hierarchical Work Breakdown Structure
+
+Our workflow follows the Agile hierarchy: **Epic → Feature → Implementation → Project Management**, with each level providing specific value and granularity:
+
+- **Epic**: Large business capability spanning multiple features (milestone level)
+- **Feature**: Deliverable user-facing functionality within an epic
+- **Implementation**: Technical planning and architecture for feature delivery
+- **Project Management**: GitHub issues, automation, and delivery tracking
+
+---
+
+## Streamlined Development Flow
+
+```mermaid
+graph LR
+ A[Epic PRD] --> B[Epic Architecture]
+ B --> C[Feature PRD]
+ C --> D[Feature Implementation Plan]
+ D --> E[GitHub Project Setup]
+
+ subgraph "Core Planning Chain"
+ G["Epic → Feature → Implementation"]
+ H["Project Management"]
+ end
+```
+
+### Input/Output Chain
+
+1. **Epic PRD** → Business requirements and scope definition
+2. **Epic Architecture** → High-level technical approach and system design
+3. **Feature PRD** → Detailed feature specifications and user requirements
+4. **Feature Implementation** → Technical planning and development approach
+5. **GitHub Project Setup** → Automated project management and tracking
+
+---
+
+## Step-by-Step Execution Guide
+
+### 1. Epic Definition (Product Management)
+
+- Use `plan-epic-pm.prompt.md` to create an Epic PRD
+- **Input:** High-level epic idea or business requirement
+- **Output:** `/docs/ways-of-work/plan/epic/{epic-name}.md`
+
+### 2. Epic Architecture (Technical Leadership)
+
+- Use `plan-epic-arch.prompt.md` with the Epic PRD to define technical architecture
+- **Input:** Epic PRD from step 1
+- **Output:** `/docs/ways-of-work/plan/epic/{epic-name}-arch.md`
+
+### 3. Feature Definition (Product Management)
+
+- Use `plan-feature-prd.prompt.md` for each feature in the epic
+- **Input:** Epic PRD and Epic Architecture
+- **Output:** `/docs/ways-of-work/plan/{epic-name}/{feature-name}.md`
+
+### 4. Feature Implementation Planning (Engineering)
+
+- Use `plan-feature-implementation.prompt.md` to create technical implementation plan
+- **Input:** Feature PRD and Epic Architecture
+- **Output:** `/docs/ways-of-work/plan/{epic-name}/{feature-name}/implementation-plan.md`
+
+### 5. GitHub Project Setup (Project Management)
+
+- Use `plan-github.prompt.md` to generate automated project management and issue tracking
+- **Input:** Epic PRD, Epic Architecture, Feature PRD, Implementation Plan
+- **Output:** `/docs/ways-of-work/plan/{epic-name}/{feature-name}/project-plan.md`
+
+---
+
+## Best Practices
+
+- **Sequential Execution**: Follow the step-by-step guide in order for optimal results
+- **Document Attachment**: Always attach required input documents as specified in each prompt
+- **File Path Consistency**: Use absolute file paths for referencing outputs
+- **Version Control**: Maintain version control for all planning artifacts
+- **Review and Validate**: Review outputs before using as inputs for subsequent steps
+- **Iterative Refinement**: Use feedback loops to improve planning quality
+
+---
+
+## Available Prompts
+
+- **plan-epic-pm.prompt.md** – Epic Product Requirements Document
+- **plan-epic-arch.prompt.md** – Epic Technical Architecture Specification
+- **plan-feature-prd.prompt.md** – Feature Product Requirements Document
+- **plan-feature-implementation.prompt.md** – Feature Technical Implementation Plan
+- **plan-test.prompt.md** – Comprehensive Test Strategy (ISTQB & ISO 25010) - wip
+- **plan-github.prompt.md** – GitHub Project Management and Issue Planning
+
+---
+
+## AI Agent Integration & Automation
+
+- **Sequential Planning**: Copilot-driven workflow execution from epic to project management
+- **Document Chain Integration**: Each prompt builds on previous outputs for complete traceability
+- **Quality Gate Automation**: ISTQB framework integration with automated validation
+- **GitHub Integration**: Automated project setup and issue tracking from planning artifacts
+- **Multi-Modal Planning**: Business, technical, testing, and project management perspectives
+- **Artifact Management**: Structured file output with consistent naming and organization
+
+---
+
+## Simplified Workflow Pattern
+
+- **Epic Level**: Define business capability and technical architecture
+- **Feature Level**: Detailed requirements and implementation planning
+- **Project Level**: Comprehensive testing strategy and project management setup
+
+The process provides **complete traceability** from high-level business goals down to specific implementation plans and quality validation, with automated project management integration.
+
+---
+
+## Usage Patterns
+
+### Complete Epic Planning
+
+1. Epic PRD → Epic Architecture → Feature PRD → Implementation → Project Setup
+
+### Feature-Focused Planning
+
+1. Feature PRD → Implementation Plan → GitHub Setup
+
+### Project Management Setup
+
+1. Gather all artifacts → GitHub Project Planning → Automated issue creation
+
+---
+
+This streamlined planning workflow provides complete coverage from business requirements through technical implementation and quality assurance, with integrated project management automation for efficient delivery tracking.
diff --git a/collections/plan/prompts/plan-epic-arch.prompt.md b/collections/plan/prompts/plan-epic-arch.prompt.md
new file mode 100644
index 00000000..2e98c4e3
--- /dev/null
+++ b/collections/plan/prompts/plan-epic-arch.prompt.md
@@ -0,0 +1,66 @@
+---
+mode: 'agent'
+description: 'Prompt for creating the high-level technical architecture for an Epic, based on a Product Requirements Document.'
+---
+
+# Epic Architecture Specification Prompt
+
+## Goal
+
+Act as a Senior Software Architect. Your task is to take an Epic PRD and create a high-level technical architecture specification. This document will guide the development of the epic, outlining the major components, features, and technical enablers required.
+
+## Context Considerations
+
+- The Epic PRD from the Product Manager.
+- **Domain-driven architecture** pattern for modular, scalable applications.
+- **Self-hosted and SaaS deployment** requirements.
+- **Docker containerization** for all services.
+- **TypeScript/Next.js** stack with App Router.
+- **Turborepo monorepo** patterns.
+- **tRPC** for type-safe APIs.
+- **Stack Auth** for authentication.
+
+**Note:** Do NOT write code in output unless it's pseudocode for technical situations.
+
+## Output Format
+
+The output should be a complete Epic Architecture Specification in Markdown format, saved to `/docs/ways-of-work/plan/{epic-name}/arch.md`.
+
+### Specification Structure
+
+#### 1. Epic Architecture Overview
+
+- A brief summary of the technical approach for the epic.
+
+#### 2. System Architecture Diagram
+
+Create a comprehensive Mermaid diagram that illustrates the complete system architecture for this epic. The diagram should include:
+
+- **User Layer**: Show how different user types (web browsers, mobile apps, admin interfaces) interact with the system
+- **Application Layer**: Depict load balancers, application instances, and authentication services (Stack Auth)
+- **Service Layer**: Include tRPC APIs, background services, workflow engines (n8n), and any epic-specific services
+- **Data Layer**: Show databases (PostgreSQL), vector databases (Qdrant), caching layers (Redis), and external API integrations
+- **Infrastructure Layer**: Represent Docker containerization and deployment architecture
+
+Use clear subgraphs to organize these layers, apply consistent color coding for different component types, and show the data flow between components. Include both synchronous request paths and asynchronous processing flows where relevant to the epic.
+
+#### 3. High-Level Features & Technical Enablers
+
+- A list of the high-level features to be built.
+- A list of technical enablers (e.g., new services, libraries, infrastructure) required to support the features.
+
+#### 4. Technology Stack
+
+- A list of the key technologies, frameworks, and libraries to be used.
+
+#### 5. Technical Value
+
+- Estimate the technical value (e.g., High, Medium, Low) with a brief justification.
+
+#### 6. T-Shirt Size Estimate
+
+- Provide a high-level t-shirt size estimate for the epic (e.g., S, M, L, XL).
+
+## Context Template
+
+- **Epic PRD:** [The content of the Epic PRD markdown file]
diff --git a/collections/plan/prompts/plan-epic-pm.prompt.md b/collections/plan/prompts/plan-epic-pm.prompt.md
new file mode 100644
index 00000000..7eb3862b
--- /dev/null
+++ b/collections/plan/prompts/plan-epic-pm.prompt.md
@@ -0,0 +1,58 @@
+---
+mode: 'agent'
+description: 'Prompt for creating an Epic Product Requirements Document (PRD) for a new epic. This PRD will be used as input for generating a technical architecture specification.'
+---
+
+# Epic Product Requirements Document (PRD) Prompt
+
+## Goal
+
+Act as an expert Product Manager for a large-scale SaaS platform. Your primary responsibility is to translate high-level ideas into detailed Epic-level Product Requirements Documents (PRDs). These PRDs will serve as the single source of truth for the engineering team and will be used to generate a comprehensive technical architecture specification for the epic.
+
+Review the user's request for a new epic and generate a thorough PRD. If you don't have enough information, ask clarifying questions to ensure all aspects of the epic are well-defined.
+
+## Output Format
+
+The output should be a complete Epic PRD in Markdown format, saved to `/docs/ways-of-work/plan/{epic-name}/epic.md`.
+
+### PRD Structure
+
+#### 1. Epic Name
+
+- A clear, concise, and descriptive name for the epic.
+
+#### 2. Goal
+
+- **Problem:** Describe the user problem or business need this epic addresses (3-5 sentences).
+- **Solution:** Explain how this epic solves the problem at a high level.
+- **Impact:** What are the expected outcomes or metrics to be improved (e.g., user engagement, conversion rate, revenue)?
+
+#### 3. User Personas
+
+- Describe the target user(s) for this epic.
+
+#### 4. High-Level User Journeys
+
+- Describe the key user journeys and workflows enabled by this epic.
+
+#### 5. Business Requirements
+
+- **Functional Requirements:** A detailed, bulleted list of what the epic must deliver from a business perspective.
+- **Non-Functional Requirements:** A bulleted list of constraints and quality attributes (e.g., performance, security, accessibility, data privacy).
+
+#### 6. Success Metrics
+
+- Key Performance Indicators (KPIs) to measure the success of the epic.
+
+#### 7. Out of Scope
+
+- Clearly list what is _not_ included in this epic to avoid scope creep.
+
+#### 8. Business Value
+
+- Estimate the business value (e.g., High, Medium, Low) with a brief justification.
+
+## Context Template
+
+- **Epic Idea:** [A high-level description of the epic from the user]
+- **Target Users:** [Optional: Any initial thoughts on who this is for]
diff --git a/collections/plan/prompts/plan-feature-implementation.prompt.md b/collections/plan/prompts/plan-feature-implementation.prompt.md
new file mode 100644
index 00000000..8ea246e1
--- /dev/null
+++ b/collections/plan/prompts/plan-feature-implementation.prompt.md
@@ -0,0 +1,128 @@
+---
+mode: 'agent'
+description: 'Prompt for creating detailed feature implementation plans, following Epoch monorepo structure.'
+---
+
+# Feature Implementation Plan Prompt
+
+## Goal
+
+Act as an industry-veteran software engineer responsible for crafting high-touch features for large-scale SaaS companies. Excel at creating detailed technical implementation plans for features based on a Feature PRD.
+Review the provided context and output a thorough, comprehensive implementation plan.
+**Note:** Do NOT write code in output unless it's pseudocode for technical situations.
+
+## Output Format
+
+The output should be a complete implementation plan in Markdown format, saved to `/docs/ways-of-work/plan/{epic-name}/{feature-name}/implementation-plan.md`.
+
+### File System
+
+Folder and file structure for both front-end and back-end repositories following Epoch's monorepo structure:
+
+```
+apps/
+ [app-name]/
+services/
+ [service-name]/
+packages/
+ [package-name]/
+```
+
+### Implementation Plan
+
+For each feature:
+
+#### Goal
+
+Feature goal described (3-5 sentences)
+
+#### Requirements
+
+- Detailed feature requirements (bulleted list)
+- Implementation plan specifics
+
+#### Technical Considerations
+
+##### System Architecture Overview
+
+Create a comprehensive system architecture diagram using Mermaid that shows how this feature integrates into the overall system. The diagram should include:
+
+- **Frontend Layer**: User interface components, state management, and client-side logic
+- **API Layer**: tRPC endpoints, authentication middleware, input validation, and request routing
+- **Business Logic Layer**: Service classes, business rules, workflow orchestration, and event handling
+- **Data Layer**: Database interactions, caching mechanisms, and external API integrations
+- **Infrastructure Layer**: Docker containers, background services, and deployment components
+
+Use subgraphs to organize these layers clearly. Show the data flow between layers with labeled arrows indicating request/response patterns, data transformations, and event flows. Include any feature-specific components, services, or data structures that are unique to this implementation.
+
+- **Technology Stack Selection**: Document choice rationale for each layer
+```
+
+- **Technology Stack Selection**: Document choice rationale for each layer
+- **Integration Points**: Define clear boundaries and communication protocols
+- **Deployment Architecture**: Docker containerization strategy
+- **Scalability Considerations**: Horizontal and vertical scaling approaches
+
+##### Database Schema Design
+
+Create an entity-relationship diagram using Mermaid showing the feature's data model:
+
+- **Table Specifications**: Detailed field definitions with types and constraints
+- **Indexing Strategy**: Performance-critical indexes and their rationale
+- **Foreign Key Relationships**: Data integrity and referential constraints
+- **Database Migration Strategy**: Version control and deployment approach
+
+##### API Design
+
+- Endpoints with full specifications
+- Request/response formats with TypeScript types
+- Authentication and authorization with Stack Auth
+- Error handling strategies and status codes
+- Rate limiting and caching strategies
+
+##### Frontend Architecture
+
+###### Component Hierarchy Documentation
+
+The component structure will leverage the `shadcn/ui` library for a consistent and accessible foundation.
+
+**Layout Structure:**
+
+```
+Recipe Library Page
+├── Header Section (shadcn: Card)
+│ ├── Title (shadcn: Typography `h1`)
+│ ├── Add Recipe Button (shadcn: Button with DropdownMenu)
+│ │ ├── Manual Entry (DropdownMenuItem)
+│ │ ├── Import from URL (DropdownMenuItem)
+│ │ └── Import from PDF (DropdownMenuItem)
+│ └── Search Input (shadcn: Input with icon)
+├── Main Content Area (flex container)
+│ ├── Filter Sidebar (aside)
+│ │ ├── Filter Title (shadcn: Typography `h4`)
+│ │ ├── Category Filters (shadcn: Checkbox group)
+│ │ ├── Cuisine Filters (shadcn: Checkbox group)
+│ │ └── Difficulty Filters (shadcn: RadioGroup)
+│ └── Recipe Grid (main)
+│ └── Recipe Card (shadcn: Card)
+│ ├── Recipe Image (img)
+│ ├── Recipe Title (shadcn: Typography `h3`)
+│ ├── Recipe Tags (shadcn: Badge)
+│ └── Quick Actions (shadcn: Button - View, Edit)
+```
+
+- **State Flow Diagram**: Component state management using Mermaid
+- Reusable component library specifications
+- State management patterns with Zustand/React Query
+- TypeScript interfaces and types
+
+##### Security Performance
+
+- Authentication/authorization requirements
+- Data validation and sanitization
+- Performance optimization strategies
+- Caching mechanisms
+
+## Context Template
+
+- **Feature PRD:** [The content of the Feature PRD markdown file]
diff --git a/collections/plan/prompts/plan-feature-prd.prompt.md b/collections/plan/prompts/plan-feature-prd.prompt.md
new file mode 100644
index 00000000..3403f6bc
--- /dev/null
+++ b/collections/plan/prompts/plan-feature-prd.prompt.md
@@ -0,0 +1,61 @@
+---
+mode: 'agent'
+description: 'Prompt for creating Product Requirements Documents (PRDs) for new features, based on an Epic.'
+---
+
+# Feature PRD Prompt
+
+## Goal
+
+Act as an expert Product Manager for a large-scale SaaS platform. Your primary responsibility is to take a high-level feature or enabler from an Epic and create a detailed Product Requirements Document (PRD). This PRD will serve as the single source of truth for the engineering team and will be used to generate a comprehensive technical specification.
+
+Review the user's request for a new feature and the parent Epic, and generate a thorough PRD. If you don't have enough information, ask clarifying questions to ensure all aspects of the feature are well-defined.
+
+## Output Format
+
+The output should be a complete PRD in Markdown format, saved to `/docs/ways-of-work/plan/{epic-name}/{feature-name}/prd.md`.
+
+### PRD Structure
+
+#### 1. Feature Name
+
+- A clear, concise, and descriptive name for the feature.
+
+#### 2. Epic
+
+- Link to the parent Epic PRD and Architecture documents.
+
+#### 3. Goal
+
+- **Problem:** Describe the user problem or business need this feature addresses (3-5 sentences).
+- **Solution:** Explain how this feature solves the problem.
+- **Impact:** What are the expected outcomes or metrics to be improved (e.g., user engagement, conversion rate, etc.)?
+
+#### 4. User Personas
+
+- Describe the target user(s) for this feature.
+
+#### 5. User Stories
+
+- Write user stories in the format: "As a ``, I want to `` so that I can ``."
+- Cover the primary paths and edge cases.
+
+#### 6. Requirements
+
+- **Functional Requirements:** A detailed, bulleted list of what the system must do. Be specific and unambiguous.
+- **Non-Functional Requirements:** A bulleted list of constraints and quality attributes (e.g., performance, security, accessibility, data privacy).
+
+#### 7. Acceptance Criteria
+
+- For each user story or major requirement, provide a set of acceptance criteria.
+- Use a clear format, such as a checklist or Given/When/Then. This will be used to validate that the feature is complete and correct.
+
+#### 8. Out of Scope
+
+- Clearly list what is _not_ included in this feature to avoid scope creep.
+
+## Context Template
+
+- **Epic:** [Link to the parent Epic documents]
+- **Feature Idea:** [A high-level description of the feature request from the user]
+- **Target Users:** [Optional: Any initial thoughts on who this is for]
diff --git a/collections/plan/prompts/plan-github.prompt.md b/collections/plan/prompts/plan-github.prompt.md
new file mode 100644
index 00000000..215f86ab
--- /dev/null
+++ b/collections/plan/prompts/plan-github.prompt.md
@@ -0,0 +1,509 @@
+---
+mode: 'agent'
+description: 'Issue Planning and Automation prompt that generates comprehensive project plans with Epic > Feature > Story/Enabler > Test hierarchy, dependencies, priorities, and automated tracking.'
+---
+
+# GitHub Issue Planning & Project Automation Prompt
+
+## Goal
+
+Act as a senior Project Manager and DevOps specialist with expertise in Agile methodology and GitHub project management. Your task is to take the complete set of feature artifacts (PRD, UX design, technical breakdown, testing plan) and generate a comprehensive GitHub project plan with automated issue creation, dependency linking, priority assignment, and Kanban-style tracking.
+
+## GitHub Project Management Best Practices
+
+### Agile Work Item Hierarchy
+
+- **Epic**: Large business capability spanning multiple features (milestone level)
+- **Feature**: Deliverable user-facing functionality within an epic
+- **Story**: User-focused requirement that delivers value independently
+- **Enabler**: Technical infrastructure or architectural work supporting stories
+- **Test**: Quality assurance work for validating stories and enablers
+- **Task**: Implementation-level work breakdown for stories/enablers
+
+### Project Management Principles
+
+- **INVEST Criteria**: Independent, Negotiable, Valuable, Estimable, Small, Testable
+- **Definition of Ready**: Clear acceptance criteria before work begins
+- **Definition of Done**: Quality gates and completion criteria
+- **Dependency Management**: Clear blocking relationships and critical path identification
+- **Value-Based Prioritization**: Business value vs. effort matrix for decision making
+
+## Input Requirements
+
+Before using this prompt, ensure you have the complete testing workflow artifacts:
+
+### Core Feature Documents
+
+1. **Feature PRD**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}.md`
+2. **Technical Breakdown**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}/technical-breakdown.md`
+3. **Implementation Plan**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}/implementation-plan.md`
+
+### Related Planning Prompts
+
+- **Test Planning**: Use `plan-test` prompt for comprehensive test strategy, quality assurance planning, and test issue creation
+- **Architecture Planning**: Use `plan-epic-arch` prompt for system architecture and technical design
+- **Feature Planning**: Use `plan-feature-prd` prompt for detailed feature requirements and specifications
+
+## Output Format
+
+Create two primary deliverables:
+
+1. **Project Plan**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}/project-plan.md`
+2. **Issue Creation Checklist**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}/issues-checklist.md`
+
+### Project Plan Structure
+
+#### 1. Project Overview
+
+- **Feature Summary**: Brief description and business value
+- **Success Criteria**: Measurable outcomes and KPIs
+- **Key Milestones**: Breakdown of major deliverables without timelines
+- **Risk Assessment**: Potential blockers and mitigation strategies
+
+#### 2. Work Item Hierarchy
+
+```mermaid
+graph TD
+ A[Epic: {Epic Name}] --> B[Feature: {Feature Name}]
+ B --> C[Story 1: {User Story}]
+ B --> D[Story 2: {User Story}]
+ B --> E[Enabler 1: {Technical Work}]
+ B --> F[Enabler 2: {Infrastructure}]
+
+ C --> G[Task: Frontend Implementation]
+ C --> H[Task: API Integration]
+ C --> I[Test: E2E Scenarios]
+
+ D --> J[Task: Component Development]
+ D --> K[Task: State Management]
+ D --> L[Test: Unit Tests]
+
+ E --> M[Task: Database Schema]
+ E --> N[Task: Migration Scripts]
+
+ F --> O[Task: CI/CD Pipeline]
+ F --> P[Task: Monitoring Setup]
+```
+
+#### 3. GitHub Issues Breakdown
+
+##### Epic Issue Template
+
+```markdown
+# Epic: {Epic Name}
+
+## Epic Description
+
+{Epic summary from PRD}
+
+## Business Value
+
+- **Primary Goal**: {Main business objective}
+- **Success Metrics**: {KPIs and measurable outcomes}
+- **User Impact**: {How users will benefit}
+
+## Epic Acceptance Criteria
+
+- [ ] {High-level requirement 1}
+- [ ] {High-level requirement 2}
+- [ ] {High-level requirement 3}
+
+## Features in this Epic
+
+- [ ] #{feature-issue-number} - {Feature Name}
+
+## Definition of Done
+
+- [ ] All feature stories completed
+- [ ] End-to-end testing passed
+- [ ] Performance benchmarks met
+- [ ] Documentation updated
+- [ ] User acceptance testing completed
+
+## Labels
+
+`epic`, `{priority-level}`, `{value-tier}`
+
+## Milestone
+
+{Release version/date}
+
+## Estimate
+
+{Epic-level t-shirt size: XS, S, M, L, XL, XXL}
+```
+
+##### Feature Issue Template
+
+```markdown
+# Feature: {Feature Name}
+
+## Feature Description
+
+{Feature summary from PRD}
+
+## User Stories in this Feature
+
+- [ ] #{story-issue-number} - {User Story Title}
+- [ ] #{story-issue-number} - {User Story Title}
+
+## Technical Enablers
+
+- [ ] #{enabler-issue-number} - {Enabler Title}
+- [ ] #{enabler-issue-number} - {Enabler Title}
+
+## Dependencies
+
+**Blocks**: {List of issues this feature blocks}
+**Blocked by**: {List of issues blocking this feature}
+
+## Acceptance Criteria
+
+- [ ] {Feature-level requirement 1}
+- [ ] {Feature-level requirement 2}
+
+## Definition of Done
+
+- [ ] All user stories delivered
+- [ ] Technical enablers completed
+- [ ] Integration testing passed
+- [ ] UX review approved
+- [ ] Performance testing completed
+
+## Labels
+
+`feature`, `{priority-level}`, `{value-tier}`, `{component-name}`
+
+## Epic
+
+#{epic-issue-number}
+
+## Estimate
+
+{Story points or t-shirt size}
+```
+
+##### User Story Issue Template
+
+```markdown
+# User Story: {Story Title}
+
+## Story Statement
+
+As a **{user type}**, I want **{goal}** so that **{benefit}**.
+
+## Acceptance Criteria
+
+- [ ] {Specific testable requirement 1}
+- [ ] {Specific testable requirement 2}
+- [ ] {Specific testable requirement 3}
+
+## Technical Tasks
+
+- [ ] #{task-issue-number} - {Implementation task}
+- [ ] #{task-issue-number} - {Integration task}
+
+## Testing Requirements
+
+- [ ] #{test-issue-number} - {Test implementation}
+
+## Dependencies
+
+**Blocked by**: {Dependencies that must be completed first}
+
+## Definition of Done
+
+- [ ] Acceptance criteria met
+- [ ] Code review approved
+- [ ] Unit tests written and passing
+- [ ] Integration tests passing
+- [ ] UX design implemented
+- [ ] Accessibility requirements met
+
+## Labels
+
+`user-story`, `{priority-level}`, `frontend/backend/fullstack`, `{component-name}`
+
+## Feature
+
+#{feature-issue-number}
+
+## Estimate
+
+{Story points: 1, 2, 3, 5, 8}
+```
+
+##### Technical Enabler Issue Template
+
+```markdown
+# Technical Enabler: {Enabler Title}
+
+## Enabler Description
+
+{Technical work required to support user stories}
+
+## Technical Requirements
+
+- [ ] {Technical requirement 1}
+- [ ] {Technical requirement 2}
+
+## Implementation Tasks
+
+- [ ] #{task-issue-number} - {Implementation detail}
+- [ ] #{task-issue-number} - {Infrastructure setup}
+
+## User Stories Enabled
+
+This enabler supports:
+
+- #{story-issue-number} - {Story title}
+- #{story-issue-number} - {Story title}
+
+## Acceptance Criteria
+
+- [ ] {Technical validation 1}
+- [ ] {Technical validation 2}
+- [ ] Performance benchmarks met
+
+## Definition of Done
+
+- [ ] Implementation completed
+- [ ] Unit tests written
+- [ ] Integration tests passing
+- [ ] Documentation updated
+- [ ] Code review approved
+
+## Labels
+
+`enabler`, `{priority-level}`, `infrastructure/api/database`, `{component-name}`
+
+## Feature
+
+#{feature-issue-number}
+
+## Estimate
+
+{Story points or effort estimate}
+```
+
+#### 4. Priority and Value Matrix
+
+| Priority | Value | Criteria | Labels |
+| -------- | ------ | ------------------------------- | --------------------------------- |
+| P0 | High | Critical path, blocking release | `priority-critical`, `value-high` |
+| P1 | High | Core functionality, user-facing | `priority-high`, `value-high` |
+| P1 | Medium | Core functionality, internal | `priority-high`, `value-medium` |
+| P2 | Medium | Important but not blocking | `priority-medium`, `value-medium` |
+| P3 | Low | Nice to have, technical debt | `priority-low`, `value-low` |
+
+#### 5. Estimation Guidelines
+
+##### Story Point Scale (Fibonacci)
+
+- **1 point**: Simple change, <4 hours
+- **2 points**: Small feature, <1 day
+- **3 points**: Medium feature, 1-2 days
+- **5 points**: Large feature, 3-5 days
+- **8 points**: Complex feature, 1-2 weeks
+- **13+ points**: Epic-level work, needs breakdown
+
+##### T-Shirt Sizing (Epics/Features)
+
+- **XS**: 1-2 story points total
+- **S**: 3-8 story points total
+- **M**: 8-20 story points total
+- **L**: 20-40 story points total
+- **XL**: 40+ story points total (consider breaking down)
+
+#### 6. Dependency Management
+
+```mermaid
+graph LR
+ A[Epic Planning] --> B[Feature Definition]
+ B --> C[Enabler Implementation]
+ C --> D[Story Development]
+ D --> E[Testing Execution]
+ E --> F[Feature Delivery]
+
+ G[Infrastructure Setup] --> C
+ H[API Design] --> D
+ I[Database Schema] --> C
+ J[Authentication] --> D
+```
+
+##### Dependency Types
+
+- **Blocks**: Work that cannot proceed until this is complete
+- **Related**: Work that shares context but not blocking
+- **Prerequisite**: Required infrastructure or setup work
+- **Parallel**: Work that can proceed simultaneously
+
+#### 7. Sprint Planning Template
+
+##### Sprint Capacity Planning
+
+- **Team Velocity**: {Average story points per sprint}
+- **Sprint Duration**: {2-week sprints recommended}
+- **Buffer Allocation**: 20% for unexpected work and bug fixes
+- **Focus Factor**: 70-80% of total time on planned work
+
+##### Sprint Goal Definition
+
+```markdown
+## Sprint {N} Goal
+
+**Primary Objective**: {Main deliverable for this sprint}
+
+**Stories in Sprint**:
+
+- #{issue} - {Story title} ({points} pts)
+- #{issue} - {Story title} ({points} pts)
+
+**Total Commitment**: {points} story points
+**Success Criteria**: {Measurable outcomes}
+```
+
+#### 8. GitHub Project Board Configuration
+
+##### Column Structure (Kanban)
+
+1. **Backlog**: Prioritized and ready for planning
+2. **Sprint Ready**: Detailed and estimated, ready for development
+3. **In Progress**: Currently being worked on
+4. **In Review**: Code review, testing, or stakeholder review
+5. **Testing**: QA validation and acceptance testing
+6. **Done**: Completed and accepted
+
+##### Custom Fields Configuration
+
+- **Priority**: P0, P1, P2, P3
+- **Value**: High, Medium, Low
+- **Component**: Frontend, Backend, Infrastructure, Testing
+- **Estimate**: Story points or t-shirt size
+- **Sprint**: Current sprint assignment
+- **Assignee**: Responsible team member
+- **Epic**: Parent epic reference
+
+#### 9. Automation and GitHub Actions
+
+##### Automated Issue Creation
+
+```yaml
+name: Create Feature Issues
+
+on:
+ workflow_dispatch:
+ inputs:
+ feature_name:
+ description: 'Feature name'
+ required: true
+ epic_issue:
+ description: 'Epic issue number'
+ required: true
+
+jobs:
+ create-issues:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Create Feature Issue
+ uses: actions/github-script@v7
+ with:
+ script: |
+ const { data: epic } = await github.rest.issues.get({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: ${{ github.event.inputs.epic_issue }}
+ });
+
+ const featureIssue = await github.rest.issues.create({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ title: `Feature: ${{ github.event.inputs.feature_name }}`,
+ body: `# Feature: ${{ github.event.inputs.feature_name }}\n\n...`,
+ labels: ['feature', 'priority-medium'],
+ milestone: epic.data.milestone?.number
+ });
+```
+
+##### Automated Status Updates
+
+```yaml
+name: Update Issue Status
+
+on:
+ pull_request:
+ types: [opened, closed]
+
+jobs:
+ update-status:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Move to In Review
+ if: github.event.action == 'opened'
+ uses: actions/github-script@v7
+ # Move related issues to "In Review" column
+
+ - name: Move to Done
+ if: github.event.action == 'closed' && github.event.pull_request.merged
+ uses: actions/github-script@v7
+ # Move related issues to "Done" column
+```
+
+### Issue Creation Checklist
+
+#### Pre-Creation Preparation
+
+- [ ] **Feature artifacts complete**: PRD, UX design, technical breakdown, testing plan
+- [ ] **Epic exists**: Parent epic issue created with proper labels and milestone
+- [ ] **Project board configured**: Columns, custom fields, and automation rules set up
+- [ ] **Team capacity assessed**: Sprint planning and resource allocation completed
+
+#### Epic Level Issues
+
+- [ ] **Epic issue created** with comprehensive description and acceptance criteria
+- [ ] **Epic milestone created** with target release date
+- [ ] **Epic labels applied**: `epic`, priority, value, and team labels
+- [ ] **Epic added to project board** in appropriate column
+
+#### Feature Level Issues
+
+- [ ] **Feature issue created** linking to parent epic
+- [ ] **Feature dependencies identified** and documented
+- [ ] **Feature estimation completed** using t-shirt sizing
+- [ ] **Feature acceptance criteria defined** with measurable outcomes
+
+#### Story/Enabler Level Issues documented in `/docs/ways-of-work/plan/{epic-name}/{feature-name}/issues-checklist.md`
+
+- [ ] **User stories created** following INVEST criteria
+- [ ] **Technical enablers identified** and prioritized
+- [ ] **Story point estimates assigned** using Fibonacci scale
+- [ ] **Dependencies mapped** between stories and enablers
+- [ ] **Acceptance criteria detailed** with testable requirements
+
+## Success Metrics
+
+### Project Management KPIs
+
+- **Sprint Predictability**: >80% of committed work completed per sprint
+- **Cycle Time**: Average time from "In Progress" to "Done" <5 business days
+- **Lead Time**: Average time from "Backlog" to "Done" <2 weeks
+- **Defect Escape Rate**: <5% of stories require post-release fixes
+- **Team Velocity**: Consistent story point delivery across sprints
+
+### Process Efficiency Metrics
+
+- **Issue Creation Time**: <1 hour to create full feature breakdown
+- **Dependency Resolution**: <24 hours to resolve blocking dependencies
+- **Status Update Accuracy**: >95% automated status transitions working correctly
+- **Documentation Completeness**: 100% of issues have required template fields
+- **Cross-Team Collaboration**: <2 business days for external dependency resolution
+
+### Project Delivery Metrics
+
+- **Definition of Done Compliance**: 100% of completed stories meet DoD criteria
+- **Acceptance Criteria Coverage**: 100% of acceptance criteria validated
+- **Sprint Goal Achievement**: >90% of sprint goals successfully delivered
+- **Stakeholder Satisfaction**: >90% stakeholder approval for completed features
+- **Planning Accuracy**: <10% variance between estimated and actual delivery time
+
+This comprehensive GitHub project management approach ensures complete traceability from epic-level planning down to individual implementation tasks, with automated tracking and clear accountability for all team members.
diff --git a/collections/plan/prompts/plan-test.prompt.md b/collections/plan/prompts/plan-test.prompt.md
new file mode 100644
index 00000000..39d5979c
--- /dev/null
+++ b/collections/plan/prompts/plan-test.prompt.md
@@ -0,0 +1,365 @@
+---
+mode: 'agent'
+description: 'Test Planning and Quality Assurance prompt that generates comprehensive test strategies, task breakdowns, and quality validation plans for GitHub projects.'
+---
+
+# Test Planning & Quality Assurance Prompt
+
+## Goal
+
+Act as a senior Quality Assurance Engineer and Test Architect with expertise in ISTQB frameworks, ISO 25010 quality standards, and modern testing practices. Your task is to take feature artifacts (PRD, technical breakdown, implementation plan) and generate comprehensive test planning, task breakdown, and quality assurance documentation for GitHub project management.
+
+## Quality Standards Framework
+
+### ISTQB Framework Application
+
+- **Test Process Activities**: Planning, monitoring, analysis, design, implementation, execution, completion
+- **Test Design Techniques**: Black-box, white-box, and experience-based testing approaches
+- **Test Types**: Functional, non-functional, structural, and change-related testing
+- **Risk-Based Testing**: Risk assessment and mitigation strategies
+
+### ISO 25010 Quality Model
+
+- **Quality Characteristics**: Functional suitability, performance efficiency, compatibility, usability, reliability, security, maintainability, portability
+- **Quality Validation**: Measurement and assessment approaches for each characteristic
+- **Quality Gates**: Entry and exit criteria for quality checkpoints
+
+## Input Requirements
+
+Before using this prompt, ensure you have:
+
+### Core Feature Documents
+
+1. **Feature PRD**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}.md`
+2. **Technical Breakdown**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}/technical-breakdown.md`
+3. **Implementation Plan**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}/implementation-plan.md`
+4. **GitHub Project Plan**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}/project-plan.md`
+
+## Output Format
+
+Create comprehensive test planning documentation:
+
+1. **Test Strategy**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}/test-strategy.md`
+2. **Test Issues Checklist**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}/test-issues-checklist.md`
+3. **Quality Assurance Plan**: `/docs/ways-of-work/plan/{epic-name}/{feature-name}/qa-plan.md`
+
+### Test Strategy Structure
+
+#### 1. Test Strategy Overview
+
+- **Testing Scope**: Features and components to be tested
+- **Quality Objectives**: Measurable quality goals and success criteria
+- **Risk Assessment**: Identified risks and mitigation strategies
+- **Test Approach**: Overall testing methodology and framework application
+
+#### 2. ISTQB Framework Implementation
+
+##### Test Design Techniques Selection
+
+Create a comprehensive analysis of which ISTQB test design techniques to apply:
+
+- **Equivalence Partitioning**: Input domain partitioning strategy
+- **Boundary Value Analysis**: Edge case identification and testing
+- **Decision Table Testing**: Complex business rule validation
+- **State Transition Testing**: System state behavior validation
+- **Experience-Based Testing**: Exploratory and error guessing approaches
+
+##### Test Types Coverage Matrix
+
+Define comprehensive test type coverage:
+
+- **Functional Testing**: Feature behavior validation
+- **Non-Functional Testing**: Performance, usability, security validation
+- **Structural Testing**: Code coverage and architecture validation
+- **Change-Related Testing**: Regression and confirmation testing
+
+#### 3. ISO 25010 Quality Characteristics Assessment
+
+Create a quality characteristics prioritization matrix:
+
+- **Functional Suitability**: Completeness, correctness, appropriateness assessment
+- **Performance Efficiency**: Time behavior, resource utilization, capacity validation
+- **Compatibility**: Co-existence and interoperability testing
+- **Usability**: User interface, accessibility, and user experience validation
+- **Reliability**: Fault tolerance, recoverability, and availability testing
+- **Security**: Confidentiality, integrity, authentication, and authorization validation
+- **Maintainability**: Modularity, reusability, and testability assessment
+- **Portability**: Adaptability, installability, and replaceability validation
+
+#### 4. Test Environment and Data Strategy
+
+- **Test Environment Requirements**: Hardware, software, and network configurations
+- **Test Data Management**: Data preparation, privacy, and maintenance strategies
+- **Tool Selection**: Testing tools, frameworks, and automation platforms
+- **CI/CD Integration**: Continuous testing pipeline integration
+
+### Test Issues Checklist
+
+#### Test Level Issues Creation
+
+- [ ] **Test Strategy Issue**: Overall testing approach and quality validation plan
+- [ ] **Unit Test Issues**: Component-level testing for each implementation task
+- [ ] **Integration Test Issues**: Interface and interaction testing between components
+- [ ] **End-to-End Test Issues**: Complete user workflow validation using Playwright
+- [ ] **Performance Test Issues**: Non-functional requirement validation
+- [ ] **Security Test Issues**: Security requirement and vulnerability testing
+- [ ] **Accessibility Test Issues**: WCAG compliance and inclusive design validation
+- [ ] **Regression Test Issues**: Change impact and existing functionality preservation
+
+#### Test Types Identification and Prioritization
+
+- [ ] **Functional Testing Priority**: Critical user paths and core business logic
+- [ ] **Non-Functional Testing Priority**: Performance, security, and usability requirements
+- [ ] **Structural Testing Priority**: Code coverage targets and architecture validation
+- [ ] **Change-Related Testing Priority**: Risk-based regression testing scope
+
+#### Test Dependencies Documentation
+
+- [ ] **Implementation Dependencies**: Tests blocked by specific development tasks
+- [ ] **Environment Dependencies**: Test environment and data requirements
+- [ ] **Tool Dependencies**: Testing framework and automation tool setup
+- [ ] **Cross-Team Dependencies**: Dependencies on external systems or teams
+
+#### Test Coverage Targets and Metrics
+
+- [ ] **Code Coverage Targets**: >80% line coverage, >90% branch coverage for critical paths
+- [ ] **Functional Coverage Targets**: 100% acceptance criteria validation
+- [ ] **Risk Coverage Targets**: 100% high-risk scenario validation
+- [ ] **Quality Characteristics Coverage**: Validation approach for each ISO 25010 characteristic
+
+### Task Level Breakdown
+
+#### Implementation Task Creation and Estimation
+
+- [ ] **Test Implementation Tasks**: Detailed test case development and automation tasks
+- [ ] **Test Environment Setup Tasks**: Infrastructure and configuration tasks
+- [ ] **Test Data Preparation Tasks**: Data generation and management tasks
+- [ ] **Test Automation Framework Tasks**: Tool setup and framework development
+
+#### Task Estimation Guidelines
+
+- [ ] **Unit Test Tasks**: 0.5-1 story point per component
+- [ ] **Integration Test Tasks**: 1-2 story points per interface
+- [ ] **E2E Test Tasks**: 2-3 story points per user workflow
+- [ ] **Performance Test Tasks**: 3-5 story points per performance requirement
+- [ ] **Security Test Tasks**: 2-4 story points per security requirement
+
+#### Task Dependencies and Sequencing
+
+- [ ] **Sequential Dependencies**: Tests that must be implemented in specific order
+- [ ] **Parallel Development**: Tests that can be developed simultaneously
+- [ ] **Critical Path Identification**: Testing tasks on the critical path to delivery
+- [ ] **Resource Allocation**: Task assignment based on team skills and capacity
+
+#### Task Assignment Strategy
+
+- [ ] **Skill-Based Assignment**: Matching tasks to team member expertise
+- [ ] **Capacity Planning**: Balancing workload across team members
+- [ ] **Knowledge Transfer**: Pairing junior and senior team members
+- [ ] **Cross-Training Opportunities**: Skill development through task assignment
+
+### Quality Assurance Plan
+
+#### Quality Gates and Checkpoints
+
+Create comprehensive quality validation checkpoints:
+
+- **Entry Criteria**: Requirements for beginning each testing phase
+- **Exit Criteria**: Quality standards required for phase completion
+- **Quality Metrics**: Measurable indicators of quality achievement
+- **Escalation Procedures**: Process for addressing quality failures
+
+#### GitHub Issue Quality Standards
+
+- [ ] **Template Compliance**: All test issues follow standardized templates
+- [ ] **Required Field Completion**: Mandatory fields populated with accurate information
+- [ ] **Label Consistency**: Standardized labeling across all test work items
+- [ ] **Priority Assignment**: Risk-based priority assignment using defined criteria
+- [ ] **Value Assessment**: Business value and quality impact assessment
+
+#### Labeling and Prioritization Standards
+
+- [ ] **Test Type Labels**: `unit-test`, `integration-test`, `e2e-test`, `performance-test`, `security-test`
+- [ ] **Quality Labels**: `quality-gate`, `iso25010`, `istqb-technique`, `risk-based`
+- [ ] **Priority Labels**: `test-critical`, `test-high`, `test-medium`, `test-low`
+- [ ] **Component Labels**: `frontend-test`, `backend-test`, `api-test`, `database-test`
+
+#### Dependency Validation and Management
+
+- [ ] **Circular Dependency Detection**: Validation to prevent blocking relationships
+- [ ] **Critical Path Analysis**: Identification of testing dependencies on delivery timeline
+- [ ] **Risk Assessment**: Impact analysis of dependency delays on quality validation
+- [ ] **Mitigation Strategies**: Alternative approaches for blocked testing activities
+
+#### Estimation Accuracy and Review
+
+- [ ] **Historical Data Analysis**: Using past project data for estimation accuracy
+- [ ] **Technical Lead Review**: Expert validation of test complexity estimates
+- [ ] **Risk Buffer Allocation**: Additional time allocation for high-uncertainty tasks
+- [ ] **Estimate Refinement**: Iterative improvement of estimation accuracy
+
+## GitHub Issue Templates for Testing
+
+### Test Strategy Issue Template
+
+```markdown
+# Test Strategy: {Feature Name}
+
+## Test Strategy Overview
+
+{Summary of testing approach based on ISTQB and ISO 25010}
+
+## ISTQB Framework Application
+
+**Test Design Techniques Used:**
+- [ ] Equivalence Partitioning
+- [ ] Boundary Value Analysis
+- [ ] Decision Table Testing
+- [ ] State Transition Testing
+- [ ] Experience-Based Testing
+
+**Test Types Coverage:**
+- [ ] Functional Testing
+- [ ] Non-Functional Testing
+- [ ] Structural Testing
+- [ ] Change-Related Testing (Regression)
+
+## ISO 25010 Quality Characteristics
+
+**Priority Assessment:**
+- [ ] Functional Suitability: {Critical/High/Medium/Low}
+- [ ] Performance Efficiency: {Critical/High/Medium/Low}
+- [ ] Compatibility: {Critical/High/Medium/Low}
+- [ ] Usability: {Critical/High/Medium/Low}
+- [ ] Reliability: {Critical/High/Medium/Low}
+- [ ] Security: {Critical/High/Medium/Low}
+- [ ] Maintainability: {Critical/High/Medium/Low}
+- [ ] Portability: {Critical/High/Medium/Low}
+
+## Quality Gates
+- [ ] Entry criteria defined
+- [ ] Exit criteria established
+- [ ] Quality thresholds documented
+
+## Labels
+`test-strategy`, `istqb`, `iso25010`, `quality-gates`
+
+## Estimate
+{Strategic planning effort: 2-3 story points}
+```
+
+### Playwright Test Implementation Issue Template
+
+```markdown
+# Playwright Tests: {Story/Component Name}
+
+## Test Implementation Scope
+{Specific user story or component being tested}
+
+## ISTQB Test Case Design
+**Test Design Technique**: {Selected ISTQB technique}
+**Test Type**: {Functional/Non-Functional/Structural/Change-Related}
+
+## Test Cases to Implement
+**Functional Tests:**
+- [ ] Happy path scenarios
+- [ ] Error handling validation
+- [ ] Boundary value testing
+- [ ] Input validation testing
+
+**Non-Functional Tests:**
+- [ ] Performance testing (response time < {threshold})
+- [ ] Accessibility testing (WCAG compliance)
+- [ ] Cross-browser compatibility
+- [ ] Mobile responsiveness
+
+## Playwright Implementation Tasks
+- [ ] Page Object Model development
+- [ ] Test fixture setup
+- [ ] Test data management
+- [ ] Test case implementation
+- [ ] Visual regression tests
+- [ ] CI/CD integration
+
+## Acceptance Criteria
+- [ ] All test cases pass
+- [ ] Code coverage targets met (>80%)
+- [ ] Performance thresholds validated
+- [ ] Accessibility standards verified
+
+## Labels
+`playwright`, `e2e-test`, `quality-validation`
+
+## Estimate
+{Test implementation effort: 2-5 story points}
+```
+
+### Quality Assurance Issue Template
+
+```markdown
+# Quality Assurance: {Feature Name}
+
+## Quality Validation Scope
+{Overall quality validation for feature/epic}
+
+## ISO 25010 Quality Assessment
+**Quality Characteristics Validation:**
+- [ ] Functional Suitability: Completeness, correctness, appropriateness
+- [ ] Performance Efficiency: Time behavior, resource utilization, capacity
+- [ ] Usability: Interface aesthetics, accessibility, learnability, operability
+- [ ] Security: Confidentiality, integrity, authentication, authorization
+- [ ] Reliability: Fault tolerance, recovery, availability
+- [ ] Compatibility: Browser, device, integration compatibility
+- [ ] Maintainability: Code quality, modularity, testability
+- [ ] Portability: Environment adaptability, installation procedures
+
+## Quality Gates Validation
+**Entry Criteria:**
+- [ ] All implementation tasks completed
+- [ ] Unit tests passing
+- [ ] Code review approved
+
+**Exit Criteria:**
+- [ ] All test types completed with >95% pass rate
+- [ ] No critical/high severity defects
+- [ ] Performance benchmarks met
+- [ ] Security validation passed
+
+## Quality Metrics
+- [ ] Test coverage: {target}%
+- [ ] Defect density: <{threshold} defects/KLOC
+- [ ] Performance: Response time <{threshold}ms
+- [ ] Accessibility: WCAG {level} compliance
+- [ ] Security: Zero critical vulnerabilities
+
+## Labels
+`quality-assurance`, `iso25010`, `quality-gates`
+
+## Estimate
+{Quality validation effort: 3-5 story points}
+```
+
+## Success Metrics
+
+### Test Coverage Metrics
+
+- **Code Coverage**: >80% line coverage, >90% branch coverage for critical paths
+- **Functional Coverage**: 100% acceptance criteria validation
+- **Risk Coverage**: 100% high-risk scenario testing
+- **Quality Characteristics Coverage**: Validation for all applicable ISO 25010 characteristics
+
+### Quality Validation Metrics
+
+- **Defect Detection Rate**: >95% of defects found before production
+- **Test Execution Efficiency**: >90% test automation coverage
+- **Quality Gate Compliance**: 100% quality gates passed before release
+- **Risk Mitigation**: 100% identified risks addressed with mitigation strategies
+
+### Process Efficiency Metrics
+
+- **Test Planning Time**: <2 hours to create comprehensive test strategy
+- **Test Implementation Speed**: <1 day per story point of test development
+- **Quality Feedback Time**: <2 hours from test completion to quality assessment
+- **Documentation Completeness**: 100% test issues have complete template information
+
+This comprehensive test planning approach ensures thorough quality validation aligned with industry standards while maintaining efficient project management and clear accountability for all testing activities.
diff --git a/update-readme.js b/update-readme.js
index f49e138b..2072909d 100755
--- a/update-readme.js
+++ b/update-readme.js
@@ -11,19 +11,33 @@ Enhance your GitHub Copilot experience with community-contributed instructions,
## 🎯 GitHub Copilot Customization Features
-GitHub Copilot provides three main ways to customize AI responses and tailor assistance to your specific workflows, team guidelines, and project requirements:
+GitHub Copilot provides four main ways to customize AI responses and tailor assistance to your specific workflows, team guidelines, and project requirements:
-| **📋 [Custom Instructions](#-custom-instructions)** | **🎯 [Reusable Prompts](#-reusable-prompts)** | **🧩 [Custom Chat Modes](#-custom-chat-modes)** |
-| --- | --- | --- |
-| Define common guidelines for tasks like code generation, reviews, and commit messages. Describe *how* tasks should be performed
**Benefits:**
• Automatic inclusion in every chat request
• Repository-wide consistency
• Multiple implementation options | Create reusable, standalone prompts for specific tasks. Describe *what* should be done with optional task-specific guidelines
**Benefits:**
• Eliminate repetitive prompt writing
• Shareable across teams
• Support for variables and dependencies | Define chat behavior, available tools, and codebase interaction patterns within specific boundaries for each request
**Benefits:**
• Context-aware assistance
• Tool configuration
• Role-specific workflows |
+| **📋 [Custom Instructions](#-custom-instructions)** | **🎯 [Reusable Prompts](#-reusable-prompts)** | **🧩 [Custom Chat Modes](#-custom-chat-modes)** | **📁 [Collections](#-collections)** |
+| --- | --- | --- | --- |
+| Define common guidelines for tasks like code generation, reviews, and commit messages. Describe *how* tasks should be performed
**Benefits:**
• Automatic inclusion in every chat request
• Repository-wide consistency
• Multiple implementation options | Create reusable, standalone prompts for specific tasks. Describe *what* should be done with optional task-specific guidelines
**Benefits:**
• Eliminate repetitive prompt writing
• Shareable across teams
• Support for variables and dependencies | Define chat behavior, available tools, and codebase interaction patterns within specific boundaries for each request
**Benefits:**
• Context-aware assistance
• Tool configuration
• Role-specific workflows | Curated bundles of domain-specific instructions, prompts, and chat modes organized by technology or workflow
**Benefits:**
• Complete solution packages
• Domain-specific expertise
• Pre-configured workflows |
-> **💡 Pro Tip:** Custom instructions only affect Copilot Chat (not inline code completions). You can combine all three customization types - use custom instructions for general guidelines, prompt files for specific tasks, and chat modes to control the interaction context.
+> **💡 Pro Tip:** Custom instructions only affect Copilot Chat (not inline code completions). You can combine all four customization types - use custom instructions for general guidelines, prompt files for specific tasks, chat modes to control interaction context, and collections for domain-specific workflows.
## 📝 Contributing
We welcome contributions! Please see our [Contributing Guide](./CONTRIBUTING.md) for details on how to submit new instructions and prompts.`,
+ collectionsSection: `## 📁 Collections
+
+Curated collections of prompts, instructions, and chat modes organized by specific domains or workflows:`,
+
+ collectionsUsage: `> 💡 **Usage**: Each collection contains domain-specific customizations. Navigate to a collection folder to find its specialized prompts, instructions, and chat modes.`,
+
+ collectionHeader: (collectionName) => `# 🎯 ${collectionName.charAt(0).toUpperCase() + collectionName.slice(1)} Collection
+
+A curated collection of GitHub Copilot customizations focused on ${collectionName} workflows and best practices.
+
+## 📄 About This Collection
+
+This collection provides specialized prompts, instructions, and chat modes tailored for ${collectionName}-related development tasks.`,
+
instructionsSection: `## 📋 Custom Instructions
Team and project-specific instructions to enhance GitHub Copilot's behavior for specific technologies and coding practices:`,
@@ -87,6 +101,73 @@ function safeFileOperation(operation, filePath, defaultValue = null) {
}
}
+/**
+ * Get all collections in the collections directory
+ */
+function getCollections(collectionsDir) {
+ if (!fs.existsSync(collectionsDir)) {
+ return [];
+ }
+
+ return fs.readdirSync(collectionsDir)
+ .filter(item => {
+ const itemPath = path.join(collectionsDir, item);
+ return fs.statSync(itemPath).isDirectory();
+ })
+ .sort();
+}
+
+/**
+ * Extract description from a collection's README or create default
+ */
+function getCollectionDescription(collectionPath) {
+ const readmePath = path.join(collectionPath, 'README.md');
+
+ if (fs.existsSync(readmePath)) {
+ return safeFileOperation(() => {
+ const content = fs.readFileSync(readmePath, 'utf8');
+ const lines = content.split('\n');
+
+ // Look for description in frontmatter first
+ let inFrontmatter = false;
+ for (const line of lines) {
+ if (line.trim() === '---') {
+ if (!inFrontmatter) {
+ inFrontmatter = true;
+ continue;
+ } else {
+ break;
+ }
+ }
+
+ if (inFrontmatter && line.includes('description:')) {
+ const match = line.match(/^description:\s*['"]?(.+?)['"]?$/);
+ if (match) {
+ return match[1];
+ }
+ }
+ }
+
+ // Look for first paragraph after headers
+ let foundHeader = false;
+ for (const line of lines) {
+ if (line.startsWith('#')) {
+ foundHeader = true;
+ continue;
+ }
+
+ if (foundHeader && line.trim() && !line.startsWith('#') && !line.startsWith('>')) {
+ return line.trim();
+ }
+ }
+
+ return null;
+ }, readmePath, null);
+ }
+
+ return null;
+}
+
function extractTitle(filePath) {
return safeFileOperation(
() => {
@@ -260,6 +341,8 @@ function extractDescription(filePath) {
/**
* Generate badges for installation links in VS Code and VS Code Insiders.
* @param {string} link - The relative link to the instructions or prompts file.
+ * @param {string} type - The type of customization (instructions, prompt, chatmode).
+ * @param {string} collectionPath - Optional collection path prefix for URLs.
* @returns {string} - Markdown formatted badges for installation.
*/
const vscodeInstallImage =
@@ -270,25 +353,36 @@ const repoBaseUrl =
"https://raw.githubusercontent.com/github/awesome-copilot/main";
const vscodeBaseUrl = "https://vscode.dev/redirect?url=";
const vscodeInsidersBaseUrl = "https://insiders.vscode.dev/redirect?url=";
-function makeBadges(link, type) {
+
+function makeBadges(link, type, collectionPath = '') {
+ const fullLink = collectionPath ? `${collectionPath}/${link}` : link;
return `[](${vscodeBaseUrl}${encodeURIComponent(
- `vscode:chat-${type}/install?url=${repoBaseUrl}/${link})`
+ `vscode:chat-${type}/install?url=${repoBaseUrl}/${fullLink})`
)} [](${vscodeInsidersBaseUrl}${encodeURIComponent(
- `vscode-insiders:chat-${type}/install?url=${repoBaseUrl}/${link})`
+ `vscode-insiders:chat-${type}/install?url=${repoBaseUrl}/${fullLink})`
)}`;
}
/**
* Generate the instructions section with a table of all instructions
*/
-function generateInstructionsSection(instructionsDir) {
+function generateInstructionsSection(instructionsDir, collectionPath = '') {
+ // Check if instructions directory exists
+ if (!fs.existsSync(instructionsDir)) {
+ return '';
+ }
+
// Get all instruction files
const instructionFiles = fs
.readdirSync(instructionsDir)
.filter((file) => file.endsWith(".md"))
.sort();
- console.log(`Found ${instructionFiles.length} instruction files`);
+ if (instructionFiles.length === 0) {
+ return '';
+ }
+
+ console.log(`Found ${instructionFiles.length} instruction files in ${instructionsDir}`);
// Create table header
let instructionsContent =
@@ -298,13 +392,13 @@ function generateInstructionsSection(instructionsDir) {
for (const file of instructionFiles) {
const filePath = path.join(instructionsDir, file);
const title = extractTitle(filePath);
- const link = encodeURI(`instructions/${file}`);
+ const link = encodeURI(collectionPath ? `instructions/${file}` : `instructions/${file}`);
// Check if there's a description in the frontmatter
const customDescription = extractDescription(filePath);
// Create badges for installation links
- const badges = makeBadges(link, "instructions");
+ const badges = makeBadges(link, 'instructions', collectionPath);
if (customDescription && customDescription !== "null") {
// Use the description from frontmatter
@@ -316,20 +410,37 @@ function generateInstructionsSection(instructionsDir) {
}
}
- return `${TEMPLATES.instructionsSection}\n\n${instructionsContent}\n${TEMPLATES.instructionsUsage}`;
+ const sectionHeader = collectionPath ?
+ "## 📋 Instructions\n\nCoding standards and best practices for this collection:" :
+ TEMPLATES.instructionsSection;
+
+ const sectionUsage = collectionPath ?
+ "> 💡 **Usage**: Copy these instructions to your `.github/copilot-instructions.md` file or create task-specific `.github/.instructions.md` files in your workspace's `.github/instructions` folder." :
+ TEMPLATES.instructionsUsage;
+
+ return `${sectionHeader}\n\n${instructionsContent}\n${sectionUsage}`;
}
/**
* Generate the prompts section with a table of all prompts
*/
-function generatePromptsSection(promptsDir) {
+function generatePromptsSection(promptsDir, collectionPath = '') {
+ // Check if prompts directory exists
+ if (!fs.existsSync(promptsDir)) {
+ return '';
+ }
+
// Get all prompt files
const promptFiles = fs
.readdirSync(promptsDir)
.filter((file) => file.endsWith(".prompt.md"))
.sort();
- console.log(`Found ${promptFiles.length} prompt files`);
+ if (promptFiles.length === 0) {
+ return '';
+ }
+
+ console.log(`Found ${promptFiles.length} prompt files in ${promptsDir}`);
// Create table header
let promptsContent =
@@ -345,7 +456,7 @@ function generatePromptsSection(promptsDir) {
const customDescription = extractDescription(filePath);
// Create badges for installation links
- const badges = makeBadges(link, "prompt");
+ const badges = makeBadges(link, 'prompt', collectionPath);
if (customDescription && customDescription !== "null") {
promptsContent += `| [${title}](${link}) | ${customDescription} | ${badges} |\n`;
@@ -354,16 +465,24 @@ function generatePromptsSection(promptsDir) {
}
}
- return `${TEMPLATES.promptsSection}\n\n${promptsContent}\n${TEMPLATES.promptsUsage}`;
+ const sectionHeader = collectionPath ?
+ "## 🎯 Prompts\n\nReady-to-use prompt templates for this collection:" :
+ TEMPLATES.promptsSection;
+
+ const sectionUsage = collectionPath ?
+ "> 💡 **Usage**: Use `/prompt-name` in VS Code chat, run `Chat: Run Prompt` command, or hit the run button while you have a prompt open." :
+ TEMPLATES.promptsUsage;
+
+ return `${sectionHeader}\n\n${promptsContent}\n${sectionUsage}`;
}
/**
* Generate the chat modes section with a table of all chat modes
*/
-function generateChatModesSection(chatmodesDir) {
+function generateChatModesSection(chatmodesDir, collectionPath = '') {
// Check if chatmodes directory exists
if (!fs.existsSync(chatmodesDir)) {
- console.log("Chat modes directory does not exist");
+ console.log(`Chat modes directory does not exist: ${chatmodesDir}`);
return "";
}
@@ -373,7 +492,7 @@ function generateChatModesSection(chatmodesDir) {
.filter((file) => file.endsWith(".chatmode.md"))
.sort();
- console.log(`Found ${chatmodeFiles.length} chat mode files`);
+ console.log(`Found ${chatmodeFiles.length} chat mode files in ${chatmodesDir}`);
// If no chat modes, return empty string
if (chatmodeFiles.length === 0) {
@@ -394,7 +513,7 @@ function generateChatModesSection(chatmodesDir) {
const customDescription = extractDescription(filePath);
// Create badges for installation links
- const badges = makeBadges(link, "chatmode");
+ const badges = makeBadges(link, 'chatmode', collectionPath);
if (customDescription && customDescription !== "null") {
chatmodesContent += `| [${title}](${link}) | ${customDescription} | ${badges} |\n`;
@@ -403,30 +522,150 @@ function generateChatModesSection(chatmodesDir) {
}
}
- return `${TEMPLATES.chatmodesSection}\n\n${chatmodesContent}\n${TEMPLATES.chatmodesUsage}`;
+ const sectionHeader = collectionPath ?
+ "## 🧩 Chat Modes\n\nCustom chat modes for this collection:" :
+ TEMPLATES.chatmodesSection;
+
+ const sectionUsage = collectionPath ?
+ "> 💡 **Usage**: Create new chat modes using the command `Chat: Configure Chat Modes...`, then switch your chat mode in the Chat input from _Agent_ or _Ask_ to your own mode." :
+ TEMPLATES.chatmodesUsage;
+
+ return `${sectionHeader}\n\n${chatmodesContent}\n${sectionUsage}`;
+}
+
+/**
+ * Generate the collections section with a table of all collections
+ */
+function generateCollectionsSection(collectionsDir) {
+ // Get all collections
+ const collections = getCollections(collectionsDir);
+
+ if (collections.length === 0) {
+ return '';
+ }
+
+ console.log(`Found ${collections.length} collections`);
+
+ // Create table header
+ let collectionsContent =
+ "| Collection | Description | Contents |\n| ---------- | ----------- | -------- |\n";
+
+ // Generate table rows for each collection
+ for (const collection of collections) {
+ const collectionPath = path.join(collectionsDir, collection);
+ const title = collection.charAt(0).toUpperCase() + collection.slice(1);
+ const link = `collections/${collection}/README.md`;
+
+ // Get description
+ const description = getCollectionDescription(collectionPath) ||
+ `Specialized ${collection} prompts and instructions`;
+
+ // Count contents
+ const promptsDir = path.join(collectionPath, 'prompts');
+ const instructionsDir = path.join(collectionPath, 'instructions');
+ const chatmodesDir = path.join(collectionPath, 'chatmodes');
+
+ let contents = [];
+
+ if (fs.existsSync(promptsDir)) {
+ const promptCount = fs.readdirSync(promptsDir).filter(f => f.endsWith('.prompt.md')).length;
+ if (promptCount > 0) contents.push(`${promptCount} prompts`);
+ }
+
+ if (fs.existsSync(instructionsDir)) {
+ const instructionCount = fs.readdirSync(instructionsDir).filter(f => f.endsWith('.md')).length;
+ if (instructionCount > 0) contents.push(`${instructionCount} instructions`);
+ }
+
+ if (fs.existsSync(chatmodesDir)) {
+ const chatmodeCount = fs.readdirSync(chatmodesDir).filter(f => f.endsWith('.chatmode.md')).length;
+ if (chatmodeCount > 0) contents.push(`${chatmodeCount} chat modes`);
+ }
+
+ const contentsText = contents.length > 0 ? contents.join(', ') : 'No items';
+
+ collectionsContent += `| [${title}](${link}) | ${description} | ${contentsText} |\n`;
+ }
+
+ return `${TEMPLATES.collectionsSection}\n\n${collectionsContent}\n${TEMPLATES.collectionsUsage}`;
}
/**
- * Generate the complete README.md content from scratch
+ * Generate README for a specific collection
*/
+function generateCollectionReadme(collectionPath, collectionName) {
+ const promptsDir = path.join(collectionPath, 'prompts');
+ const instructionsDir = path.join(collectionPath, 'instructions');
+ const chatmodesDir = path.join(collectionPath, 'chatmodes');
+
+ const collectionPathForBadges = `collections/${collectionName}`;
+
+ // Generate each section for the collection
+ const sections = [];
+
+ // Header
+ sections.push(TEMPLATES.collectionHeader(collectionName));
+
+ // Instructions section
+ const instructionsSection = generateInstructionsSection(instructionsDir, collectionPathForBadges);
+ if (instructionsSection) {
+ sections.push(instructionsSection);
+ }
+
+ // Prompts section
+ const promptsSection = generatePromptsSection(promptsDir, collectionPathForBadges);
+ if (promptsSection) {
+ sections.push(promptsSection);
+ }
+
+ // Chat modes section
+ const chatmodesSection = generateChatModesSection(chatmodesDir, collectionPathForBadges);
+ if (chatmodesSection) {
+ sections.push(chatmodesSection);
+ }
+
+ // Add footer
+ sections.push(`## 🔗 Related
+
+- [Main Repository](../../) - Browse all available customizations
+- [Contributing Guide](../../CONTRIBUTING.md) - How to contribute to this collection`);
+
+ return sections.join('\n\n');
+}
function generateReadme() {
const instructionsDir = path.join(__dirname, "instructions");
const promptsDir = path.join(__dirname, "prompts");
const chatmodesDir = path.join(__dirname, "chatmodes");
+ const collectionsDir = path.join(__dirname, "collections");
// Generate each section
const instructionsSection = generateInstructionsSection(instructionsDir);
const promptsSection = generatePromptsSection(promptsDir);
const chatmodesSection = generateChatModesSection(chatmodesDir);
+ const collectionsSection = generateCollectionsSection(collectionsDir);
// Build the complete README content with template sections
- let readmeContent = [TEMPLATES.header, instructionsSection, promptsSection];
+ let readmeContent = [TEMPLATES.header];
+
+ // Add main sections
+ if (instructionsSection) {
+ readmeContent.push(instructionsSection);
+ }
+
+ if (promptsSection) {
+ readmeContent.push(promptsSection);
+ }
// Only include chat modes section if we have any chat modes
if (chatmodesSection) {
readmeContent.push(chatmodesSection);
}
+ // Add collections section after chat modes if we have any
+ if (collectionsSection) {
+ readmeContent.push(collectionsSection);
+ }
+
// Add footer
readmeContent.push(TEMPLATES.footer);
@@ -456,6 +695,37 @@ try {
fs.writeFileSync(readmePath, newReadmeContent);
console.log("README.md created successfully!");
}
+
+ // Generate READMEs for all collections
+ const collectionsDir = path.join(__dirname, "collections");
+ const collections = getCollections(collectionsDir);
+
+ console.log(`\nProcessing ${collections.length} collections...`);
+
+ for (const collection of collections) {
+ const collectionPath = path.join(collectionsDir, collection);
+ const collectionReadmePath = path.join(collectionPath, "README.md");
+ const newCollectionContent = generateCollectionReadme(collectionPath, collection);
+
+ // Check if the collection README file already exists
+ if (fs.existsSync(collectionReadmePath)) {
+ const originalContent = fs.readFileSync(collectionReadmePath, "utf8");
+ const hasChanges = originalContent !== newCollectionContent;
+
+ if (hasChanges) {
+ fs.writeFileSync(collectionReadmePath, newCollectionContent);
+ console.log(`${collection}/README.md updated successfully!`);
+ } else {
+ console.log(`${collection}/README.md is already up to date. No changes needed.`);
+ }
+ } else {
+ // Create the collection README file if it doesn't exist
+ fs.writeFileSync(collectionReadmePath, newCollectionContent);
+ console.log(`${collection}/README.md created successfully!`);
+ }
+ }
+
+ console.log("\nAll README files processed successfully!");
} catch (error) {
console.error(`Error generating README.md: ${error.message}`);
process.exit(1);