@stackmemoryai/stackmemory 1.6.0 → 1.6.2

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

@@ -275,6 +275,94 @@ function ensureDefaultPromptTemplate() {
   }
   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"], {
@@ -306,6 +394,68 @@ function spawnClaudePrint(prompt, timeoutMs = 12e4) {
     child.stdin.end();
   });
 }
+function printSimpleDiff(oldText, newText) {
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const oldSet = new Set(oldLines);
+  const newSet = new Set(newLines);
+  const removed = oldLines.filter((l) => !newSet.has(l));
+  const added = newLines.filter((l) => !oldSet.has(l));
+  const removedSet = new Set(removed);
+  const addedSet = new Set(added);
+  const CONTEXT = 2;
+  const changedOld = /* @__PURE__ */ new Set();
+  for (let i = 0; i < oldLines.length; i++) {
+    if (removedSet.has(oldLines[i])) changedOld.add(i);
+  }
+  const changedNew = /* @__PURE__ */ new Set();
+  for (let i = 0; i < newLines.length; i++) {
+    if (addedSet.has(newLines[i])) changedNew.add(i);
+  }
+  let lastPrinted = -1;
+  for (let i = 0; i < oldLines.length; i++) {
+    let nearChange = false;
+    for (let j = Math.max(0, i - CONTEXT); j <= Math.min(oldLines.length - 1, i + CONTEXT); j++) {
+      if (changedOld.has(j)) {
+        nearChange = true;
+        break;
+      }
+    }
+    if (!nearChange) continue;
+    if (lastPrinted >= 0 && i > lastPrinted + 1) {
+      console.log(`    ${c.d}...${c.r}`);
+    }
+    if (removedSet.has(oldLines[i])) {
+      console.log(`    ${c.red}- ${oldLines[i]}${c.r}`);
+    } else {
+      console.log(`      ${oldLines[i]}`);
+    }
+    lastPrinted = i;
+  }
+  if (removed.length > 0 && added.length > 0) {
+    console.log(`    ${c.d}---${c.r}`);
+  }
+  lastPrinted = -1;
+  for (let i = 0; i < newLines.length; i++) {
+    let nearChange = false;
+    for (let j = Math.max(0, i - CONTEXT); j <= Math.min(newLines.length - 1, i + CONTEXT); j++) {
+      if (changedNew.has(j)) {
+        nearChange = true;
+        break;
+      }
+    }
+    if (!nearChange) continue;
+    if (lastPrinted >= 0 && i > lastPrinted + 1) {
+      console.log(`    ${c.d}...${c.r}`);
+    }
+    if (addedSet.has(newLines[i])) {
+      console.log(`    ${c.green}+ ${newLines[i]}${c.r}`);
+    } else {
+      console.log(`      ${newLines[i]}`);
+    }
+    lastPrinted = i;
+  }
+}
 async function evolvePromptTemplate(input) {
   const {
     templatePath,
@@ -314,7 +464,8 @@ async function evolvePromptTemplate(input) {
     failPhases,
     errorPatterns,
     recs,
-    outcomes
+    outcomes,
+    dryRun
   } = input;
   let currentTemplate;
   if (existsSync(templatePath)) {
@@ -387,6 +538,17 @@ OUTPUT THE IMPROVED TEMPLATE:`;
       );
       return;
     }
+    if (dryRun) {
+      console.log(`
+    ${c.b}${c.cyan}Dry-run diff:${c.r}
+`);
+      printSimpleDiff(currentTemplate, evolved.trim());
+      console.log(
+        `
+    ${c.d}Dry run \u2014 no files modified. Run without --dry-run to apply.${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);
@@ -825,6 +987,14 @@ function createConductorCommands() {
     "--evolve",
     "Auto-mutate prompt template using GEPA-style evolution from failure data",
     false
+  ).option(
+    "--dry-run",
+    "Show evolved template without writing (use with --evolve)",
+    false
+  ).option(
+    "--predict",
+    "Show difficulty predictions alongside actual outcomes",
+    false
   ).action(async (options) => {
     const logPath = getOutcomesLogPath();
     if (!existsSync(logPath)) {
@@ -1015,11 +1185,161 @@ function createConductorCommands() {
         failPhases,
         errorPatterns,
         recs,
-        outcomes
+        outcomes,
+        dryRun: options.dryRun
       });
     }
+    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(),
@@ -1084,6 +1404,13 @@ 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"
+  ).option(
+    "--no-pr",
+    "Disable automatic GitHub PR creation after agent success"
   ).action(async (options) => {
     ensureDefaultPromptTemplate();
     const conductor = new Conductor({
@@ -1098,7 +1425,9 @@ 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,
+      autoPR: options.pr
     });
     await conductor.start();
   });
@@ -1379,5 +1708,6 @@ function createConductorCommands() {
 }
 export {
   createConductorCommands,
-  formatElapsed
+  formatElapsed,
+  predictDifficulty
 };