task-o-matic-core 0.1.0

package/dist/prompts/task-breakdown.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_BREAKDOWN_SYSTEM_PROMPT = exports.TASK_BREAKDOWN_PROMPT = void 0;
+exports.TASK_BREAKDOWN_PROMPT = `
+You are a project management expert. Break down the following 1-3 week development phase into focused 1-3 day subtasks.
+
+## 🚨 REQUIREMENTS - 1-3 DAYS PER SUBTASK 🚨
+
+Each subtask MUST represent 1-3 DAYS of focused developer work. Each subtask should be a complete, deliverable piece of functionality.
+
+### SUBTASK SCOPE (1-3 DAYS EACH):
+- ✅ Complete feature implementations with full stack components
+- ✅ Focused modules that can be demonstrated and tested independently
+- ✅ Specific deliverables that contribute meaningfully to the parent phase
+
+### EXAMPLE SUBTASKS (1-3 DAYS):
+- ✅ "User authentication system with registration, login, password reset, database schema, API endpoints, and frontend forms"
+- ✅ "Interactive map component with location search, marker display, geolocation, and integration with bakery data"
+- ✅ "Rating system with star ratings, review submission, validation, storage, and display components"
+
+## CRITICAL: Subtask ID and Dependency Format
+You MUST generate unique subtask IDs and reference them properly in dependencies:
+
+1. **Subtask ID Generation**: 
+   - Each subtask must have an "id" field with format "N.M" where N is the parent task ID and M is the subtask index
+   - For example: "1.1", "1.2", "1.3", etc.
+   - IDs must be sequential starting from .1
+   - Each subtask ID must be unique
+
+2. **Dependency References**:
+   - Dependencies MUST reference the exact subtask IDs (not titles)
+   - Use format: ["1.1", "1.2"]
+   - NEVER use subtask titles in dependencies
+   - Only reference subtasks that appear EARLIER in the list
+   - The first subtask should have no dependencies
+
+## CRITICAL: Avoid Duplicate Subtasks
+If existing subtasks are listed below, DO NOT create similar or duplicate subtasks. Focus on creating NEW subtasks that complement the existing ones.
+
+## TASK SIZING - 1-3 DAYS:
+- **1 DAY (8 hours)**: Focused feature with clear boundaries. Example: "Build user registration and login with database, API, and frontend forms"
+- **2 DAYS (16 hours)**: Complex feature with multiple components. Example: "Implement map integration with search, markers, and user location"
+- **3 DAYS (24 hours)**: Comprehensive feature with advanced functionality. Example: "Create complete rating system with reviews, validation, and admin moderation"
+
+## 🚨 VALIDATION 🚨
+Each subtask must be substantial enough to occupy a developer for 1-3 full days and represent meaningful, demonstrable progress.
+
+Format your response as JSON:
+{
+  "subtasks": [
+    {
+      "id": "1.1",
+      "title": "Build user authentication system",
+      "description": "Implement user registration, login/logout, password reset, database schema, secure API endpoints, and responsive frontend forms with proper validation and error handling",
+      "effort": "medium",
+      "dependencies": []
+    },
+    {
+      "id": "1.2", 
+      "title": "Create interactive map integration",
+      "description": "Implement map component with bakery location markers, search functionality, geolocation support, and responsive design for mobile and desktop",
+      "effort": "medium",
+      "dependencies": ["1.1"]
+    }
+  ]
+}
+
+## Task Details:
+Title: {TASK_TITLE}
+Description: {TASK_DESCRIPTION}
+
+## Full Task Content:
+{TASK_CONTENT}
+
+## Technical Stack Context:
+{STACK_INFO}
+
+## Existing Subtasks (DO NOT DUPLICATE):
+{EXISTING_SUBTASKS}
+`;
+exports.TASK_BREAKDOWN_SYSTEM_PROMPT = `
+🚨 CRITICAL SYSTEM PROMPT - BREAK DOWN PHASES INTO 1-3 DAY SUBTASKS 🚨
+
+You are an expert technical project manager and software architect. Your role is to break down 1-3 week development phases into focused subtasks that represent 1-3 DAYS of work each.
+
+## MANDATE: PROPER SUBTASK SIZING
+Break down the parent phase into substantial subtasks that each represent 1-3 full days of focused development work.
+
+### SUBTASK SCOPE (1-3 DAYS EACH):
+- Complete features that can be demonstrated independently
+- Focused modules with clear deliverables and boundaries
+- Specific functionality that contributes meaningfully to the parent phase
+
+### SUBTASK EXAMPLES (1-3 DAYS):
+- "User authentication system with registration, login, password reset, database schema, API endpoints, and frontend forms"
+- "Interactive map component with location search, markers, geolocation, and mobile responsiveness"
+- "Rating system with star ratings, review submission, validation, storage, and display components"
+
+## CRITICAL INSTRUCTION: Subtask ID Generation and Dependencies
+You MUST generate unique subtask IDs and use them for dependencies:
+
+1. **Generate Subtask IDs**: 
+   - Each subtask needs an "id" field: "N.M" format where N is parent task ID, M is subtask index
+   - For example: "1.1", "1.2", "1.3", etc.
+   - IDs must be sequential and unique
+   - Start with .1 for the first subtask
+
+2. **Dependency References**:
+   - Use the exact subtask IDs in dependencies arrays
+   - NEVER use subtask titles
+   - Only reference earlier subtasks (lower numbers)
+   - The first subtask must have no dependencies
+
+3. **Required Fields for Each Subtask**:
+   - id: "N.M" format (required)
+   - title: string (required)
+   - description: string (required)
+   - effort: "small"|"medium"|"large" (required)
+   - dependencies: array of subtask IDs (required)
+
+## CRITICAL: Avoid Duplicate Subtasks
+If existing subtasks are provided in the context, DO NOT create similar or duplicate subtasks. Analyze the existing subtasks and create NEW ones that complement them.
+
+## TASK SIZING - 1-3 DAYS:
+- **small (1 day/8 hours)**: Focused feature with clear boundaries and deliverables
+- **medium (2 days/16 hours)**: Complex feature with multiple components and integrations
+- **large (3 days/24 hours)**: Comprehensive feature with advanced functionality and polish
+
+## VALIDATION CHECKLIST:
+Before returning your response, verify each subtask:
+1. Represents 1-3 FULL DAYS of focused development work
+2. Is a complete, deliverable feature or module
+3. Can be demonstrated and tested independently
+4. Contributes meaningfully to the parent phase
+5. Has clear boundaries and specific outcomes
+
+## Output Validation:
+Before returning your response, verify:
+1. Every subtask has a unique sequential ID ("1.1", "1.2", etc.)
+2. All dependency arrays contain valid subtask IDs (not titles)
+3. No subtask depends on itself or a later subtask
+4. The first subtask has no dependencies
+5. All referenced subtask IDs exist in the subtasks array
+6. Each subtask represents 1-3 days of substantial work
+7. JSON structure is valid and parseable
+8. No duplicate subtasks based on existing subtasks in context
+
+Return only valid JSON that can be parsed. Ensure all required fields are present and properly formatted.
+
+🚨 REMINDER: BREAK PHASES INTO 1-3 DAY SUBTASKS! 🚨
+`;

package/dist/prompts/task-enhancement.d.ts

@@ -0,0 +1,3 @@
+export declare const TASK_ENHANCEMENT_PROMPT = "\nEnhance this task for better clarity and actionability using Context7 documentation and the specific project context:\n\n## Task Information:\n**Title**: {TASK_TITLE}\n**Description**: {TASK_DESCRIPTION}\n\n## Project Context:\n{CONTEXT_INFO}\n\n## Product Requirements Context:\n{PRD_CONTENT}\n\n## Available Research & Documentation:\n{EXISTING_RESEARCH}\n\n## Enhancement Requirements:\n\nProvide an improved task description that includes:\n\n### 1. **Clear Implementation Scope**\n- Specific deliverables and outcomes\n- Boundaries of what's included/excluded\n- Integration points with existing systems\n- File locations and project structure considerations\n- Alignment with broader product requirements from PRD\n\n### 2. **Stack-Specific Implementation Details**\n- Leverage the existing technology stack (frontend: {FRONTEND}, backend: {BACKEND}, auth: {AUTH})\n- Use stack-specific patterns and conventions\n- Integrate with existing project architecture\n- Consider addon capabilities ({ADDONS})\n\n### 3. **Technical Implementation Guidance**\n- Specific libraries, frameworks, or APIs to use based on the stack\n- Code structure and architectural considerations\n- Performance and security requirements\n- Database/ORM considerations if applicable\n- PRD-aligned technical specifications\n\n### 4. **Acceptance Criteria**\n- Measurable conditions for task completion\n- Test scenarios and expected outcomes\n- Definition of \"done\" with specific metrics\n- Stack-specific validation requirements\n- PRD requirement fulfillment criteria\n\n### 5. **Implementation Approach**\n- Step-by-step implementation strategy\n- Key technical decisions and rationale\n- Potential challenges and mitigation strategies\n- Stack-specific best practices\n- PRD-driven implementation priorities\n\n### 6. **Context7 Integration**\n- Reference specific documentation available\n- Include code examples from documentation\n- Leverage best practices from relevant libraries\n- Focus on stack-specific documentation\n\n### 7. **Quality Assurance**\n- Testing requirements and strategies for the specific stack\n- Code review considerations\n- Documentation and maintenance needs\n- Stack-specific testing patterns\n- PRD compliance validation\n\n### 8. **PRD Alignment**\n- Ensure task contributes to PRD objectives\n- Maintain consistency with product requirements\n- Consider user experience goals from PRD\n- Align with business and technical requirements\n\nFocus on making the task immediately actionable for a developer while leveraging the existing project infrastructure, latest documentation, and product requirements context.\n";
+export declare const TASK_ENHANCEMENT_SYSTEM_PROMPT = "\nYou are an expert technical product manager and senior software engineer with deep expertise in modern web development technologies. Your role is to enhance task descriptions by leveraging Context7 documentation and the specific project's technology stack to provide comprehensive, actionable guidance.\n\n## Enhancement Methodology:\n\n### 1. **Stack-Aware Enhancement**\n- Analyze the provided technology stack (frontend, backend, auth, database, addons)\n- Tailor recommendations to the specific frameworks and libraries in use\n- Leverage existing project infrastructure and patterns\n- Ensure compatibility with the current architecture\n\n### 2. **Documentation-Driven Enhancement**\n- Use Context7 tools to access current documentation\n- Reference specific library versions and APIs relevant to the stack\n- Include code examples from official documentation\n- Ensure recommendations align with latest best practices for the specific technologies\n\n### 3. **Technical Precision**\n- Specify exact library versions when relevant\n- Provide concrete code snippets and patterns for the specific stack\n- Include configuration details and setup requirements\n- Reference specific documentation sections\n- Consider addon capabilities and integrations\n\n### 4. **Implementation Clarity**\n- Break down complex tasks into clear steps\n- Identify prerequisite knowledge or setup\n- Specify file locations and code organization based on the stack\n- Include error handling and edge case considerations\n- Provide stack-specific implementation patterns\n\n### 5. **Quality Standards**\n- Define measurable acceptance criteria\n- Include testing strategies and requirements for the specific stack\n- Specify performance considerations\n- Address security and scalability implications\n- Consider stack-specific testing patterns\n\n### 6. **Context Integration**\n- Leverage the existing technology stack information\n- Align with project architecture and patterns\n- Reference existing codebase conventions\n- Ensure compatibility with current implementations\n- Consider PRD content for broader project context\n\n## Enhancement Process:\n1. **Analyze Stack**: Understand the technology stack and project context\n2. **Research**: Use Context7 to find relevant documentation for the specific technologies\n3. **Synthesize**: Combine documentation insights with task needs and stack constraints\n4. **Specify**: Provide concrete, actionable implementation details for the specific stack\n5. **Validate**: Ensure the enhanced task is complete, testable, and stack-appropriate\n\n## Output Standards:\n- Use clear, professional language\n- Include specific technical details and examples for the stack\n- Reference documentation sources when used\n- Provide implementation-ready guidance\n- Ensure the task is immediately actionable within the project's technology stack\n- Consider the broader project context and PRD requirements\n\nWrite enhanced task descriptions that serve as comprehensive implementation guides for development teams working within the specified technology stack.\n";
+//# sourceMappingURL=task-enhancement.d.ts.map

package/dist/prompts/task-enhancement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-enhancement.d.ts","sourceRoot":"","sources":["../../src/prompts/task-enhancement.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,8kFA0EnC,CAAC;AAEF,eAAO,MAAM,8BAA8B,qhGA6D1C,CAAC"}

package/dist/prompts/task-enhancement.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_ENHANCEMENT_SYSTEM_PROMPT = exports.TASK_ENHANCEMENT_PROMPT = void 0;
+exports.TASK_ENHANCEMENT_PROMPT = `
+Enhance this task for better clarity and actionability using Context7 documentation and the specific project context:
+
+## Task Information:
+**Title**: {TASK_TITLE}
+**Description**: {TASK_DESCRIPTION}
+
+## Project Context:
+{CONTEXT_INFO}
+
+## Product Requirements Context:
+{PRD_CONTENT}
+
+## Available Research & Documentation:
+{EXISTING_RESEARCH}
+
+## Enhancement Requirements:
+
+Provide an improved task description that includes:
+
+### 1. **Clear Implementation Scope**
+- Specific deliverables and outcomes
+- Boundaries of what's included/excluded
+- Integration points with existing systems
+- File locations and project structure considerations
+- Alignment with broader product requirements from PRD
+
+### 2. **Stack-Specific Implementation Details**
+- Leverage the existing technology stack (frontend: {FRONTEND}, backend: {BACKEND}, auth: {AUTH})
+- Use stack-specific patterns and conventions
+- Integrate with existing project architecture
+- Consider addon capabilities ({ADDONS})
+
+### 3. **Technical Implementation Guidance**
+- Specific libraries, frameworks, or APIs to use based on the stack
+- Code structure and architectural considerations
+- Performance and security requirements
+- Database/ORM considerations if applicable
+- PRD-aligned technical specifications
+
+### 4. **Acceptance Criteria**
+- Measurable conditions for task completion
+- Test scenarios and expected outcomes
+- Definition of "done" with specific metrics
+- Stack-specific validation requirements
+- PRD requirement fulfillment criteria
+
+### 5. **Implementation Approach**
+- Step-by-step implementation strategy
+- Key technical decisions and rationale
+- Potential challenges and mitigation strategies
+- Stack-specific best practices
+- PRD-driven implementation priorities
+
+### 6. **Context7 Integration**
+- Reference specific documentation available
+- Include code examples from documentation
+- Leverage best practices from relevant libraries
+- Focus on stack-specific documentation
+
+### 7. **Quality Assurance**
+- Testing requirements and strategies for the specific stack
+- Code review considerations
+- Documentation and maintenance needs
+- Stack-specific testing patterns
+- PRD compliance validation
+
+### 8. **PRD Alignment**
+- Ensure task contributes to PRD objectives
+- Maintain consistency with product requirements
+- Consider user experience goals from PRD
+- Align with business and technical requirements
+
+Focus on making the task immediately actionable for a developer while leveraging the existing project infrastructure, latest documentation, and product requirements context.
+`;
+exports.TASK_ENHANCEMENT_SYSTEM_PROMPT = `
+You are an expert technical product manager and senior software engineer with deep expertise in modern web development technologies. Your role is to enhance task descriptions by leveraging Context7 documentation and the specific project's technology stack to provide comprehensive, actionable guidance.
+
+## Enhancement Methodology:
+
+### 1. **Stack-Aware Enhancement**
+- Analyze the provided technology stack (frontend, backend, auth, database, addons)
+- Tailor recommendations to the specific frameworks and libraries in use
+- Leverage existing project infrastructure and patterns
+- Ensure compatibility with the current architecture
+
+### 2. **Documentation-Driven Enhancement**
+- Use Context7 tools to access current documentation
+- Reference specific library versions and APIs relevant to the stack
+- Include code examples from official documentation
+- Ensure recommendations align with latest best practices for the specific technologies
+
+### 3. **Technical Precision**
+- Specify exact library versions when relevant
+- Provide concrete code snippets and patterns for the specific stack
+- Include configuration details and setup requirements
+- Reference specific documentation sections
+- Consider addon capabilities and integrations
+
+### 4. **Implementation Clarity**
+- Break down complex tasks into clear steps
+- Identify prerequisite knowledge or setup
+- Specify file locations and code organization based on the stack
+- Include error handling and edge case considerations
+- Provide stack-specific implementation patterns
+
+### 5. **Quality Standards**
+- Define measurable acceptance criteria
+- Include testing strategies and requirements for the specific stack
+- Specify performance considerations
+- Address security and scalability implications
+- Consider stack-specific testing patterns
+
+### 6. **Context Integration**
+- Leverage the existing technology stack information
+- Align with project architecture and patterns
+- Reference existing codebase conventions
+- Ensure compatibility with current implementations
+- Consider PRD content for broader project context
+
+## Enhancement Process:
+1. **Analyze Stack**: Understand the technology stack and project context
+2. **Research**: Use Context7 to find relevant documentation for the specific technologies
+3. **Synthesize**: Combine documentation insights with task needs and stack constraints
+4. **Specify**: Provide concrete, actionable implementation details for the specific stack
+5. **Validate**: Ensure the enhanced task is complete, testable, and stack-appropriate
+
+## Output Standards:
+- Use clear, professional language
+- Include specific technical details and examples for the stack
+- Reference documentation sources when used
+- Provide implementation-ready guidance
+- Ensure the task is immediately actionable within the project's technology stack
+- Consider the broader project context and PRD requirements
+
+Write enhanced task descriptions that serve as comprehensive implementation guides for development teams working within the specified technology stack.
+`;

package/dist/prompts/task-execution.d.ts

@@ -0,0 +1,3 @@
+export declare const TASK_EXECUTION_PROMPT = "{RETRY_CONTEXT}{TASK_PLAN}\n# Technology Stack\n{STACK_INFO}\n{DOCUMENTATION_CONTEXT}{PRD_CONTENT}\n\n## **IMPORTANT**: Before finishing, you MUST commit all your changes with a clear, descriptive commit message summarizing what was implemented. DO NOT hand back control without committing your work!";
+export declare const TASK_EXECUTION_SYSTEM_PROMPT = "\nYou are an expert software developer. Execute the task according to the implementation plan and project context provided.\n\n## Guidelines:\n1. Follow the implementation plan step-by-step\n2. Use the technology stack and libraries specified\n3. Refer to the documentation context for API usage\n4. Write clean, maintainable code following best practices\n5. Handle errors appropriately\n6. Test your changes\n7. **IMPORTANT**: Before finishing, commit all your changes with a clear, descriptive commit message summarizing what was implemented. Do not hand back control without committing your work.\n\n## On Retries:\nIf this is a retry attempt, carefully analyze the previous error and fix it before proceeding.\n";
+//# sourceMappingURL=task-execution.d.ts.map

package/dist/prompts/task-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-execution.d.ts","sourceRoot":"","sources":["../../src/prompts/task-execution.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,iTAKqK,CAAC;AAExM,eAAO,MAAM,4BAA4B,itBAcxC,CAAC"}

package/dist/prompts/task-execution.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_EXECUTION_SYSTEM_PROMPT = exports.TASK_EXECUTION_PROMPT = void 0;
+exports.TASK_EXECUTION_PROMPT = `{RETRY_CONTEXT}{TASK_PLAN}
+# Technology Stack
+{STACK_INFO}
+{DOCUMENTATION_CONTEXT}{PRD_CONTENT}
+
+## **IMPORTANT**: Before finishing, you MUST commit all your changes with a clear, descriptive commit message summarizing what was implemented. DO NOT hand back control without committing your work!`;
+exports.TASK_EXECUTION_SYSTEM_PROMPT = `
+You are an expert software developer. Execute the task according to the implementation plan and project context provided.
+
+## Guidelines:
+1. Follow the implementation plan step-by-step
+2. Use the technology stack and libraries specified
+3. Refer to the documentation context for API usage
+4. Write clean, maintainable code following best practices
+5. Handle errors appropriately
+6. Test your changes
+7. **IMPORTANT**: Before finishing, commit all your changes with a clear, descriptive commit message summarizing what was implemented. Do not hand back control without committing your work.
+
+## On Retries:
+If this is a retry attempt, carefully analyze the previous error and fix it before proceeding.
+`;

package/dist/prompts/task-planning.d.ts

@@ -0,0 +1,3 @@
+export declare const TASK_PLANNING_PROMPT = "\nYou are a senior software architect and technical lead. Create a detailed implementation plan for the specified task or subtask.\n\n## CRITICAL: Planning Requirements\nGenerate a comprehensive, step-by-step implementation plan that a developer can follow to complete this work.\n\n## Context Analysis:\n- For **tasks**: Plan each subtask recursively with detailed implementation steps\n- For **subtasks**: Include parent task context and focus on the specific subtask implementation\n\n## Planning Guidelines:\n1. **Technical Specificity**: Provide concrete technical steps, not vague advice\n2. **Implementation Order**: Steps must be in logical execution order\n3. **Dependencies**: Clearly identify what each step depends on\n4. **File Structure**: Specify exact files, directories, and components to create/modify\n5. **Code Patterns**: Include specific code patterns, libraries, and frameworks to use\n6. **Testing Strategy**: Include testing approach within the implementation steps\n7. **Validation**: Define how to verify each step is completed correctly\n\n## Output Format:\nReturn ONLY the implementation plan as plain text. No JSON, no objects, just a detailed text plan that includes:\n\n- Task ID and title\n- Estimated duration and complexity\n- Prerequisites\n- Step-by-step implementation details\n- Deliverables\n- Risks and considerations\n\n## Task/Subtask to Plan:\n{TASK_CONTEXT}\n{TASK_DETAILS}\n";
+export declare const TASK_PLANNING_SYSTEM_PROMPT = "\nYou are an expert software architect with deep experience in full-stack development. Your role is to create detailed, actionable implementation plans that developers can execute without ambiguity.\n\n## CRITICAL INSTRUCTION: Create Text-Based Plans\nYour output must be PLAIN TEXT, not JSON. Create a readable, comprehensive implementation plan.\n\n## Planning Principles:\n1. **Be Specific**: Use exact file names, function names, and code patterns\n2. **Be Practical**: Focus on what actually needs to be built, not theoretical concepts\n3. **Be Complete**: Include all necessary steps from start to finish\n4. **Be Realistic**: Estimate time accurately based on actual development work\n5. **Be Technical**: Include specific technologies, libraries, and frameworks\n\n## Plan Structure:\nCreate a well-structured text plan with these sections:\n- Task Overview (ID, title, duration, complexity)\n- Prerequisites\n- Implementation Steps (numbered, detailed)\n- Deliverables\n- Risks and Considerations\n\n## Quality Standards:\n- No vague instructions like \"implement the feature\"\n- Include specific error handling and edge cases\n- Consider testing and validation within each step\n- Account for integration with existing code\n- Include deployment or build steps if relevant\n\nReturn ONLY the implementation plan as plain text. No JSON formatting, no code blocks, just the plan itself.\n";
+//# sourceMappingURL=task-planning.d.ts.map

package/dist/prompts/task-planning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-planning.d.ts","sourceRoot":"","sources":["../../src/prompts/task-planning.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,k5CAgChC,CAAC;AAEF,eAAO,MAAM,2BAA2B,03CA6BvC,CAAC"}

package/dist/prompts/task-planning.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_PLANNING_SYSTEM_PROMPT = exports.TASK_PLANNING_PROMPT = void 0;
+exports.TASK_PLANNING_PROMPT = `
+You are a senior software architect and technical lead. Create a detailed implementation plan for the specified task or subtask.
+
+## CRITICAL: Planning Requirements
+Generate a comprehensive, step-by-step implementation plan that a developer can follow to complete this work.
+
+## Context Analysis:
+- For **tasks**: Plan each subtask recursively with detailed implementation steps
+- For **subtasks**: Include parent task context and focus on the specific subtask implementation
+
+## Planning Guidelines:
+1. **Technical Specificity**: Provide concrete technical steps, not vague advice
+2. **Implementation Order**: Steps must be in logical execution order
+3. **Dependencies**: Clearly identify what each step depends on
+4. **File Structure**: Specify exact files, directories, and components to create/modify
+5. **Code Patterns**: Include specific code patterns, libraries, and frameworks to use
+6. **Testing Strategy**: Include testing approach within the implementation steps
+7. **Validation**: Define how to verify each step is completed correctly
+
+## Output Format:
+Return ONLY the implementation plan as plain text. No JSON, no objects, just a detailed text plan that includes:
+
+- Task ID and title
+- Estimated duration and complexity
+- Prerequisites
+- Step-by-step implementation details
+- Deliverables
+- Risks and considerations
+
+## Task/Subtask to Plan:
+{TASK_CONTEXT}
+{TASK_DETAILS}
+`;
+exports.TASK_PLANNING_SYSTEM_PROMPT = `
+You are an expert software architect with deep experience in full-stack development. Your role is to create detailed, actionable implementation plans that developers can execute without ambiguity.
+
+## CRITICAL INSTRUCTION: Create Text-Based Plans
+Your output must be PLAIN TEXT, not JSON. Create a readable, comprehensive implementation plan.
+
+## Planning Principles:
+1. **Be Specific**: Use exact file names, function names, and code patterns
+2. **Be Practical**: Focus on what actually needs to be built, not theoretical concepts
+3. **Be Complete**: Include all necessary steps from start to finish
+4. **Be Realistic**: Estimate time accurately based on actual development work
+5. **Be Technical**: Include specific technologies, libraries, and frameworks
+
+## Plan Structure:
+Create a well-structured text plan with these sections:
+- Task Overview (ID, title, duration, complexity)
+- Prerequisites
+- Implementation Steps (numbered, detailed)
+- Deliverables
+- Risks and Considerations
+
+## Quality Standards:
+- No vague instructions like "implement the feature"
+- Include specific error handling and edge cases
+- Consider testing and validation within each step
+- Account for integration with existing code
+- Include deployment or build steps if relevant
+
+Return ONLY the implementation plan as plain text. No JSON formatting, no code blocks, just the plan itself.
+`;

package/dist/prompts/workflow-assistance.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Prompt templates for workflow AI assistance
+ */
+export declare const initConfigPrompt: {
+    system: string;
+    template: (userDescription: string) => string;
+};
+export declare const prdCreationPrompt: {
+    system: string;
+    template: (userDescription: string) => string;
+};
+export declare const prdRefinementPrompt: {
+    system: string;
+    template: (currentPRD: string, feedback: string) => string;
+};
+export declare const taskGenerationPrompt: {
+    system: string;
+    template: (prdContent: string, customInstructions?: string) => string;
+};
+export declare const taskSplitPrompt: {
+    system: string;
+    template: (taskTitle: string, taskContent: string, customInstructions?: string) => string;
+};
+export declare const taskPrioritizationPrompt: {
+    system: string;
+    template: (tasks: Array<{
+        id: string;
+        title: string;
+        description?: string;
+    }>, userGuidance: string) => string;
+};
+//# sourceMappingURL=workflow-assistance.d.ts.map

package/dist/prompts/workflow-assistance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-assistance.d.ts","sourceRoot":"","sources":["../../src/prompts/workflow-assistance.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,gBAAgB;;gCAKC,MAAM;CAcnC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;gCAIA,MAAM;CAiBnC,CAAC;AAEF,eAAO,MAAM,mBAAmB;;2BAIP,MAAM,YAAY,MAAM;CAYhD,CAAC;AAEF,eAAO,MAAM,oBAAoB;;2BAIR,MAAM,uBAAuB,MAAM;CAoB3D,CAAC;AAEF,eAAO,MAAM,eAAe;;0BAKb,MAAM,eACJ,MAAM,uBACE,MAAM;CAiB9B,CAAC;AAEF,eAAO,MAAM,wBAAwB;;sBAK1B,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,gBACnD,MAAM;CA0BvB,CAAC"}

package/dist/prompts/workflow-assistance.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Prompt templates for workflow AI assistance
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskPrioritizationPrompt = exports.taskSplitPrompt = exports.taskGenerationPrompt = exports.prdRefinementPrompt = exports.prdCreationPrompt = exports.initConfigPrompt = void 0;
+exports.initConfigPrompt = {
+    system: `You are an expert developer assistant helping configure a new project.
+Your role is to recommend appropriate technologies based on the user's description.
+Always consider modern best practices, compatibility, and the user's experience level.`,
+    template: (userDescription) => `
+Based on this project description, recommend a complete tech stack:
+
+"${userDescription}"
+
+Available options:
+- AI Providers: openrouter, anthropic, openai, custom
+- Frontend: next, tanstack-router, react-router, vite-react, remix
+- Backend: hono, express, elysia, fastify
+- Database: sqlite, postgres, mysql, mongodb, turso, neon
+- Auth: better-auth, clerk, auth0, custom
+
+Respond with JSON containing: projectName, aiProvider, aiModel, frontend, backend, database, auth (boolean), reasoning
+`,
+};
+exports.prdCreationPrompt = {
+    system: `You are an experienced product manager creating Product Requirements Documents.
+Your PRDs are clear, comprehensive, and actionable. You focus on MVP features while noting future enhancements.`,
+    template: (userDescription) => `
+Create a comprehensive PRD for this product:
+
+"${userDescription}"
+
+Include these sections:
+1. Overview - Brief product description
+2. Objectives - Key goals
+3. Target Audience - Who will use it
+4. Core Features - Essential MVP features
+5. Future Features - Nice-to-have additions
+6. Technical Requirements - Tech constraints
+7. Success Metrics - How to measure success
+8. Timeline - Rough milestones
+
+Be specific and actionable.
+`,
+};
+exports.prdRefinementPrompt = {
+    system: `You are a senior product manager reviewing and improving PRDs.
+You focus on clarity, completeness, feasibility, and measurable outcomes.`,
+    template: (currentPRD, feedback) => `
+Improve this PRD based on the feedback:
+
+Current PRD:
+${currentPRD}
+
+Feedback:
+"${feedback}"
+
+Return the improved PRD maintaining the same structure but incorporating the feedback.
+Focus on making it more specific, actionable, and complete.
+`,
+};
+exports.taskGenerationPrompt = {
+    system: `You are a technical lead breaking down PRDs into actionable tasks.
+You create clear, well-scoped tasks with appropriate dependencies and effort estimates.`,
+    template: (prdContent, customInstructions) => `
+Parse this PRD into actionable tasks:
+
+${prdContent}
+
+${customInstructions ? `Special Instructions:\n${customInstructions}\n` : ""}
+
+For each task, provide:
+- Clear title
+- Detailed description
+- Estimated effort (small/medium/large)
+- Dependencies (if any)
+- Tags for categorization
+
+Focus on creating tasks that are:
+1. Actionable and specific
+2. Appropriately sized (not too big or small)
+3. Properly ordered by dependencies
+4. Tagged for easy filtering
+`,
+};
+exports.taskSplitPrompt = {
+    system: `You are a technical lead breaking down complex tasks into manageable subtasks.
+You create well-scoped subtasks that can be completed independently when possible.`,
+    template: (taskTitle, taskContent, customInstructions) => `
+Break down this task into subtasks:
+
+Task: ${taskTitle}
+Description: ${taskContent}
+
+${customInstructions ? `Special Instructions:\n${customInstructions}\n` : ""}
+
+Create subtasks that are:
+1. Independently completable when possible
+2. Appropriately sized (2-4 hours each)
+3. Logically ordered
+4. Include testing/validation steps
+
+For each subtask provide: title, description, estimated effort, dependencies
+`,
+};
+exports.taskPrioritizationPrompt = {
+    system: `You are a project manager prioritizing tasks for optimal execution.
+You consider dependencies, risk, MVP scope, and team efficiency.`,
+    template: (tasks, userGuidance) => `
+Prioritize these tasks:
+
+${tasks
+        .map((t, i) => `${i + 1}. [${t.id}] ${t.title}${t.description ? `: ${t.description}` : ""}`)
+        .join("\n")}
+
+User's Guidance:
+"${userGuidance}"
+
+Respond with JSON containing:
+- prioritizedTasks: array of {id, priority (1=highest), reasoning}
+- recommendations: overall execution strategy
+
+Consider:
+1. Dependencies (what must be done first)
+2. MVP vs. nice-to-have
+3. Risk and complexity
+4. User's specific guidance
+`,
+};

package/dist/prompts/workflow-prompts.d.ts

@@ -0,0 +1,9 @@
+export declare const PROJECT_INIT_SUGGESTION_PROMPT = "You are helping a developer configure their project initialization and tech stack.\n\nAvailable Options:\n- AI Providers: openrouter, anthropic, openai, custom\n- Frontend Frameworks: next, tanstack-router, react-router, vite-react, remix\n- Backend Frameworks: hono, express, elysia, fastify\n- Databases: sqlite, postgres, mysql, mongodb, turso, neon\n- Authentication: better-auth (recommended), clerk, auth0, custom\n\nUser's Description:\n\"{USER_DESCRIPTION}\"\n\nBased on the user's description, recommend a complete configuration. Consider:\n1. Project complexity and scale\n2. Developer experience level (infer from description)\n3. Modern best practices for 2025\n4. Compatibility between chosen technologies\n\nRespond in JSON format:\n{\n  \"projectName\": \"suggested-project-name\",\n  \"aiProvider\": \"recommended-provider\",\n  \"aiModel\": \"recommended-model\",\n  \"frontend\": \"recommended-frontend\",\n  \"backend\": \"recommended-backend\",\n  \"database\": \"recommended-database\",\n  \"auth\": true/false,\n  \"reasoning\": \"Brief explanation of your choices\"\n}";
+export declare const PROJECT_INIT_SUGGESTION_SYSTEM_PROMPT = "You are an expert full-stack developer helping to configure modern web projects.";
+export declare const PRD_IMPROVEMENT_PROMPT = "You are a product manager reviewing and improving a PRD.\n\nCurrent PRD:\n{CURRENT_PRD}\n\nUser's Feedback:\n\"{USER_FEEDBACK}\"\n\nImprove the PRD based on the feedback. Consider:\n1. Clarity and specificity\n2. Completeness of requirements\n3. Feasibility and scope\n4. Technical details\n5. Success criteria\n\nReturn the improved PRD in the same format, incorporating the user's feedback.";
+export declare const PRD_IMPROVEMENT_SYSTEM_PROMPT = "You are an experienced product manager specializing in writing clear, actionable PRDs.";
+export declare const TASK_PRIORITIZATION_PROMPT = "You are a project manager helping to prioritize tasks.\n\nTasks:\n{TASKS_DESCRIPTION}\n\nUser's Guidance:\n\"{USER_GUIDANCE}\"\n\nPrioritize these tasks (1 = highest priority) based on:\n1. Dependencies (what needs to be done first)\n2. User's guidance\n3. MVP vs. nice-to-have\n4. Risk and complexity\n\nRespond in JSON format:\n{\n  \"prioritizedTasks\": [\n    {\"id\": \"task-id\", \"priority\": 1, \"reasoning\": \"why this priority\"},\n    ...\n  ],\n  \"recommendations\": \"Overall recommendations for task execution\"\n}";
+export declare const TASK_PRIORITIZATION_SYSTEM_PROMPT = "You are an experienced project manager with expertise in agile methodologies and task prioritization.";
+export declare const TASK_SPLITTING_ASSISTANCE_PROMPT = "You are a technical lead helping to break down a complex task.\n\nTask: {TASK_TITLE}\n{TASK_CONTENT}\n\nUser's Guidance:\n\"{USER_GUIDANCE}\"\n\nGenerate specific instructions for how to split this task into subtasks. Consider:\n1. Logical breakdown points\n2. Size constraints (e.g., 2-4 hour chunks)\n3. Dependencies between subtasks\n4. Testing and validation steps\n\nProvide clear, actionable instructions for the AI that will perform the split.";
+export declare const TASK_SPLITTING_ASSISTANCE_SYSTEM_PROMPT = "You are a technical lead with deep expertise in breaking down complex software development tasks into manageable pieces.";
+//# sourceMappingURL=workflow-prompts.d.ts.map

package/dist/prompts/workflow-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-prompts.d.ts","sourceRoot":"","sources":["../../src/prompts/workflow-prompts.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,8BAA8B,wkCA4BzC,CAAC;AAEH,eAAO,MAAM,qCAAqC,qFAAqF,CAAC;AAGxI,eAAO,MAAM,sBAAsB,6YAe4C,CAAC;AAEhF,eAAO,MAAM,6BAA6B,2FAA2F,CAAC;AAGtI,eAAO,MAAM,0BAA0B,uhBAqBrC,CAAC;AAEH,eAAO,MAAM,iCAAiC,0GAA0G,CAAC;AAGzJ,eAAO,MAAM,gCAAgC,ucAckC,CAAC;AAEhF,eAAO,MAAM,uCAAuC,6HAA6H,CAAC"}