task-o-matic-core 0.1.0

package/src/prompts/task-enhancement.ts

@@ -0,0 +1,138 @@
+export const 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.
+`;
+
+export const 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/src/prompts/task-execution.ts

@@ -0,0 +1,22 @@
+export const 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!`;
+
+export const 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/src/prompts/task-planning.ts

@@ -0,0 +1,64 @@
+export const 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}
+`;
+
+export const 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/src/prompts/workflow-assistance.ts

@@ -0,0 +1,151 @@
+/**
+ * Prompt templates for workflow AI assistance
+ */
+
+export const 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: string) => `
+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
+`,
+};
+
+export const 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: string) => `
+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.
+`,
+};
+
+export const prdRefinementPrompt = {
+  system: `You are a senior product manager reviewing and improving PRDs.
+You focus on clarity, completeness, feasibility, and measurable outcomes.`,
+
+  template: (currentPRD: string, feedback: string) => `
+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.
+`,
+};
+
+export const 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: string, customInstructions?: string) => `
+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
+`,
+};
+
+export const 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: string,
+    taskContent: string,
+    customInstructions?: string
+  ) => `
+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
+`,
+};
+
+export const taskPrioritizationPrompt = {
+  system: `You are a project manager prioritizing tasks for optimal execution.
+You consider dependencies, risk, MVP scope, and team efficiency.`,
+
+  template: (
+    tasks: Array<{ id: string; title: string; description?: string }>,
+    userGuidance: string
+  ) => `
+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/src/prompts/workflow-prompts.ts

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