@stackmemoryai/stackmemory 1.5.9 → 1.6.1

package/dist/src/cli/commands/orchestrate.js

@@ -9,12 +9,14 @@ import {
   mkdirSync,
   writeFileSync,
   readFileSync,
-  readdirSync
+  readdirSync,
+  copyFileSync
 } from "fs";
 import { join } from "path";
 import { homedir, tmpdir } from "os";
 import Database from "better-sqlite3";
 import { logger } from "../../core/monitoring/logger.js";
+import { isProcessAlive } from "../../utils/process-cleanup.js";
 import { Conductor } from "./orchestrator.js";
 import {
   getAgentStatusDir,
@@ -123,14 +125,6 @@ const phaseColor = {
   testing: c.pink,
   committing: c.green
 };
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
 function phaseProgress(phase, toolCalls, stale, alive) {
   const basePct = {
     reading: 10,
@@ -231,6 +225,293 @@ function printUsageSummary(u) {
     `  20x (900 msgs)  ${budgetBar(budgetPct20x)}  ${c.d}~${fmtMinutes(mins20x)} left${c.r}`
   );
 }
+const DEFAULT_PROMPT_TEMPLATE = `# Agent Prompt \u2014 {{ISSUE_ID}}
+
+You are working on Linear issue **{{ISSUE_ID}}**: {{TITLE}}
+
+## Description
+
+{{DESCRIPTION}}
+
+## Context
+
+- Priority: {{PRIORITY}}
+- Labels: {{LABELS}}
+{{PRIOR_CONTEXT}}
+
+## Instructions
+
+1. Read the issue description and related code carefully
+2. Plan your approach before writing code
+3. Implement the requested changes
+4. Run \`npm run lint\` and fix any errors
+5. Run \`npm run test:run\` and fix any failures
+6. Commit your changes with format: \`type(scope): message\`
+
+## Rules
+
+- Follow existing code conventions (ESM imports with .js extension, TypeScript strict)
+- Keep changes focused \u2014 only modify what the issue requires
+- Write or update tests for any new functionality
+- Do not skip pre-commit hooks
+- If stuck, leave a comment in the code explaining the blocker
+
+Work in the current directory. All changes will be on a dedicated branch.
+`;
+function ensureDefaultPromptTemplate() {
+  const templatePath = join(
+    homedir(),
+    ".stackmemory",
+    "conductor",
+    "prompt-template.md"
+  );
+  if (!existsSync(templatePath)) {
+    const dir = join(homedir(), ".stackmemory", "conductor");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(templatePath, DEFAULT_PROMPT_TEMPLATE);
+    console.log(
+      `  ${c.d}Created default prompt template: ${templatePath}${c.r}`
+    );
+  }
+  return templatePath;
+}
+function predictDifficulty(labels, description, priority, outcomes) {
+  let difficulty = "medium";
+  let confidence = 0.5;
+  const reasons = [];
+  const lowerLabels = labels.map((l) => l.toLowerCase());
+  if (outcomes.length > 0 && labels.length > 0) {
+    const matching = outcomes.filter(
+      (o) => o.labels && o.labels.some((ol) => lowerLabels.includes(ol.toLowerCase()))
+    );
+    if (matching.length >= 3) {
+      const failRate = matching.filter((o) => o.outcome === "failure").length / matching.length;
+      if (failRate > 0.6) {
+        difficulty = "hard";
+        confidence = Math.min(confidence + 0.1, 0.9);
+        reasons.push(
+          `Historical failure rate ${Math.round(failRate * 100)}% for similar labels`
+        );
+      } else if (failRate < 0.2) {
+        difficulty = "easy";
+        confidence = Math.min(confidence + 0.1, 0.9);
+        reasons.push(
+          `Historical failure rate ${Math.round(failRate * 100)}% for similar labels`
+        );
+      }
+    }
+  }
+  const hasBugOrFix = lowerLabels.some(
+    (l) => l === "bug" || l === "fix" || l.includes("bugfix")
+  );
+  if (description.length < 100 && hasBugOrFix) {
+    if (difficulty !== "easy") difficulty = "easy";
+    confidence = Math.min(confidence + 0.1, 0.9);
+    reasons.push("Short description with bug/fix label suggests simple fix");
+  }
+  const hasComplexLabel = lowerLabels.some(
+    (l) => l === "feature" || l === "refactor" || l === "refactoring" || l === "architecture"
+  );
+  if (description.length > 500 || hasComplexLabel) {
+    if (difficulty !== "hard") {
+      difficulty = description.length > 500 && hasComplexLabel ? "hard" : difficulty === "easy" ? "medium" : "hard";
+    }
+    confidence = Math.min(confidence + 0.1, 0.9);
+    if (description.length > 500) {
+      reasons.push(
+        `Long description (${description.length} chars) suggests complexity`
+      );
+    }
+    if (hasComplexLabel) {
+      reasons.push("Feature/refactor label suggests higher complexity");
+    }
+  }
+  if (priority === 1 || priority === 2) {
+    if (difficulty === "easy") difficulty = "medium";
+    else if (difficulty === "medium") difficulty = "hard";
+    confidence = Math.min(confidence + 0.1, 0.9);
+    reasons.push(
+      `Priority ${priority} (${priority === 1 ? "urgent" : "high"}) \u2014 higher difficulty expected`
+    );
+  }
+  if (outcomes.length > 0 && labels.length > 0) {
+    const matching = outcomes.filter(
+      (o) => o.labels && o.labels.some((ol) => lowerLabels.includes(ol.toLowerCase()))
+    );
+    if (matching.length >= 3) {
+      const avgToolCalls = matching.reduce((s, o) => s + o.toolCalls, 0) / matching.length;
+      if (avgToolCalls > 80) {
+        difficulty = "hard";
+        confidence = Math.min(confidence + 0.1, 0.9);
+        reasons.push(
+          `Historical avg tool calls ${Math.round(avgToolCalls)} for similar labels (>80)`
+        );
+      }
+    }
+  }
+  if (reasons.length === 0) {
+    reasons.push("No strong signals \u2014 defaulting to medium");
+  }
+  return { difficulty, confidence, reasons };
+}
+function loadOutcomes() {
+  const logPath = getOutcomesLogPath();
+  if (!existsSync(logPath)) return [];
+  try {
+    return readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean).map((l) => JSON.parse(l));
+  } catch {
+    return [];
+  }
+}
+function spawnClaudePrint(prompt, timeoutMs = 12e4) {
+  return new Promise((resolve, reject) => {
+    const child = cpSpawn("claude", ["--print"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGTERM");
+    }, timeoutMs);
+    child.stdout.on("data", (d) => stdout += d.toString());
+    child.stderr.on("data", (d) => stderr += d.toString());
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (killed)
+        return reject(new Error(`claude timed out after ${timeoutMs}ms`));
+      if (code !== 0 && !stdout)
+        return reject(new Error(stderr || `claude exited ${code}`));
+      resolve(stdout);
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.stdin.write(prompt);
+    child.stdin.end();
+  });
+}
+async function evolvePromptTemplate(input) {
+  const {
+    templatePath,
+    successRate,
+    failures,
+    failPhases,
+    errorPatterns,
+    recs,
+    outcomes
+  } = input;
+  let currentTemplate;
+  if (existsSync(templatePath)) {
+    currentTemplate = readFileSync(templatePath, "utf-8");
+  } else {
+    currentTemplate = DEFAULT_PROMPT_TEMPLATE;
+    const dir = join(homedir(), ".stackmemory", "conductor");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(templatePath, currentTemplate);
+  }
+  const failPhaseSummary = Object.entries(failPhases).sort((a, b) => b[1] - a[1]).map(([phase, count]) => `  - ${phase}: ${count} failures`).join("\n");
+  const errorSummary = Object.entries(errorPatterns).sort((a, b) => b[1] - a[1]).map(([pattern, count]) => `  - ${pattern}: ${count} occurrences`).join("\n");
+  const failedOutcomes = outcomes.filter((o) => o.outcome === "failure" && o.errorTail).slice(-5);
+  const errorTails = failedOutcomes.map(
+    (o) => `  [${o.issue} attempt ${o.attempt}, phase: ${o.phase}]
+  ${o.errorTail}`
+  ).join("\n\n");
+  const mutationPrompt = `You are optimizing a prompt template for autonomous AI coding agents managed by a conductor system.
+
+CURRENT PROMPT TEMPLATE:
+\`\`\`markdown
+${currentTemplate}
+\`\`\`
+
+PERFORMANCE DATA:
+- Success rate: ${successRate}%
+- Total failures: ${failures}
+
+FAILURE PHASE BREAKDOWN:
+${failPhaseSummary || "  (none)"}
+
+ERROR PATTERNS:
+${errorSummary || "  (none)"}
+
+SAMPLE ERROR TAILS FROM RECENT FAILURES:
+${errorTails || "  (none)"}
+
+RECOMMENDATIONS FROM ANALYSIS:
+${recs.map((r) => `- ${r}`).join("\n")}
+
+YOUR TASK:
+Improve the prompt template to reduce failures. Focus on:
+1. Adding specific instructions that address the most common failure modes
+2. Making implicit requirements explicit (lint rules, test commands, commit format)
+3. Adding guardrails for the error patterns seen (e.g., if lint failures are common, add lint-specific instructions)
+4. Keeping the template concise \u2014 agents work better with clear, structured prompts
+5. Preserving all {{VARIABLE}} placeholders exactly as-is
+
+REQUIREMENTS:
+- Output ONLY the improved markdown template
+- Keep all {{VARIABLE}} placeholders: {{ISSUE_ID}}, {{TITLE}}, {{DESCRIPTION}}, {{LABELS}}, {{PRIORITY}}, {{ATTEMPT}}, {{PRIOR_CONTEXT}}
+- Do not add commentary, explanations, or markdown fences around the output
+- Target similar length to the current template (no bloat)
+
+OUTPUT THE IMPROVED TEMPLATE:`;
+  try {
+    console.log(
+      `    ${c.d}Calling Claude to generate improved template...${c.r}`
+    );
+    const evolved = await spawnClaudePrint(mutationPrompt);
+    if (!evolved.trim()) {
+      console.log(`    ${c.red}Empty response from Claude \u2014 skipping.${c.r}`);
+      return;
+    }
+    const requiredVars = ["{{ISSUE_ID}}", "{{TITLE}}", "{{DESCRIPTION}}"];
+    const missing = requiredVars.filter((v) => !evolved.includes(v));
+    if (missing.length > 0) {
+      console.log(
+        `    ${c.red}Evolved template missing variables: ${missing.join(", ")} \u2014 skipping.${c.r}`
+      );
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const backupPath = templatePath.replace(".md", `.backup-${timestamp}.md`);
+    copyFileSync(templatePath, backupPath);
+    console.log(`    ${c.d}Backed up to ${backupPath}${c.r}`);
+    writeFileSync(templatePath, evolved.trim() + "\n");
+    console.log(
+      `    ${c.green}Evolved template written to ${templatePath}${c.r}`
+    );
+    const evolutionLog = join(
+      homedir(),
+      ".stackmemory",
+      "conductor",
+      "evolution-log.jsonl"
+    );
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      successRate,
+      failures,
+      failPhases,
+      errorPatterns,
+      backupPath
+    };
+    const dir = join(homedir(), ".stackmemory", "conductor");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      evolutionLog,
+      (existsSync(evolutionLog) ? readFileSync(evolutionLog, "utf-8") : "") + JSON.stringify(entry) + "\n"
+    );
+    console.log(`    ${c.d}Evolution logged to ${evolutionLog}${c.r}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(`    ${c.red}Evolution failed: ${msg}${c.r}`);
+    console.log(
+      `    ${c.d}Tip: Ensure 'claude' CLI is available and authenticated.${c.r}`
+    );
+  }
+}
 function createConductorCommands() {
   const cmd = new Command("conductor");
   cmd.description("Conductor \u2014 autonomous agent orchestration via Linear");
@@ -538,12 +819,25 @@ function createConductorCommands() {
       const elapsedStr = formatElapsed(s.elapsed).replace(" ago", "");
       let hasCommits = false;
       if (s.workspacePath && existsSync(s.workspacePath)) {
+        let baseBranch = "main";
         try {
-          const log = execSync("git log origin/main..HEAD --oneline", {
+          const ref = execSync("git symbolic-ref refs/remotes/origin/HEAD", {
             cwd: s.workspacePath,
             encoding: "utf-8",
-            timeout: 1e4
-          });
+            timeout: 5e3
+          }).trim();
+          baseBranch = ref.replace("refs/remotes/origin/", "");
+        } catch {
+        }
+        try {
+          const log = execSync(
+            `git log origin/${baseBranch}..HEAD --oneline`,
+            {
+              cwd: s.workspacePath,
+              encoding: "utf-8",
+              timeout: 1e4
+            }
+          );
           hasCommits = log.trim().length > 0;
         } catch {
         }
@@ -600,20 +894,30 @@ function createConductorCommands() {
     const lines = parseInt(options.lines, 10);
     const args = options.follow ? ["-f", "-n", String(lines), logPath] : ["-n", String(lines), logPath];
     const tail = cpSpawn("tail", args, { stdio: "inherit" });
+    const forward = () => {
+      tail.kill("SIGTERM");
+    };
+    process.on("SIGINT", forward);
+    process.on("SIGTERM", forward);
     await new Promise((resolve) => {
       tail.on("close", () => {
+        process.removeListener("SIGINT", forward);
+        process.removeListener("SIGTERM", forward);
         resolve();
       });
-      const forward = () => {
-        tail.kill("SIGTERM");
-      };
-      process.on("SIGINT", forward);
-      process.on("SIGTERM", forward);
     });
   });
   cmd.command("learn").description(
     "Analyze agent outcomes and generate improved prompt templates"
-  ).option("--last <n>", "Analyze last N outcomes (default: all)", "0").option("--failures-only", "Only analyze failures", false).option("--export", "Export analysis as JSON", false).action(async (options) => {
+  ).option("--last <n>", "Analyze last N outcomes (default: all)", "0").option("--failures-only", "Only analyze failures", false).option("--export", "Export analysis as JSON", false).option(
+    "--evolve",
+    "Auto-mutate prompt template using GEPA-style evolution from failure data",
+    false
+  ).option(
+    "--predict",
+    "Show difficulty predictions alongside actual outcomes",
+    false
+  ).action(async (options) => {
     const logPath = getOutcomesLogPath();
     if (!existsSync(logPath)) {
       console.log(
@@ -792,8 +1096,171 @@ function createConductorCommands() {
       console.log(`
   ${c.d}Using custom template: ${templatePath}${c.r}`);
     }
+    if (options.evolve) {
+      console.log(`
+  ${c.b}${c.cyan}Evolving prompt template...${c.r}
+`);
+      await evolvePromptTemplate({
+        templatePath,
+        successRate,
+        failures,
+        failPhases,
+        errorPatterns,
+        recs,
+        outcomes
+      });
+    }
+    if (options.predict) {
+      console.log(
+        `
+  ${c.b}${c.purple}Difficulty Predictions vs Actual${c.r}
+`
+      );
+      const byIssue = /* @__PURE__ */ new Map();
+      for (const o of outcomes) {
+        byIssue.set(o.issue, o);
+      }
+      const difficultyColor = {
+        easy: c.green,
+        medium: c.yellow,
+        hard: c.red
+      };
+      for (const [issue, outcome] of byIssue) {
+        const issueLabels = outcome.labels || [];
+        const otherOutcomes = outcomes.filter((o) => o.issue !== issue);
+        const pred = predictDifficulty(
+          issueLabels,
+          "",
+          // no description in outcome data
+          0,
+          // no priority in outcome data
+          otherOutcomes
+        );
+        const actualDifficulty = outcome.outcome === "success" && outcome.toolCalls < 40 ? "easy" : outcome.outcome === "failure" || outcome.toolCalls > 80 ? "hard" : "medium";
+        const match = pred.difficulty === actualDifficulty;
+        const matchIcon = match ? `${c.green}\u2713${c.r}` : `${c.red}\u2717${c.r}`;
+        console.log(
+          `    ${matchIcon} ${c.white}${issue.padEnd(12)}${c.r}  predicted: ${difficultyColor[pred.difficulty]}${pred.difficulty.padEnd(6)}${c.r}  actual: ${difficultyColor[actualDifficulty]}${actualDifficulty.padEnd(6)}${c.r}  ${c.gray}(${Math.round(pred.confidence * 100)}% conf)${c.r}`
+        );
+      }
+      const issueList = [...byIssue.values()];
+      const correct = issueList.filter((o) => {
+        const otherOutcomes = outcomes.filter((oo) => oo.issue !== o.issue);
+        const pred = predictDifficulty(o.labels || [], "", 0, otherOutcomes);
+        const actual = o.outcome === "success" && o.toolCalls < 40 ? "easy" : o.outcome === "failure" || o.toolCalls > 80 ? "hard" : "medium";
+        return pred.difficulty === actual;
+      }).length;
+      const accuracy = Math.round(correct / issueList.length * 100);
+      console.log(
+        `
+    ${c.b}Accuracy${c.r}: ${accuracy}% (${correct}/${issueList.length})`
+      );
+    }
     console.log("");
   });
+  cmd.command("predict [issue-id]").description("Predict difficulty for an issue based on historical outcomes").option("--title <title>", "Issue title (for testing without Linear)").option(
+    "--labels <labels>",
+    "Comma-separated labels (for testing without Linear)"
+  ).option("--priority <n>", "Priority 0-4 (for testing without Linear)", "0").option("--json", "Output as JSON", false).action(async (issueId, options) => {
+    let title = options.title || "";
+    let labels = options.labels ? options.labels.split(",").map((l) => l.trim()) : [];
+    let description = "";
+    let priority = parseInt(options.priority, 10) || 0;
+    if (issueId && !options.title && !options.labels) {
+      try {
+        const { LinearClient } = await import("../../integrations/linear/client.js");
+        const { LinearAuthManager } = await import("../../integrations/linear/auth.js");
+        let client;
+        try {
+          const authManager = new LinearAuthManager(process.cwd());
+          const token = await authManager.getValidToken();
+          client = new LinearClient({ apiKey: token, useBearer: true });
+        } catch {
+          const apiKey = process.env.LINEAR_API_KEY;
+          if (!apiKey) {
+            console.log(
+              `${c.red}No Linear auth found.${c.r} Use --title/--labels/--priority for testing.`
+            );
+            return;
+          }
+          client = new LinearClient({ apiKey });
+        }
+        const issue = await client.getIssue(issueId);
+        if (!issue) {
+          console.log(`${c.red}Issue ${issueId} not found.${c.r}`);
+          return;
+        }
+        title = issue.title;
+        description = issue.description || "";
+        labels = issue.labels.map((l) => l.name);
+        priority = issue.priority;
+      } catch (err) {
+        console.log(
+          `${c.red}Failed to fetch issue:${c.r} ${err.message}`
+        );
+        return;
+      }
+    }
+    if (!issueId && !options.title) {
+      console.log(
+        `${c.yellow}Provide an issue ID or --title/--labels for testing.${c.r}`
+      );
+      return;
+    }
+    const outcomes = loadOutcomes();
+    const pred = predictDifficulty(labels, description, priority, outcomes);
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            issueId: issueId || "inline",
+            title,
+            labels,
+            priority,
+            ...pred
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const difficultyColor = {
+      easy: c.green,
+      medium: c.yellow,
+      hard: c.red
+    };
+    console.log(`
+  ${c.b}${c.purple}Difficulty Prediction${c.r}
+`);
+    if (title) {
+      console.log(`  ${c.b}Issue${c.r}       ${issueId || "inline"}`);
+      console.log(`  ${c.b}Title${c.r}       ${title}`);
+    }
+    if (labels.length > 0) {
+      console.log(`  ${c.b}Labels${c.r}      ${labels.join(", ")}`);
+    }
+    if (priority > 0) {
+      console.log(`  ${c.b}Priority${c.r}    ${priority}`);
+    }
+    console.log(
+      `
+  ${c.b}Difficulty${c.r}  ${difficultyColor[pred.difficulty]}${pred.difficulty.toUpperCase()}${c.r}`
+    );
+    console.log(
+      `  ${c.b}Confidence${c.r}  ${Math.round(pred.confidence * 100)}%`
+    );
+    console.log(`
+  ${c.b}Signals${c.r}`);
+    for (const reason of pred.reasons) {
+      console.log(`    ${c.cyan}\u2192${c.r} ${reason}`);
+    }
+    console.log(
+      `
+  ${c.d}Based on ${outcomes.length} historical outcomes${c.r}
+`
+    );
+  });
   cmd.command("usage").description("Show token usage, budget, and time-to-exhaustion").option("--json", "Output as JSON", false).option("--scan", "Scan Claude Code JSONL logs for historical data", false).action(async (options) => {
     const statusPath = join(
       process.cwd(),
@@ -858,7 +1325,12 @@ function createConductorCommands() {
     "--mode <mode>",
     'Agent mode: "cli" (claude -p, session auth) or "adapter" (JSON-RPC, API key)',
     "cli"
+  ).option(
+    "--model <model>",
+    'Model routing: "auto" (complexity-based) or a specific model ID',
+    "auto"
   ).action(async (options) => {
+    ensureDefaultPromptTemplate();
     const conductor = new Conductor({
       teamId: options.team,
       activeStates: options.states.split(",").map((s) => s.trim()),
@@ -871,7 +1343,8 @@ function createConductorCommands() {
       baseBranch: options.branch,
       maxRetries: parseInt(options.retries, 10),
       turnTimeoutMs: parseInt(options.turnTimeout, 10),
-      agentMode: options.mode === "adapter" ? "adapter" : "cli"
+      agentMode: options.mode === "adapter" ? "adapter" : "cli",
+      model: options.model
     });
     await conductor.start();
   });
@@ -1017,14 +1490,14 @@ function createConductorCommands() {
         if (!paused) await render();
       }, refreshInterval);
       await new Promise((resolve) => {
-        process.on("SIGINT", () => {
+        const cleanup = () => {
           clearInterval(timer);
+          process.removeListener("SIGINT", cleanup);
+          process.removeListener("SIGTERM", cleanup);
           resolve();
-        });
-        process.on("SIGTERM", () => {
-          clearInterval(timer);
-          resolve();
-        });
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
       });
       return;
     }
@@ -1137,21 +1610,21 @@ function createConductorCommands() {
       }
     });
     await new Promise((resolve) => {
-      process.on("SIGINT", () => {
-        if (refreshTimer) clearTimeout(refreshTimer);
-        if (process.stdin.isTTY) process.stdin.setRawMode(false);
-        resolve();
-      });
-      process.on("SIGTERM", () => {
+      const cleanup = () => {
         if (refreshTimer) clearTimeout(refreshTimer);
         if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        process.removeListener("SIGINT", cleanup);
+        process.removeListener("SIGTERM", cleanup);
         resolve();
-      });
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
     });
   });
   return cmd;
 }
 export {
   createConductorCommands,
-  formatElapsed
+  formatElapsed,
+  predictDifficulty
 };