@stackmemoryai/stackmemory 1.10.5 → 1.14.0

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

@@ -18,6 +18,7 @@ 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 { createVisionCommand } from "./vision.js";
 import {
   getAgentStatusDir,
   getOutcomesLogPath
@@ -189,13 +190,13 @@ function progressBar(pct, width) {
   return `${col}${"\u2501".repeat(filled)}${c.d}${"\u254C".repeat(empty)}${c.r}`;
 }
 function scanAgentStatuses() {
-  const agentsDir2 = join(homedir(), ".stackmemory", "conductor", "agents");
-  if (!existsSync(agentsDir2)) return [];
-  const entries = readdirSync(agentsDir2, { withFileTypes: true });
+  const agentsDir = join(homedir(), ".stackmemory", "conductor", "agents");
+  if (!existsSync(agentsDir)) return [];
+  const entries = readdirSync(agentsDir, { withFileTypes: true });
   const statuses = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const statusPath = join(agentsDir2, entry.name, "status.json");
+    const statusPath = join(agentsDir, entry.name, "status.json");
     if (!existsSync(statusPath)) continue;
     try {
       const data = JSON.parse(readFileSync(statusPath, "utf-8"));
@@ -668,6 +669,7 @@ function createConductorCommands() {
     }
     cmd.help();
   });
+  cmd.addCommand(createVisionCommand());
   cmd.command("capture").description("Capture workspace context after an agent run").requiredOption("--issue <id>", "Issue identifier (e.g., STA-476)").option("--workspace <path>", "Workspace directory", process.cwd()).option("--attempt <n>", "Attempt number", "1").action(async (options) => {
     const workspace = options.workspace;
     const issueId = options.issue;
@@ -953,6 +955,7 @@ function createConductorCommands() {
     console.log("");
   });
   cmd.command("finalize").description("Clean up completed/dead agents that conductor missed").option("--dry-run", "Show what would be done without doing it", false).action(async (options) => {
+    const agentsDir = join(homedir(), ".stackmemory", "conductor", "agents");
     const statuses = scanAgentStatuses();
     const needsFinalize = statuses.map((s) => ({ ...s, ...enrichStatus(s) })).filter((s) => {
       return !s.alive || s.elapsed > STALE_FINALIZE_THRESHOLD_MS;
@@ -1038,6 +1041,221 @@ function createConductorCommands() {
       );
     }
   });
+  const isMerged = (repo, branch, lane) => {
+    try {
+      execSync(`git merge-base --is-ancestor "${branch}" "${lane}"`, {
+        cwd: repo,
+        stdio: "pipe",
+        timeout: 5e3
+      });
+      return true;
+    } catch (err) {
+      const status = err.status;
+      if (status !== 1) throw err;
+    }
+    try {
+      const out = execSync(`git cherry "${lane}" "${branch}"`, {
+        cwd: repo,
+        encoding: "utf-8",
+        timeout: 1e4
+      }).trim();
+      if (!out) return true;
+      const lines = out.split("\n").filter(Boolean);
+      return lines.every((l) => l.startsWith("-"));
+    } catch {
+      return false;
+    }
+  };
+  const bucketLaneBranches = (repo, lane) => {
+    let all = [];
+    try {
+      all = execSync(`git branch --list 'worktree-agent-*'`, {
+        cwd: repo,
+        encoding: "utf-8",
+        timeout: 1e4
+      }).split("\n").map((s) => s.trim().replace(/^[*+]\s*/, "")).filter(Boolean);
+    } catch {
+    }
+    const merged = [];
+    const unmerged = [];
+    for (const b of all) {
+      (isMerged(repo, b, lane) ? merged : unmerged).push(b);
+    }
+    return { merged, unmerged };
+  };
+  const getWorktreeCleanliness = (repo, wtPath) => {
+    try {
+      const out = execSync(`git -C "${wtPath}" status --short`, {
+        cwd: repo,
+        encoding: "utf-8",
+        timeout: 5e3
+      });
+      return out.trim().length > 0 ? "dirty" : "clean";
+    } catch {
+      return "unknown";
+    }
+  };
+  const laneCmd = cmd.command("lane").description(
+    "Inspect or clean up worktree-agent-* branches against a lane"
+  );
+  laneCmd.command("status").description(
+    "List worktree-agent-* branches and their merge state vs the lane"
+  ).option(
+    "--lane <branch>",
+    "Lane branch to compare against (default: current branch)"
+  ).option("--repo <path>", "Git repo root", process.cwd()).action((options) => {
+    const repo = options.repo;
+    const lane = options.lane || execSync("git branch --show-current", {
+      cwd: repo,
+      encoding: "utf-8"
+    }).trim();
+    if (!lane) {
+      console.error(
+        `${c.red}Could not resolve lane branch.${c.r} Pass --lane.`
+      );
+      process.exit(1);
+    }
+    const { merged, unmerged } = bucketLaneBranches(repo, lane);
+    console.log(`
+  ${c.b}Lane:${c.r} ${c.cyan}${lane}${c.r}
+`);
+    if (merged.length) {
+      console.log(`  ${c.green}merged (${merged.length}):${c.r}`);
+      for (const b of merged) console.log(`    ${c.gray}\u2713${c.r} ${b}`);
+    }
+    if (unmerged.length) {
+      console.log(`
+  ${c.orange}unmerged (${unmerged.length}):${c.r}`);
+      for (const b of unmerged) console.log(`    ${c.orange}\u2022${c.r} ${b}`);
+    }
+    if (!merged.length && !unmerged.length) {
+      console.log(`  ${c.gray}No worktree-agent-* branches found.${c.r}`);
+    }
+  });
+  laneCmd.command("cleanup").description(
+    "Remove worktree-agent-* branches and worktrees already merged into the lane"
+  ).option(
+    "--lane <branch>",
+    "Lane branch to compare against (default: current branch)"
+  ).option("--repo <path>", "Git repo root", process.cwd()).option("--dry-run", "Show what would be removed without doing it", false).option(
+    "--force",
+    "Remove worktrees even if they have uncommitted changes",
+    false
+  ).action((options) => {
+    const repo = options.repo;
+    const lane = options.lane || execSync("git branch --show-current", {
+      cwd: repo,
+      encoding: "utf-8"
+    }).trim();
+    if (!lane) {
+      console.error(
+        `${c.red}Could not resolve lane branch.${c.r} Pass --lane.`
+      );
+      process.exit(1);
+    }
+    const { merged } = bucketLaneBranches(repo, lane);
+    if (merged.length === 0) {
+      console.log(
+        `${c.green}Nothing to clean up for lane ${c.cyan}${lane}${c.r}.`
+      );
+      return;
+    }
+    const worktreeMap = /* @__PURE__ */ new Map();
+    try {
+      const wt = execSync("git worktree list --porcelain", {
+        cwd: repo,
+        encoding: "utf-8",
+        timeout: 1e4
+      });
+      let currentPath = "";
+      for (const line of wt.split("\n")) {
+        if (line.startsWith("worktree ")) {
+          currentPath = line.slice("worktree ".length).trim();
+        } else if (line.startsWith("branch ")) {
+          const ref = line.slice("branch ".length).trim();
+          const b = ref.replace(/^refs\/heads\//, "");
+          if (currentPath) worktreeMap.set(b, currentPath);
+        }
+      }
+    } catch {
+    }
+    console.log(
+      `
+  ${c.b}Lane:${c.r} ${c.cyan}${lane}${c.r}  ${c.d}(${merged.length} merged branches)${c.r}
+`
+    );
+    let skippedDirty = 0;
+    let skippedUnknown = 0;
+    for (const branch of merged) {
+      const wtPath = worktreeMap.get(branch);
+      const cleanliness = wtPath ? getWorktreeCleanliness(repo, wtPath) : "unknown";
+      const dirty = cleanliness === "dirty";
+      if (dirty && !options.force) {
+        skippedDirty++;
+        console.log(
+          `  ${c.orange}\u26A0${c.r}  ${c.orange}dirty${c.r} ${wtPath} ${c.d}(skipping ${branch} \u2014 pass --force to remove)${c.r}`
+        );
+        continue;
+      }
+      if (wtPath && cleanliness === "unknown" && !options.force) {
+        skippedUnknown++;
+        console.log(
+          `  ${c.orange}\u26A0${c.r}  ${c.orange}unknown${c.r} ${wtPath} ${c.d}(skipping ${branch} \u2014 could not verify clean state; pass --force to remove)${c.r}`
+        );
+        continue;
+      }
+      const dirtyTag = dirty ? ` ${c.orange}[dirty]${c.r}` : "";
+      const unknownTag = cleanliness === "unknown" ? ` ${c.orange}[unknown]${c.r}` : "";
+      const action = wtPath ? `${c.gray}worktree remove${c.r} ${wtPath}${dirtyTag}${unknownTag} + ${c.gray}branch -D${c.r} ${branch}` : `${c.gray}branch -D${c.r} ${branch}`;
+      console.log(`  ${c.green}\u2713${c.r} ${action}`);
+      if (options.dryRun) continue;
+      if (wtPath) {
+        try {
+          execSync(`git worktree remove "${wtPath}" --force`, {
+            cwd: repo,
+            stdio: "pipe",
+            timeout: 15e3
+          });
+        } catch (err) {
+          console.log(
+            `     ${c.red}worktree remove failed:${c.r} ${err.message}`
+          );
+        }
+      }
+      try {
+        execSync(`git branch -D "${branch}"`, {
+          cwd: repo,
+          stdio: "pipe",
+          timeout: 5e3
+        });
+      } catch (err) {
+        console.log(
+          `     ${c.red}branch -D failed:${c.r} ${err.message}`
+        );
+      }
+    }
+    if (!options.dryRun) {
+      try {
+        execSync("git worktree prune", {
+          cwd: repo,
+          stdio: "pipe",
+          timeout: 1e4
+        });
+      } catch {
+      }
+      const skipNote = skippedDirty ? ` ${c.orange}(${skippedDirty} dirty skipped \u2014 pass --force)${c.r}` : "";
+      const unknownNote = skippedUnknown ? ` ${c.orange}(${skippedUnknown} unknown skipped \u2014 pass --force)${c.r}` : "";
+      console.log(`
+  ${c.green}Done.${c.r}${skipNote}${unknownNote}`);
+    } else {
+      const skipNote = skippedDirty ? ` ${c.orange}(${skippedDirty} dirty would be skipped \u2014 pass --force to include)${c.r}` : "";
+      const unknownNote = skippedUnknown ? ` ${c.orange}(${skippedUnknown} unknown would be skipped \u2014 pass --force to include)${c.r}` : "";
+      console.log(
+        `
+  ${c.d}Dry run \u2014 no changes made. Remove --dry-run to execute.${c.r}${skipNote}${unknownNote}`
+      );
+    }
+  });
   cmd.command("logs").description("Tail agent output log").argument("<issue-id>", "Issue identifier (e.g., STA-499)").option("-f, --follow", "Follow the log (tail -f)", false).option("-n, --lines <n>", "Number of lines to show", "50").action(async (issueId, options) => {
     const logPath = join(getAgentStatusDir(issueId), "output.log");
     if (!existsSync(logPath)) {
@@ -1521,6 +1739,13 @@ function createConductorCommands() {
   ).option(
     "--no-pr",
     "Disable automatic GitHub PR creation after agent success"
+  ).option(
+    "--workspace-mode <mode>",
+    'Workspace mode: "auto" (detect GitButler), "gitbutler", or "worktree"',
+    "auto"
+  ).option(
+    "--lane <branch>",
+    "Optional lane branch. When set, conductor uses git worktrees rooted at the lane as worktree-agent-<id> and suppresses PRs (lane is human-curated)."
   ).action(async (options) => {
     ensureDefaultPromptTemplate();
     const conductor = new Conductor({
@@ -1537,7 +1762,9 @@ function createConductorCommands() {
       turnTimeoutMs: parseInt(options.turnTimeout, 10),
       agentMode: options.mode === "adapter" ? "adapter" : "cli",
       model: options.model,
-      autoPR: options.pr
+      autoPR: options.lane ? false : options.pr,
+      workspaceMode: options.workspaceMode,
+      laneBranch: options.lane
     });
     await conductor.start();
   });