@langadventurellc/task-trellis-mcp 1.3.2 → 1.4.0

package/dist/resources/basic/prompts/create-epics.md

@@ -1,177 +0,0 @@
----
-description: Break down a project into major epics by analyzing the project specification
----
-
-# Create Epics Command
-
-Break down a project into major epics using the Trellis task management system by analyzing the project specification and gathering additional requirements as needed. Do not attempt to create multiple epics in parallel. Do them sequentially one at a time.
-
-## Goal
-
-Analyze a project's comprehensive specification to create well-structured epics that represent major work streams, ensuring complete coverage of all project requirements and enabling effective feature decomposition.
-
-## Process
-
-### 1. Identify Target Project
-
-#### Input
-
-`$ARGUMENTS`
-
-#### Project Context
-
-The project ID may be:
-
-- Provided in `input` (e.g., "P-inventory-mgmt")
-- Known from previous conversation context
-- Specified along with additional instructions in `input`
-
-#### Instructions
-
-Retrieve the project using MCP `get_issue` to access its comprehensive description and requirements.
-
-### 2. Analyze Project Specification
-
-**Thoroughly analyze the project description to identify natural epic boundaries:**
-
-- **Use context7 MCP tool** to research architectural patterns and best practices
-- **Search codebase** for similar epic structures or patterns
-- Extract all functional requirements from the project description
-- Identify major technical components and systems
-- Consider cross-cutting concerns (security, testing, deployment, monitoring)
-- Group related functionality into cohesive work streams
-- Identify dependencies between work streams
-- Consider development phases and prerequisites
-- Note any specific instructions provided in `input`
-
-### 3. Gather Additional Information
-
-**Ask clarifying questions as needed to refine the epic structure:**
-
-Use this structured approach:
-
-- **Ask one question at a time** with specific options
-- **Focus on epic boundaries** - understand where one epic ends and another begins
-- **Identify component relationships** - how epics interact with each other
-- **Continue until complete** - don't stop until you have clear epic structure
-
-Key areas to clarify:
-
-- **Epic Boundaries**: Where does one epic end and another begin?
-- **Dependencies**: Which epics must complete before others can start?
-- **Technical Grouping**: Should technical concerns be separate epics or integrated?
-- **Phases**: Should there be phase-based epics (MVP, Enhancement, etc.)?
-- **Non-functional**: How to handle security, performance, monitoring as epics?
-
-**Example questioning approach:**
-
-```
-How should the authentication system be organized as an epic?
-Options:
-- A) Separate epic for all authentication (login, registration, password reset)
-- B) Integrate authentication into each functional epic
-- C) Split into multiple epics (core auth, advanced features, integrations)
-```
-
-Continue until the epic structure:
-
-- Covers all aspects of the project specification
-- Has clear boundaries and scope
-- Enables parallel development where possible
-- Supports logical feature breakdown
-
-### 4. Generate Epic Structure
-
-For each epic, create:
-
-- **Title**: Clear, descriptive name (3-5 words)
-- **Description**: Comprehensive explanation including:
-  - Purpose and goals
-  - Major components and deliverables
-  - **Detailed Acceptance Criteria**: Specific, measurable requirements that define epic completion, including:
-    - Functional deliverables with clear success metrics
-    - Integration requirements with other epics or external systems
-    - Performance and quality standards specific to this epic
-    - Security and compliance requirements
-    - User experience and usability criteria
-    - Testing and validation requirements
-  - Technical considerations
-  - Dependencies on other epics
-  - Estimated scale (number of features)
-  - **User Stories** - Key user scenarios this epic addresses
-  - **Non-functional Requirements** - Performance, security, scalability considerations specific to this epic
-
-### 5. Create Epics Using MCP
-
-For each epic, call the Task Trellis MCP `create_issue` tool:
-
-- `type`: Set to `"epic"`
-- `parent`: The project ID
-- `title`: Generated epic title
-- `status`: Set to `"open"` (default, ready to begin work) or `"draft"` unless specified
-- `prerequisites`: List of epic IDs that must complete first
-- `description`: Comprehensive epic description with all elements from step 4
-
-**For standalone epics**: Simply omit the `parent` parameter entirely.
-
-### 6. Output Format
-
-After successful creation:
-
-```
-✅ Successfully created [N] epics for project "[Project Title]"
-
-📋 Created Epics:
-1. E-[id1]: [Epic 1 Title]
-   → Dependencies: none
-
-2. E-[id2]: [Epic 2 Title]
-   → Dependencies: E-[id1]
-
-3. E-[id3]: [Epic 3 Title]
-   → Dependencies: E-[id1], E-[id2]
-
-📊 Epic Summary:
-- Total Epics: [N]
-```
-
-## Simplicity Principles
-
-When creating epics, follow these guidelines:
-
-### Keep It Simple:
-
-- **No over-engineering** - Create only the epics needed for the project
-- **No extra features** - Don't add functionality that wasn't requested
-- **Choose straightforward approaches** - Simple epic structure over complex hierarchies
-- **Solve the actual problem** - Don't anticipate future requirements
-
-### Forbidden Patterns:
-
-- **NO premature optimization** - Don't optimize epic structure unless requested
-- **NO feature creep** - Stick to the specified project requirements
-- **NO complex dependencies** - Keep epic relationships simple and clear
-
-### Modular Architecture:
-
-- **Clear boundaries** - Each epic should have distinct, well-defined responsibilities
-- **Minimal coupling** - Epics should interact through clean interfaces, not internal dependencies
-- **High cohesion** - Related functionality should be grouped within the same epic
-- **Clean interfaces** - Define clear contracts between epics for data and functionality exchange
-
-## Question Guidelines
-
-Ask questions that:
-
-- **Clarify epic boundaries**: What functionality belongs together?
-- **Identify dependencies**: What must be built first?
-- **Consider team structure**: Can epics be worked on in parallel?
-- **Plan for phases**: MVP vs full implementation?
-- **Address non-functionals**: Where do performance/security requirements fit?
-
-<rules>
-  <critical>Use MCP tools for all operations (create_issue, get_issue, etc.)</critical>
-  <critical>Ask one question at a time with specific options</critical>
-  <critical>Continue asking questions until you have complete understanding of epic boundaries</critical>
-  <important>Epic descriptions must be detailed enough for feature creation</important>
-</rules>

package/dist/resources/basic/prompts/create-features.md

@@ -1,172 +0,0 @@
----
-description: Break down an epic into specific features by analyzing the epic specification
----
-
-# Create Features Command
-
-Break down an epic into specific features using the Trellis task management system by analyzing the epic specification and gathering additional requirements as needed. Do not attempt to create multiple features in parallel. Do them sequentially one at a time.
-
-## Goal
-
-Analyze an epic's comprehensive specification to create well-structured features that represent implementable functionality, ensuring complete coverage of the epic's scope and enabling effective task decomposition.
-
-**IMPORTANT**: Features must include actual changes, implementations, or deliverables. Do not create features that are purely research tasks or analysis tasks without any tangible output. Since all features and tasks are executed independently without context from other features or tasks, purely analytical work provides no value.
-
-## Process
-
-### 1. Identify Context and Requirements
-
-#### Input
-
-`$ARGUMENTS`
-
-#### Context Determination
-
-The input may contain:
-
-- **Epic ID**: (e.g., "E-user-auth") - Create features within an epic hierarchy
-- **Feature Requirements**: Direct description of standalone functionality needed
-- **Mixed**: Epic ID plus additional feature specifications
-
-#### Instructions
-
-**For Hierarchical Features:**
-
-- Retrieve the epic using MCP `get_issue` to access its comprehensive description, requirements, and parent project context
-
-**For Standalone Features:**
-
-- Analyze the provided requirements directly
-- No parent context needed, focus on the specific functionality described
-
-### 2. Analyze Requirements
-
-**Thoroughly analyze the requirements (epic description OR standalone requirements) to identify natural feature boundaries:**
-
-- **Search codebase** for similar feature patterns or implementations
-- Extract all deliverables and components from the epic description
-- Review architecture diagrams and technical specifications
-- Analyze user stories to identify discrete user-facing functionality
-- Consider non-functional requirements that need specific implementation
-- Group related functionality into cohesive features
-- Identify dependencies between features
-- Note any specific instructions provided in `input`
-
-### 3. Gather Additional Information
-
-**Ask clarifying questions as needed to refine the feature structure:**
-
-Use this structured approach:
-
-- **Ask one question at a time** with specific options
-- **Focus on feature boundaries** - understand what constitutes a complete, testable feature
-- **Identify component relationships** - how features interact with each other
-- **Continue until complete** - don't stop until you have clear feature structure
-
-Key areas to clarify:
-
-- **Feature Boundaries**: What constitutes a complete, testable feature?
-- **Dependencies**: Which features must be implemented before others?
-- **Technical Approach**: How should complex functionality be divided?
-- **Testing Strategy**: How can features be tested independently?
-- **Integration Points**: Where do features interface with each other?
-
-**Example questioning approach:**
-
-```
-How should the user registration feature be scoped?
-Options:
-- A) Basic registration only (email, password, confirmation)
-- B) Full registration with profile setup and email verification
-- C) Registration with social login integration included
-```
-
-Continue until the feature structure:
-
-- Covers all aspects of the epic specification
-- Represents 6-20 tasks worth of work per feature
-- Has clear implementation boundaries
-- Enables independent development and testing
-
-### 4. Generate Feature Structure
-
-For each feature, create:
-
-- **Title**: Clear, specific name (3-5 words)
-- **Description**: Comprehensive explanation including:
-  - Purpose and functionality
-  - Key components to implement
-  - **Detailed Acceptance Criteria**: Specific, measurable requirements that define feature completion, including:
-    - Functional behavior with specific input/output expectations
-    - User interface requirements and interaction patterns
-    - Data validation and error handling criteria
-    - Integration points with other features or systems
-    - Performance benchmarks and response time requirements
-    - Security validation and access control requirements
-    - Browser/platform compatibility requirements
-    - Accessibility and usability standards
-  - Technical requirements
-  - Dependencies on other features
-  - **Implementation Guidance** - Technical approach and patterns to follow
-  - **Testing Requirements** - How to verify the feature works correctly
-  - **Security Considerations** - Input validation, authorization, data protection needs
-  - **Performance Requirements** - Response times, resource usage constraints
-
-**Feature Granularity Guidelines:**
-
-Each feature should be sized appropriately for task breakdown:
-
-- **1-2 hours per task** - When broken down, each task should be completable in 1-2 hours
-- **Independent implementation** - Features should be implementable without blocking other features
-- **Testable boundaries** - Features should have clear success criteria and testing strategies
-
-### 5. Create Features Using MCP
-
-For each feature, call the Task Trellis MCP `create_issue` tool:
-
-- `type`: Set to `"feature"`
-- `parent`: The epic ID (optional - omit for standalone features)
-- `title`: Generated feature title
-- `status`: Set to `"open"` (default, ready to begin work) or `"draft"` unless specified
-- `prerequisites`: List of feature IDs that must complete first
-- `description`: Comprehensive feature description with all elements from step 4
-
-**For standalone features**: Simply omit the `parent` parameter entirely.
-
-### 6. Output Format
-
-After successful creation:
-
-```
-✅ Successfully created [N] features for epic "[Epic Title]"
-
-📋 Created Features:
-1. F-[id1]: [Feature 1 Title]
-   → Dependencies: none
-
-2. F-[id2]: [Feature 2 Title]
-   → Dependencies: F-[id1]
-
-3. F-[id3]: [Feature 3 Title]
-   → Dependencies: F-[id1], F-[id2]
-
-📊 Feature Summary:
-- Total Features: [N]
-```
-
-## Question Guidelines
-
-Ask questions that:
-
-- **Define feature scope**: What's included vs excluded?
-- **Clarify technical approach**: Specific technologies or patterns?
-- **Identify dependencies**: Build order and integration points?
-- **Consider testing**: How to verify feature completeness?
-
-<rules>
-  <critical>Use MCP tools for all operations (create_issue, get_issue, etc.)</critical>
-  <critical>Ask one question at a time with specific options</critical>
-  <critical>Continue asking questions until you have complete understanding of feature boundaries</critical>
-  <important>Feature descriptions must be detailed enough for task creation</important>
-  <important>Include implementation guidance and testing requirements</important>
-</rules>

package/dist/resources/basic/prompts/create-project.md

@@ -1,128 +0,0 @@
----
-description: Create a new project in the Trellis task management system by analyzing specifications and gathering requirements
----
-
-# Create Project Trellis Command
-
-Create a new project in the Trellis task management system by analyzing specifications provided and gathering additional requirements as needed.
-
-## Goal
-
-Transform project specifications into a comprehensive project definition with full context and requirements that enable other agents to effectively create epics, features, and ultimately implementable tasks.
-
-## Process
-
-### 1. Parse Input Specifications
-
-#### Specification Input
-
-`$ARGUMENTS`
-
-#### Instructions
-
-Read and analyze the specifications:
-
-- Extract key project goals, requirements, and constraints
-
-### 2. Analyze Project Context
-
-**Before gathering requirements, research the existing system:**
-
-- **Search codebase** for similar projects or patterns
-- **Identify existing architecture** and conventions
-- **Document discovered technologies** for consistency
-
-### 3. Gather Additional Requirements
-
-**Continue asking questions until you can create a complete project specification:**
-
-Use this structured approach:
-
-- **Ask one question at a time** with specific options
-- **Focus on decomposition** - break large concepts into smaller components
-- **Clarify boundaries** - understand where one component ends and another begins
-- **Continue until complete** - don't stop until you have full understanding
-
-Key areas to explore:
-
-- **Functional Requirements**: What specific capabilities must the system provide?
-- **Technical Architecture**: What technologies, frameworks, and patterns should be used?
-- **Integration Points**: What external systems or APIs need to be integrated?
-- **User Types**: Who will use this system and what are their needs?
-- **Performance Requirements**: What are the response time, load, and scaling needs?
-- **Security Requirements**: What authentication, authorization, and data protection is needed?
-- **Deployment Environment**: Where and how will this be deployed?
-- **Timeline & Phases**: Are there specific deadlines or phase requirements?
-- **Success Metrics**: How will project success be measured?
-
-**Example questioning approach:**
-
-```
-How should user authentication be handled in this project?
-Options:
-- A) Use existing authentication system (specify integration points)
-- B) Implement new authentication mechanism (specify requirements)
-- C) No authentication needed for this project
-```
-
-Continue asking clarifying questions until you have enough information to create a comprehensive project description that would enable another agent to:
-
-- Understand the full scope and vision
-- Create appropriate epics covering all aspects
-- Make informed technical decisions
-- Understand constraints and requirements
-
-### 4. Generate Project Title and Description
-
-Based on gathered information:
-
-- **Title**: Create a clear, concise project title (5-7 words)
-- **Description**: Write comprehensive project specification including:
-  - Executive summary
-  - Detailed functional requirements
-  - Technical requirements and constraints
-  - Architecture overview
-  - User stories or personas
-  - Non-functional requirements (performance, security, etc.)
-  - Integration requirements
-  - Deployment strategy
-  - **Detailed Acceptance Criteria**: Specific, measurable requirements that define feature completion, including:
-    - Functional behavior with specific input/output expectations
-    - User interface requirements and interaction patterns
-    - Data validation and error handling criteria
-    - Integration points with other features or systems
-    - Performance benchmarks and response time requirements
-    - Security validation and access control requirements
-    - Browser/platform compatibility requirements
-    - Accessibility and usability standards
-  - Any other context needed for epic creation
-
-### 5. Create Project Using MCP
-
-Call the Task Trellis MCP `create_issue` tool to create the project with the following parameters:
-
-- `type`: Set to `"project"`
-- `title`: The generated project title
-- `status`: Set to `"open"` (default, ready to begin work) or `"draft"` unless specified
-- `description`: The comprehensive project description generated in the previous step
-
-### 6. Output Format
-
-After successful creation:
-
-```
-✅ Project created successfully!
-
-📁 Project: [Generated Title]
-📍 ID: [generated-id]
-📊 Status: [actual-status]
-
-📝 Project Summary:
-[First paragraph of description]
-```
-
-<rules>
-  <critical>Use MCP tools for all operations (create_issue, get_issue, activate, etc.)</critical>
-  <critical>Continue asking questions until you have a complete understanding of the requirements</critical>
-  <critical>Ask one question at a time with specific options</critical>
-</rules>