claude-kanban 0.6.3 → 0.6.4

package/dist/server/index.js

@@ -1654,6 +1654,7 @@ var RoadmapService = class extends EventEmitter2 {
           phase: f.phase,
           rationale: f.rationale || "",
           steps: f.steps,
+          acceptanceCriteria: f.acceptanceCriteria,
           addedToKanban: false
         })),
         competitors,
@@ -1667,68 +1668,83 @@ var RoadmapService = class extends EventEmitter2 {
     }
   }
   /**
-   * Build the competitor research prompt
+   * Build the competitor research prompt (inspired by Auto-Claude)
    */
   buildCompetitorResearchPrompt(projectInfo) {
-    return `You are a product research analyst. Your task is to research competitors and return ONLY JSON output.
+    return `You are a Competitor Analysis Agent. This is a NON-INTERACTIVE autonomous task - you CANNOT ask questions or request clarification. Make educated inferences from available information.
 
-IMPORTANT: Do not ask any questions. Do not request clarification. Just analyze and return the JSON.
+## Your Role
+Research competitors, analyze user feedback, and document pain points to inform feature prioritization.
 
-## Project Information
+## Project Context
 - Name: ${projectInfo.name}
 - Description: ${projectInfo.description}
 - Tech Stack: ${projectInfo.stack.join(", ") || "Unknown"}
 
-## Your Task
-1. Based on the project description, identify what type of product/service this is
-2. Find 3-5 competitors or similar projects in this space
-3. Analyze their strengths and weaknesses
-4. Identify differentiating features
-
-## Required Output Format
-Return ONLY a JSON array (no markdown code blocks, no explanations):
+## Research Process
+1. DISCOVERY: Identify 3-5 main competitors (direct competitors, market leaders, alternative solutions)
+2. FEEDBACK COLLECTION: Gather real user complaints from:
+   - App store reviews
+   - Reddit discussions
+   - GitHub issues
+   - Stack Overflow questions
+   - Twitter/social media
+3. PAIN POINT ANALYSIS: Extract patterns - missing features, UX problems, performance issues, pricing concerns
+
+## Critical Requirements
+- Document sources for every pain point (no fabricated data)
+- Focus on authentic user feedback, not just feature lists
+- Include severity ratings where possible
+- Identify market gaps and opportunities
+
+## Required Output
+Return ONLY valid JSON (no markdown, no explanations). Begin with [ and end with ]:
 
 [
   {
     "name": "Competitor Name",
     "url": "https://example.com",
     "strengths": ["strength 1", "strength 2"],
-    "weaknesses": ["weakness 1", "weakness 2"],
-    "differentiators": ["feature 1", "feature 2"]
+    "weaknesses": ["weakness 1 - based on user feedback from [source]", "weakness 2"],
+    "differentiators": ["unique feature 1", "unique feature 2"],
+    "painPoints": ["user complaint 1", "user complaint 2"],
+    "marketGaps": ["opportunity 1"]
   }
 ]
 
-Begin your response with [ and end with ]. No other text.`;
+Begin your response with [ - no other text.`;
   }
   /**
-   * Build the roadmap generation prompt
+   * Build the roadmap generation prompt (inspired by Auto-Claude)
    */
   buildRoadmapPrompt(projectInfo, competitors, request) {
-    let prompt = `You are a product strategist creating a feature roadmap for a software project.
-
-## Project Information
-Name: ${projectInfo.name}
-Description: ${projectInfo.description}
-Tech Stack: ${projectInfo.stack.join(", ") || "Unknown"}
-${projectInfo.existingFeatures.length > 0 ? `
-Existing Features/Tasks:
-${projectInfo.existingFeatures.map((f) => `- ${f}`).join("\n")}` : ""}
+    let prompt = `You are a Roadmap Feature Generator Agent. This is a NON-INTERACTIVE autonomous task - you CANNOT ask questions or request clarification. Make educated inferences from available information.
+
+## Your Role
+Convert project context into a strategic, prioritized feature roadmap with phased organization.
+
+## Project Context
+- Name: ${projectInfo.name}
+- Description: ${projectInfo.description}
+- Tech Stack: ${projectInfo.stack.join(", ") || "Unknown"}
+${projectInfo.existingFeatures.length > 0 ? `- Existing Features: ${projectInfo.existingFeatures.join(", ")}` : ""}
 `;
     if (competitors && competitors.length > 0) {
       prompt += `
-## Competitor Analysis
+## Competitor Intelligence
+Use this data to identify opportunities and prioritize features that address market gaps.
 ${competitors.map((c) => `
-### ${c.name}
+### ${c.name}${c.url ? ` (${c.url})` : ""}
 - Strengths: ${c.strengths.join(", ")}
 - Weaknesses: ${c.weaknesses.join(", ")}
-- Key Features: ${c.differentiators.join(", ")}
-`).join("\n")}
+- Differentiators: ${c.differentiators.join(", ")}
+`).join("")}
 `;
     }
     if (request.focusAreas && request.focusAreas.length > 0) {
       prompt += `
 ## Focus Areas
-The user wants to focus on: ${request.focusAreas.join(", ")}
+Prioritize features related to: ${request.focusAreas.join(", ")}
 `;
     }
     if (request.customPrompt) {
@@ -1738,57 +1754,75 @@ ${request.customPrompt}
 `;
     }
     prompt += `
-## Instructions
-IMPORTANT: Do not ask any questions. Do not request clarification. Generate the roadmap based on the information provided.
-
-Create a comprehensive product roadmap with features organized into phases.
-
-Use the MoSCoW prioritization framework:
-- must: Critical features that must be implemented
-- should: Important features that should be implemented
-- could: Nice-to-have features that could be implemented
-- wont: Features that won't be implemented in the near term
-
-For each feature, estimate:
-- effort: low, medium, or high
-- impact: low, medium, or high
-
-Categories should be one of: functional, ui, bug, enhancement, testing, refactor
-
-## Required Output Format
-Return ONLY valid JSON (no markdown code blocks, no explanations). Begin with { and end with }:
+## Workflow
+1. Analyze project goals and user needs
+2. Apply MoSCoW prioritization (must/should/could/wont)
+3. Assess complexity and impact for each feature
+4. Organize into logical phases with dependencies
+5. Generate structured roadmap output
+
+## Standard Phases
+- Foundation: Core infrastructure and essential features
+- Enhancement: Improved UX and additional functionality
+- Scale: Performance, integrations, advanced features
+- Future: Long-term vision and nice-to-haves
+
+## MoSCoW Framework
+- must: Critical for launch, blocks everything else
+- should: Important but not blocking
+- could: Nice to have, implement if time permits
+- wont: Out of scope for current planning horizon
+
+## Priority Matrix
+- High Impact + Low Effort = Do First (must)
+- High Impact + High Effort = Plan Carefully (should)
+- Low Impact + Low Effort = Quick Wins (could)
+- Low Impact + High Effort = Deprioritize (wont)
+
+## Required Output Schema
+Return ONLY valid JSON. Begin with { and end with }:
 
 {
-  "projectDescription": "Brief description of the project",
-  "targetAudience": "Who this project is for",
+  "projectDescription": "Inferred project purpose and value proposition",
+  "targetAudience": "Primary user persona",
   "phases": [
     {
-      "name": "Phase 1: MVP",
-      "description": "Core features for minimum viable product"
+      "name": "Foundation",
+      "description": "Core features required for initial launch"
     },
     {
-      "name": "Phase 2: Enhancement",
+      "name": "Enhancement",
       "description": "Features to improve user experience"
+    },
+    {
+      "name": "Scale",
+      "description": "Growth and advanced capabilities"
     }
   ],
   "features": [
     {
       "title": "Feature title",
-      "description": "What this feature does",
+      "description": "What this feature does and why users need it",
       "priority": "must",
       "category": "functional",
       "effort": "medium",
       "impact": "high",
-      "phase": "Phase 1: MVP",
-      "rationale": "Why this feature is important",
-      "steps": ["Step 1", "Step 2"]
+      "phase": "Foundation",
+      "rationale": "Why this feature matters - reference competitor gaps if applicable",
+      "steps": ["Implementation step 1", "Implementation step 2"],
+      "acceptanceCriteria": ["User can do X", "System handles Y"]
     }
   ]
 }
 
-Generate 10-20 strategic features across 3-4 phases. Be specific and actionable.
-Don't duplicate features that already exist in the project.
-Begin your response with { - no other text before or after the JSON.`;
+## Critical Requirements
+- Generate 10-20 features across 3-4 phases
+- Each feature must have clear acceptance criteria
+- Don't duplicate existing project features
+- Reference competitor insights in rationale where relevant
+- Be specific and actionable, not generic
+
+Begin your response with { - no other text.`;
     return prompt;
   }
   /**