claude-kanban 0.6.2 → 0.6.4

package/dist/server/index.js

@@ -1513,11 +1513,33 @@ var RoadmapService = class extends EventEmitter2 {
     let description = "";
     let stack = [];
     let existingFeatures = [];
+    const claudeMdPaths = ["CLAUDE.md", "claude.md", ".claude/CLAUDE.md"];
+    for (const claudePath of claudeMdPaths) {
+      const fullPath = join5(this.projectPath, claudePath);
+      if (existsSync3(fullPath)) {
+        const claudeMd = readFileSync5(fullPath, "utf-8");
+        const lines = claudeMd.split("\n");
+        const contentLines = [];
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("```")) {
+            contentLines.push(trimmed);
+            if (contentLines.join(" ").length > 300) break;
+          }
+        }
+        if (contentLines.length > 0) {
+          description = contentLines.join(" ").slice(0, 500);
+        }
+        break;
+      }
+    }
     const packageJsonPath = join5(this.projectPath, "package.json");
     if (existsSync3(packageJsonPath)) {
       try {
         const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
-        description = pkg.description || "";
+        if (!description && pkg.description && !pkg.description.includes("<")) {
+          description = pkg.description;
+        }
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         if (deps.react) stack.push("React");
         if (deps.vue) stack.push("Vue");
@@ -1527,23 +1549,43 @@ var RoadmapService = class extends EventEmitter2 {
         if (deps.fastify) stack.push("Fastify");
         if (deps.typescript) stack.push("TypeScript");
         if (deps.tailwindcss) stack.push("Tailwind CSS");
+        if (deps.laravel) stack.push("Laravel");
       } catch {
       }
     }
-    const readmePaths = ["README.md", "readme.md", "README.txt", "readme.txt"];
-    for (const readmePath of readmePaths) {
-      const fullPath = join5(this.projectPath, readmePath);
-      if (existsSync3(fullPath)) {
-        const readme = readFileSync5(fullPath, "utf-8");
-        if (!description) {
-          const lines = readme.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
+    const composerPath = join5(this.projectPath, "composer.json");
+    if (existsSync3(composerPath)) {
+      try {
+        const composer = JSON.parse(readFileSync5(composerPath, "utf-8"));
+        if (!description && composer.description && !composer.description.includes("<")) {
+          description = composer.description;
+        }
+        if (composer.require?.["laravel/framework"]) stack.push("Laravel");
+        if (composer.require?.["livewire/livewire"]) stack.push("Livewire");
+        if (composer.require?.["inertiajs/inertia-laravel"]) stack.push("Inertia.js");
+      } catch {
+      }
+    }
+    if (!description) {
+      const readmePaths = ["README.md", "readme.md", "README.txt", "readme.txt"];
+      for (const readmePath of readmePaths) {
+        const fullPath = join5(this.projectPath, readmePath);
+        if (existsSync3(fullPath)) {
+          const readme = readFileSync5(fullPath, "utf-8");
+          const lines = readme.split("\n").filter((l) => {
+            const trimmed = l.trim();
+            return trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("<") && !trimmed.startsWith("![") && !trimmed.startsWith("[!");
+          });
           if (lines.length > 0) {
             description = lines[0].trim().slice(0, 500);
           }
+          break;
         }
-        break;
       }
     }
+    if (!description) {
+      description = `A ${stack.length > 0 ? stack.join("/") + " " : ""}software project`;
+    }
     const prdPath = join5(this.projectPath, ROADMAP_DIR, "prd.json");
     if (existsSync3(prdPath)) {
       try {
@@ -1612,6 +1654,7 @@ var RoadmapService = class extends EventEmitter2 {
           phase: f.phase,
           rationale: f.rationale || "",
           steps: f.steps,
+          acceptanceCriteria: f.acceptanceCriteria,
           addedToKanban: false
         })),
         competitors,
@@ -1625,64 +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. Research competitors for the following project:
-
-Project: ${projectInfo.name}
-Description: ${projectInfo.description}
-Tech Stack: ${projectInfo.stack.join(", ") || "Unknown"}
+    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.
+
+## Your Role
+Research competitors, analyze user feedback, and document pain points to inform feature prioritization.
+
+## Project Context
+- Name: ${projectInfo.name}
+- Description: ${projectInfo.description}
+- Tech Stack: ${projectInfo.stack.join(", ") || "Unknown"}
+
+## 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 ]:
 
-Your task:
-1. Use web search to find 3-5 competitors or similar projects
-2. Analyze their strengths and weaknesses
-3. Identify differentiating features
-
-Return your findings as JSON in this format:
-\`\`\`json
 [
   {
     "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"]
   }
 ]
-\`\`\`
 
-Only return the JSON, 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) {
@@ -1692,55 +1754,75 @@ ${request.customPrompt}
 `;
     }
     prompt += `
-## Your Task
-Create a comprehensive product roadmap with features organized into phases.
+## 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 }:
 
-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
-
-Return your roadmap as JSON:
-\`\`\`json
 {
-  "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.
-Only return the JSON, no other text.`;
+## 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;
   }
   /**