pi-messenger 0.7.3

package/crew/handlers/plan.ts

@@ -0,0 +1,358 @@
+/**
+ * Crew - Plan Handler
+ * 
+ * Orchestrates planning: scouts (parallel) → gap-analyst → create tasks
+ * Simplified: PRD → plan → tasks
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { MessengerState, Dirs } from "../../lib.js";
+import type { CrewParams } from "../types.js";
+import { result } from "../utils/result.js";
+import { spawnAgents } from "../agents.js";
+import { loadCrewConfig } from "../utils/config.js";
+import { discoverCrewAgents } from "../utils/discover.js";
+import * as store from "../store.js";
+import { getCrewDir } from "../store.js";
+
+// Common PRD/spec file patterns to search for
+const PRD_PATTERNS = [
+  "PRD.md", "prd.md",
+  "SPEC.md", "spec.md",
+  "REQUIREMENTS.md", "requirements.md",
+  "DESIGN.md", "design.md",
+  "PLAN.md", "plan.md",
+  "docs/PRD.md", "docs/prd.md",
+  "docs/SPEC.md", "docs/spec.md",
+];
+
+// Scout agents to run in parallel
+const SCOUT_AGENTS = [
+  "crew-repo-scout",
+  "crew-practice-scout",
+  "crew-docs-scout",
+  "crew-web-scout",
+  "crew-github-scout",
+];
+
+export async function execute(
+  params: CrewParams,
+  _state: MessengerState,
+  _dirs: Dirs,
+  ctx: ExtensionContext
+) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const config = loadCrewConfig(getCrewDir(cwd));
+  const { prd } = params;
+
+  // Check if plan already exists
+  const existingPlan = store.getPlan(cwd);
+  if (existingPlan) {
+    return result(`A plan already exists for ${existingPlan.prd}.\n\nTo create a new plan, first delete the existing one:\n  - Delete .pi/messenger/crew/ directory\n  - Or reset tasks manually`, {
+      mode: "plan",
+      error: "plan_exists",
+      existingPrd: existingPlan.prd
+    });
+  }
+
+  // Find PRD file
+  let prdPath: string;
+  let prdContent: string;
+
+  if (prd) {
+    // Explicit PRD path
+    prdPath = prd;
+    const fullPath = path.isAbsolute(prd) ? prd : path.join(cwd, prd);
+    if (!fs.existsSync(fullPath)) {
+      return result(`PRD file not found: ${prd}`, {
+        mode: "plan",
+        error: "prd_not_found",
+        prd
+      });
+    }
+    prdContent = fs.readFileSync(fullPath, "utf-8");
+  } else {
+    // Auto-discover PRD
+    const discovered = discoverPRD(cwd);
+    if (!discovered) {
+      return result(`No PRD file found. Create one of: ${PRD_PATTERNS.slice(0, 4).join(", ")}\n\nOr specify path: pi_messenger({ action: "plan", prd: "path/to/PRD.md" })`, {
+        mode: "plan",
+        error: "no_prd",
+        searchedPatterns: PRD_PATTERNS
+      });
+    }
+    prdPath = discovered.relativePath;
+    prdContent = discovered.content;
+  }
+
+  // Discover available scouts
+  const availableAgents = discoverCrewAgents(cwd);
+  const availableScouts = SCOUT_AGENTS.filter(name => 
+    availableAgents.some(a => a.name === name)
+  );
+
+  if (availableScouts.length === 0) {
+    return result("Error: No scout agents available. Run crew.install or create crew-*-scout.md agents.", {
+      mode: "plan",
+      error: "no_scouts"
+    });
+  }
+
+  // Check for gap-analyst
+  const hasAnalyst = availableAgents.some(a => a.name === "crew-gap-analyst");
+  if (!hasAnalyst) {
+    return result("Error: crew-gap-analyst agent not found. Required for plan synthesis.", {
+      mode: "plan",
+      error: "no_analyst"
+    });
+  }
+
+  // Create the plan entry
+  store.createPlan(cwd, prdPath);
+
+  // Phase 1: Run scouts in parallel
+  const scoutTasks = availableScouts.map(agent => ({
+    agent,
+    task: `Analyze for implementing the following PRD:
+
+## PRD: ${prdPath}
+
+${prdContent}
+
+Provide context for planning this feature implementation.`
+  }));
+
+  const scoutResults = await spawnAgents(
+    scoutTasks,
+    config.concurrency.scouts,
+    cwd
+  );
+
+  // Aggregate scout findings
+  const scoutFindings: string[] = [];
+  const failedScouts: string[] = [];
+
+  for (const r of scoutResults) {
+    if (r.exitCode === 0 && r.output) {
+      scoutFindings.push(`## ${r.agent}\n\n${r.output}`);
+    } else {
+      failedScouts.push(r.agent);
+    }
+  }
+
+  if (scoutFindings.length === 0) {
+    // Clean up the plan entry since planning failed
+    store.deletePlan(cwd);
+    return result("Error: All scouts failed. Check agent configurations.", {
+      mode: "plan",
+      error: "all_scouts_failed",
+      failedScouts
+    });
+  }
+
+  // Phase 2: Run gap-analyst to synthesize findings
+  const aggregatedFindings = scoutFindings.join("\n\n---\n\n");
+  
+  const [analystResult] = await spawnAgents([{
+    agent: "crew-gap-analyst",
+    task: `Synthesize scout findings and create task breakdown.
+
+## PRD: ${prdPath}
+
+${prdContent}
+
+## Scout Findings
+
+${aggregatedFindings}
+
+Create a task breakdown following the exact output format specified in your instructions.`
+  }], 1, cwd);
+
+  if (analystResult.exitCode !== 0) {
+    // Clean up the plan entry since planning failed
+    store.deletePlan(cwd);
+    return result(`Error: Gap analyst failed: ${analystResult.error ?? "Unknown error"}`, {
+      mode: "plan",
+      error: "analyst_failed",
+      scoutResults: scoutFindings.length
+    });
+  }
+
+  // Phase 3: Parse analyst output and create tasks
+  const tasks = parseTasksFromOutput(analystResult.output);
+
+  if (tasks.length === 0) {
+    // Store the analysis as plan spec even if no tasks parsed
+    store.setPlanSpec(cwd, analystResult.output);
+    
+    return result(`Plan analysis complete but no tasks could be parsed.\n\nAnalysis saved to plan.md. Review and create tasks manually.`, {
+      mode: "plan",
+      prd: prdPath,
+      analysisLength: analystResult.output.length,
+      scoutsRun: scoutFindings.length,
+      failedScouts
+    });
+  }
+
+  // Create tasks in store
+  const createdTasks: { id: string; title: string; dependsOn: string[] }[] = [];
+  const titleToId = new Map<string, string>();
+
+  // First pass: create tasks without dependencies
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i];
+    const created = store.createTask(cwd, task.title, task.description);
+    createdTasks.push({ id: created.id, title: task.title, dependsOn: task.dependsOn });
+    titleToId.set(task.title.toLowerCase(), created.id);
+    // Also map "task N" format
+    titleToId.set(`task ${i + 1}`, created.id);
+    titleToId.set(`task-${i + 1}`, created.id);
+  }
+
+  // Second pass: resolve and update dependencies
+  for (const task of createdTasks) {
+    if (task.dependsOn.length > 0) {
+      const resolvedDeps: string[] = [];
+      for (const dep of task.dependsOn) {
+        const depId = titleToId.get(dep.toLowerCase());
+        if (depId && depId !== task.id) {
+          resolvedDeps.push(depId);
+        }
+      }
+      if (resolvedDeps.length > 0) {
+        store.updateTask(cwd, task.id, { depends_on: resolvedDeps });
+      }
+    }
+  }
+
+  // Update plan spec with full analysis
+  store.setPlanSpec(cwd, analystResult.output);
+
+  // Build result text
+  const taskList = createdTasks.map(t => {
+    const task = store.getTask(cwd, t.id);
+    const deps = task?.depends_on.length ? ` → deps: ${task.depends_on.join(", ")}` : "";
+    return `  - ${t.id}: ${t.title}${deps}`;
+  }).join("\n");
+
+  const text = `✅ Plan created from **${prdPath}**
+
+**Scouts run:** ${scoutFindings.length}/${availableScouts.length}
+${failedScouts.length > 0 ? `**Failed scouts:** ${failedScouts.join(", ")}\n` : ""}
+**Tasks created:** ${createdTasks.length}
+
+${taskList}
+
+**Next steps:**
+- Review tasks: \`pi_messenger({ action: "task.list" })\`
+- Start work: \`pi_messenger({ action: "work" })\`
+- Autonomous: \`pi_messenger({ action: "work", autonomous: true })\``;
+
+  return result(text, {
+    mode: "plan",
+    prd: prdPath,
+    scoutsRun: scoutFindings.length,
+    failedScouts,
+    tasksCreated: createdTasks.map(t => ({ id: t.id, title: t.title }))
+  });
+}
+
+// =============================================================================
+// Task Parsing
+// =============================================================================
+
+interface ParsedTask {
+  title: string;
+  description: string;
+  dependsOn: string[];
+}
+
+/**
+ * Parses tasks from gap-analyst output.
+ * 
+ * Expected format:
+ * ### Task 1: [Title]
+ * [Description...]
+ * Dependencies: none | Task 1, Task 2
+ */
+function parseTasksFromOutput(output: string): ParsedTask[] {
+  const tasks: ParsedTask[] = [];
+  
+  // Match task blocks
+  const taskRegex = /###\s*Task\s*\d+:\s*(.+?)\n([\s\S]*?)(?=###\s*Task\s*\d+:|## |$)/gi;
+  let match;
+
+  while ((match = taskRegex.exec(output)) !== null) {
+    const title = match[1].trim();
+    const body = match[2].trim();
+
+    // Extract dependencies
+    const depsMatch = body.match(/Dependencies?:\s*(.+?)(?:\n|$)/i);
+    let dependsOn: string[] = [];
+    
+    if (depsMatch) {
+      const depsText = depsMatch[1].trim().toLowerCase();
+      if (depsText !== "none" && depsText !== "n/a" && depsText !== "-") {
+        // Parse "Task 1, Task 2" or "task-1, task-2" format
+        dependsOn = depsText
+          .split(/,\s*/)
+          .map(d => d.trim())
+          .filter(d => d.length > 0);
+      }
+    }
+
+    // Description is everything except the dependencies line
+    const description = body
+      .replace(/Dependencies?:\s*.+?(?:\n|$)/i, "")
+      .trim();
+
+    tasks.push({ title, description, dependsOn });
+  }
+
+  return tasks;
+}
+
+// =============================================================================
+// PRD Discovery
+// =============================================================================
+
+interface DiscoveredPRD {
+  relativePath: string;
+  content: string;
+}
+
+const MAX_PRD_SIZE = 100000; // 100KB max
+
+/**
+ * Discovers PRD file from the project.
+ */
+function discoverPRD(cwd: string): DiscoveredPRD | null {
+  const seenPaths = new Set<string>();
+
+  for (const pattern of PRD_PATTERNS) {
+    const filePath = path.join(cwd, pattern);
+    if (fs.existsSync(filePath)) {
+      try {
+        // Use realpath to handle case-insensitive filesystems
+        const realPath = fs.realpathSync(filePath);
+        if (seenPaths.has(realPath)) continue;
+        seenPaths.add(realPath);
+        
+        let content = fs.readFileSync(filePath, "utf-8");
+        
+        // Truncate if too large
+        if (content.length > MAX_PRD_SIZE) {
+          content = content.slice(0, MAX_PRD_SIZE) + "\n\n[Content truncated]";
+        }
+        
+        return { relativePath: pattern, content };
+      } catch {
+        // Ignore read errors
+      }
+    }
+  }
+
+  return null;
+}

package/crew/handlers/review.ts

@@ -0,0 +1,341 @@
+/**
+ * Crew - Review Handler
+ * 
+ * Spawns reviewer with git diff context for task or plan review.
+ * Simplified: works with current plan
+ */
+
+import { execSync } from "node:child_process";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { MessengerState, Dirs } from "../../lib.js";
+import type { CrewParams } from "../types.js";
+import { result } from "../utils/result.js";
+import { spawnAgents } from "../agents.js";
+import { discoverCrewAgents } from "../utils/discover.js";
+import * as store from "../store.js";
+
+export async function execute(
+  params: CrewParams,
+  _state: MessengerState,
+  _dirs: Dirs,
+  ctx: ExtensionContext
+) {
+  const cwd = ctx.cwd ?? process.cwd();
+  const { target, type } = params;
+
+  if (!target) {
+    return result("Error: target (task ID) required for review action.\n\nUsage: pi_messenger({ action: \"review\", target: \"task-1\" })", {
+      mode: "review",
+      error: "missing_target"
+    });
+  }
+
+  // Check for reviewer agent
+  const availableAgents = discoverCrewAgents(cwd);
+  const hasReviewer = availableAgents.some(a => a.name === "crew-reviewer");
+  if (!hasReviewer) {
+    return result("Error: crew-reviewer agent not found. Required for code review.", {
+      mode: "review",
+      error: "no_reviewer"
+    });
+  }
+
+  // Determine review type: "impl" for task, "plan" for plan review
+  const reviewType = type ?? (target.startsWith("task-") ? "impl" : "plan");
+
+  if (reviewType === "impl") {
+    return reviewImplementation(cwd, target);
+  } else {
+    return reviewPlan(cwd);
+  }
+}
+
+// =============================================================================
+// Implementation Review
+// =============================================================================
+
+async function reviewImplementation(cwd: string, taskId: string) {
+  const task = store.getTask(cwd, taskId);
+  if (!task) {
+    return result(`Error: Task ${taskId} not found.`, {
+      mode: "review",
+      error: "task_not_found",
+      target: taskId
+    });
+  }
+
+  if (task.status !== "done" && task.status !== "in_progress") {
+    return result(`Error: Task ${taskId} is ${task.status}. Can only review in_progress or done tasks.`, {
+      mode: "review",
+      error: "invalid_status",
+      status: task.status
+    });
+  }
+
+  // Get git diff
+  const baseCommit = task.base_commit;
+  if (!baseCommit) {
+    return result(`Error: Task ${taskId} has no base_commit. Cannot generate diff.`, {
+      mode: "review",
+      error: "no_base_commit"
+    });
+  }
+
+  const diff = getGitDiff(baseCommit, cwd);
+  const commitLog = getCommitLog(baseCommit, cwd);
+
+  // Get task spec for context
+  const taskSpec = store.getTaskSpec(cwd, taskId) ?? "";
+  const plan = store.getPlan(cwd);
+
+  // Build review prompt
+  const prompt = `# Code Review Request
+
+## Task Information
+
+**Task ID:** ${taskId}
+**Task Title:** ${task.title}
+**PRD:** ${plan?.prd ?? "Unknown"}
+
+## Task Specification
+
+${taskSpec || "*No spec available*"}
+
+## Changes
+
+### Commits
+${commitLog || "*No commits*"}
+
+### Diff
+\`\`\`diff
+${diff}
+\`\`\`
+
+## Your Review
+
+Review this implementation following the crew-reviewer protocol.
+Output your verdict as SHIP, NEEDS_WORK, or MAJOR_RETHINK with detailed feedback.`;
+
+  // Spawn reviewer
+  const [reviewResult] = await spawnAgents([{
+    agent: "crew-reviewer",
+    task: prompt
+  }], 1, cwd);
+
+  if (reviewResult.exitCode !== 0) {
+    return result(`Error: Reviewer failed: ${reviewResult.error ?? "Unknown error"}`, {
+      mode: "review",
+      error: "reviewer_failed"
+    });
+  }
+
+  // Parse verdict from output
+  const verdict = parseVerdict(reviewResult.output);
+
+  // Store review feedback in task for retry context
+  store.updateTask(cwd, taskId, {
+    last_review: {
+      verdict: verdict.verdict,
+      summary: verdict.summary,
+      issues: verdict.issues,
+      suggestions: verdict.suggestions,
+      reviewed_at: new Date().toISOString()
+    }
+  });
+
+  const text = `# Review: ${taskId}
+
+**Verdict:** ${verdict.verdict}
+
+${verdict.summary}
+
+${verdict.issues.length > 0 ? `## Issues\n${verdict.issues.map(i => `- ${i}`).join("\n")}` : ""}
+
+${verdict.suggestions.length > 0 ? `## Suggestions\n${verdict.suggestions.map(s => `- ${s}`).join("\n")}` : ""}
+
+${verdict.verdict === "SHIP" ? "✅ Ready to merge!" : verdict.verdict === "NEEDS_WORK" ? "⚠️ Address issues and re-review." : "🔄 Consider re-planning this task."}`;
+
+  return result(text, {
+    mode: "review",
+    type: "impl",
+    taskId,
+    verdict: verdict.verdict,
+    issueCount: verdict.issues.length,
+    suggestionCount: verdict.suggestions.length
+  });
+}
+
+// =============================================================================
+// Plan Review
+// =============================================================================
+
+async function reviewPlan(cwd: string) {
+  const plan = store.getPlan(cwd);
+  if (!plan) {
+    return result("Error: No plan found.", {
+      mode: "review",
+      error: "no_plan"
+    });
+  }
+
+  const planSpec = store.getPlanSpec(cwd);
+  const tasks = store.getTasks(cwd);
+
+  // Build task overview
+  const taskOverview = tasks.map(t => {
+    const spec = store.getTaskSpec(cwd, t.id);
+    const deps = t.depends_on.length > 0 ? ` (deps: ${t.depends_on.join(", ")})` : "";
+    const specPreview = spec && !spec.includes("*Spec pending*")
+      ? `\n  ${spec.slice(0, 200)}${spec.length > 200 ? "..." : ""}`
+      : "";
+    return `- ${t.id}: ${t.title}${deps}${specPreview}`;
+  }).join("\n");
+
+  // Build review prompt
+  const prompt = `# Plan Review Request
+
+## Plan Information
+
+**PRD:** ${plan.prd}
+**Tasks:** ${tasks.length}
+**Progress:** ${plan.completed_count}/${plan.task_count}
+
+## Plan Specification
+
+${planSpec || "*No spec available*"}
+
+## Task Breakdown
+
+${taskOverview || "*No tasks*"}
+
+## Your Review
+
+Review this plan for:
+1. Completeness - Are all requirements covered?
+2. Task granularity - Are tasks appropriately sized?
+3. Dependencies - Are dependencies correct and complete?
+4. Gaps - Are there missing tasks or edge cases?
+5. Order - Is the execution order optimal?
+
+Output your verdict as SHIP (plan is solid), NEEDS_WORK (minor adjustments), or MAJOR_RETHINK (fundamental issues).`;
+
+  // Spawn reviewer
+  const [reviewResult] = await spawnAgents([{
+    agent: "crew-reviewer",
+    task: prompt
+  }], 1, cwd);
+
+  if (reviewResult.exitCode !== 0) {
+    return result(`Error: Reviewer failed: ${reviewResult.error ?? "Unknown error"}`, {
+      mode: "review",
+      error: "reviewer_failed"
+    });
+  }
+
+  // Parse verdict
+  const verdict = parseVerdict(reviewResult.output);
+
+  const text = `# Plan Review
+
+**PRD:** ${plan.prd}
+**Verdict:** ${verdict.verdict}
+
+${verdict.summary}
+
+${verdict.issues.length > 0 ? `## Issues\n${verdict.issues.map(i => `- ${i}`).join("\n")}` : ""}
+
+${verdict.suggestions.length > 0 ? `## Suggestions\n${verdict.suggestions.map(s => `- ${s}`).join("\n")}` : ""}
+
+${verdict.verdict === "SHIP" ? "✅ Plan is ready for execution!" : verdict.verdict === "NEEDS_WORK" ? "⚠️ Adjust plan before starting work." : "🔄 Consider re-planning with more context."}`;
+
+  return result(text, {
+    mode: "review",
+    type: "plan",
+    prd: plan.prd,
+    verdict: verdict.verdict,
+    issueCount: verdict.issues.length,
+    suggestionCount: verdict.suggestions.length
+  });
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function getGitDiff(baseCommit: string, cwd: string): string {
+  try {
+    const diff = execSync(
+      `git diff ${baseCommit}..HEAD`,
+      { cwd, encoding: "utf-8", maxBuffer: 5 * 1024 * 1024 }
+    );
+    // Truncate very long diffs
+    if (diff.length > 50000) {
+      return diff.slice(0, 50000) + "\n\n[Diff truncated - too large]";
+    }
+    return diff || "*No changes*";
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return `*Failed to get diff: ${message}*`;
+  }
+}
+
+function getCommitLog(baseCommit: string, cwd: string): string {
+  try {
+    return execSync(
+      `git log ${baseCommit}..HEAD --oneline --no-decorate`,
+      { cwd, encoding: "utf-8" }
+    ).trim() || "*No commits*";
+  } catch {
+    return "*No commits*";
+  }
+}
+
+interface ParsedReview {
+  verdict: "SHIP" | "NEEDS_WORK" | "MAJOR_RETHINK";
+  summary: string;
+  issues: string[];
+  suggestions: string[];
+}
+
+function parseVerdict(output: string): ParsedReview {
+  const result: ParsedReview = {
+    verdict: "NEEDS_WORK",
+    summary: "",
+    issues: [],
+    suggestions: []
+  };
+
+  // Extract verdict
+  const verdictMatch = output.match(/##\s*Verdict:\s*(SHIP|NEEDS_WORK|MAJOR_RETHINK)/i);
+  if (verdictMatch) {
+    result.verdict = verdictMatch[1].toUpperCase() as ParsedReview["verdict"];
+  }
+
+  // Extract summary (text between Verdict and next ##)
+  const summaryMatch = output.match(/##\s*Verdict:.*?\n([\s\S]*?)(?=\n##|$)/i);
+  if (summaryMatch) {
+    result.summary = summaryMatch[1].trim();
+  }
+
+  // Extract issues
+  const issuesMatch = output.match(/##\s*Issues?\s*\n([\s\S]*?)(?=\n##|$)/i);
+  if (issuesMatch) {
+    result.issues = issuesMatch[1]
+      .split("\n")
+      .filter(line => line.trim().startsWith("-") || line.trim().startsWith("*"))
+      .map(line => line.replace(/^[\s\-*]+/, "").trim())
+      .filter(Boolean);
+  }
+
+  // Extract suggestions
+  const suggestionsMatch = output.match(/##\s*Suggestions?\s*\n([\s\S]*?)(?=\n##|$)/i);
+  if (suggestionsMatch) {
+    result.suggestions = suggestionsMatch[1]
+      .split("\n")
+      .filter(line => line.trim().startsWith("-") || line.trim().startsWith("*"))
+      .map(line => line.replace(/^[\s\-*]+/, "").trim())
+      .filter(Boolean);
+  }
+
+  return result;
+}