@stackmemoryai/stackmemory 1.5.2 → 1.5.4

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

@@ -3,10 +3,17 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { spawn, execSync } from "child_process";
-import { existsSync, mkdirSync, rmSync } from "fs";
+import {
+  existsSync,
+  mkdirSync,
+  rmSync,
+  writeFileSync,
+  createWriteStream
+} from "fs";
 import { join, dirname } from "path";
-import { tmpdir } from "os";
+import { tmpdir, homedir } from "os";
 import { fileURLToPath } from "url";
+import { Transform } from "stream";
 import { logger } from "../../core/monitoring/logger.js";
 import {
   LinearClient
@@ -26,6 +33,95 @@ function findPackageRoot() {
   }
   return dirname(currentFile);
 }
+function getAgentStatusDir(issueIdentifier) {
+  return join(
+    homedir(),
+    ".stackmemory",
+    "conductor",
+    "agents",
+    issueIdentifier
+  );
+}
+function ensureAgentStatusDir(issueIdentifier) {
+  const dir = getAgentStatusDir(issueIdentifier);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+class TeeTransform extends Transform {
+  logStream;
+  constructor(logStream) {
+    super();
+    this.logStream = logStream;
+  }
+  _transform(chunk, _encoding, callback) {
+    this.logStream.write(chunk);
+    this.push(chunk);
+    callback();
+  }
+  _flush(callback) {
+    this.logStream.end();
+    callback();
+  }
+}
+function inferPhaseFromStreamJson(event) {
+  if (event.type !== "assistant") return null;
+  const message = event.message;
+  const content = message?.content || [];
+  for (const block of content) {
+    if (block.type !== "tool_use") continue;
+    const toolLower = (block.name || "").toLowerCase();
+    if (toolLower.includes("read") || toolLower.includes("glob") || toolLower.includes("grep") || toolLower.includes("search")) {
+      return "reading";
+    }
+    if (toolLower.includes("todowrite") || toolLower.includes("todo")) {
+      return "planning";
+    }
+    if (toolLower.includes("edit") || toolLower.includes("write") || toolLower.includes("bash")) {
+      if (toolLower === "bash") {
+        const input = block.input;
+        const command = (input?.command ?? "").toLowerCase();
+        if (command.includes("git commit") || command.includes("git add")) {
+          return "committing";
+        }
+      }
+      return "implementing";
+    }
+    if (toolLower.includes("test")) {
+      return "testing";
+    }
+  }
+  return null;
+}
+function inferPhase(msg) {
+  const method = msg.method;
+  const params = msg.params;
+  if (method === "item/commandExecution/started") {
+    const tool = params?.tool || params?.name || "";
+    const toolLower = tool.toLowerCase();
+    if (toolLower.includes("read") || toolLower.includes("glob") || toolLower.includes("grep") || toolLower.includes("search")) {
+      return "reading";
+    }
+    if (toolLower.includes("todowrite") || toolLower.includes("todo")) {
+      return "planning";
+    }
+    if (toolLower.includes("edit") || toolLower.includes("write") || toolLower.includes("bash")) {
+      return "implementing";
+    }
+    if (toolLower.includes("test")) {
+      return "testing";
+    }
+  }
+  if (method === "item/commandExecution/started") {
+    const args = params?.arguments;
+    const command = (args?.command ?? params?.command) || "";
+    if (command.includes("git commit") || command.includes("git add")) {
+      return "committing";
+    }
+  }
+  return null;
+}
 const DEFAULT_CONFIG = {
   activeStates: ["Todo"],
   terminalStates: ["Done", "Cancelled", "Canceled", "Closed"],
@@ -44,7 +140,8 @@ const DEFAULT_CONFIG = {
   ),
   turnTimeoutMs: 36e5,
   maxRetries: 1,
-  hookTimeoutMs: 6e4
+  hookTimeoutMs: 6e4,
+  agentMode: "cli"
 };
 class Conductor {
   config;
@@ -130,6 +227,7 @@ class Conductor {
     console.log(
       `Orchestrator started \u2014 polling every ${this.config.pollIntervalMs / 1e3}s, max ${this.config.maxConcurrent} concurrent`
     );
+    this.writeStatusFile();
     const shutdown = () => this.stop();
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
@@ -175,6 +273,7 @@ class Conductor {
     }
     this.running.clear();
     this.claimed.clear();
+    this.clearStatusFile();
     console.log(
       `Orchestrator stopped. Completed: ${this.completeCount}, Failed: ${this.failCount}`
     );
@@ -198,6 +297,82 @@ class Conductor {
       issues
     };
   }
+  // ── Status File ──
+  /**
+   * Write current conductor state to .stackmemory/conductor-status.json
+   * for consumption by `stackmemory dashboard` and other tools.
+   */
+  writeStatusFile() {
+    const statusDir = join(this.config.repoRoot, ".stackmemory");
+    if (!existsSync(statusDir)) return;
+    const status = {
+      pid: process.pid,
+      startedAt: this.startedAt,
+      updatedAt: Date.now(),
+      running: Array.from(this.running.values()).map((r) => ({
+        identifier: r.issue.identifier,
+        title: r.issue.title,
+        status: r.status,
+        attempt: r.attempt,
+        startedAt: r.startedAt,
+        runtime: Date.now() - r.startedAt
+      })),
+      queued: Array.from(this.claimed).filter(
+        (id) => !this.running.has(id) && !this.completed.has(id)
+      ).length,
+      completed: this.completeCount,
+      failed: this.failCount,
+      totalAttempts: this.totalAttempts,
+      maxConcurrent: this.config.maxConcurrent,
+      stopping: this.stopping
+    };
+    try {
+      writeFileSync(
+        join(statusDir, "conductor-status.json"),
+        JSON.stringify(status, null, 2)
+      );
+    } catch {
+    }
+  }
+  clearStatusFile() {
+    const statusPath = join(
+      this.config.repoRoot,
+      ".stackmemory",
+      "conductor-status.json"
+    );
+    try {
+      if (existsSync(statusPath)) rmSync(statusPath);
+    } catch {
+    }
+  }
+  // ── Agent Status Files ──
+  /**
+   * Write per-agent status to ~/.stackmemory/conductor/agents/<issue-id>/status.json
+   */
+  writeAgentStatus(issueIdentifier, run) {
+    try {
+      const dir = ensureAgentStatusDir(issueIdentifier);
+      const status = {
+        issue: issueIdentifier,
+        pid: run.process?.pid || process.pid,
+        started: new Date(run.startedAt).toISOString(),
+        lastUpdate: (/* @__PURE__ */ new Date()).toISOString(),
+        phase: run.phase,
+        filesModified: run.filesModified,
+        toolCalls: run.toolCalls,
+        tokensUsed: run.tokensUsed
+      };
+      writeFileSync(join(dir, "status.json"), JSON.stringify(status, null, 2));
+    } catch {
+    }
+  }
+  /**
+   * Open a log file write stream for an agent.
+   */
+  openAgentLogStream(issueIdentifier) {
+    const dir = ensureAgentStatusDir(issueIdentifier);
+    return createWriteStream(join(dir, "output.log"), { flags: "a" });
+  }
   // ── Polling ──
   async schedulePoll() {
     while (!this.stopping) {
@@ -210,6 +385,7 @@ class Conductor {
       } catch (err) {
         logger.error("Poll cycle failed", { error: err.message });
       }
+      this.writeStatusFile();
     }
   }
   async poll() {
@@ -337,8 +513,13 @@ class Conductor {
       process: null,
       attempt: 1,
       startedAt: Date.now(),
-      status: "starting"
+      status: "starting",
+      phase: "reading",
+      toolCalls: 0,
+      filesModified: 0,
+      tokensUsed: 0
     };
+    this.writeAgentStatus(issue.identifier, run);
     this.running.set(issueId, run);
     this.totalAttempts++;
     console.log(`[${issue.identifier}] Dispatching: ${issue.title}`);
@@ -347,23 +528,26 @@ class Conductor {
       run.workspacePath = workspacePath;
       await this.transitionIssue(issue, this.config.inProgressState);
       await this.runHook("after-create", workspacePath, issue);
-      run.status = "running";
-      await this.runAgent(issue, run);
-      run.status = "completed";
-      this.completeCount++;
-      await this.runHook("after-run", workspacePath, issue, run.attempt);
-      this.takeSnapshot(workspacePath, issue);
-      await this.transitionIssue(issue, this.config.inReviewState);
-      console.log(`[${issue.identifier}] Completed successfully`);
+      await this.attemptRun(issue, run);
     } catch (err) {
-      run.status = "failed";
-      run.error = err.message;
-      logger.error("Issue dispatch failed", {
-        identifier: issue.identifier,
-        error: run.error,
-        attempt: run.attempt
-      });
-      if (run.workspacePath) {
+      this.failCount++;
+      console.log(`[${issue.identifier}] Failed: ${err.message}`);
+    } finally {
+      this.running.delete(issueId);
+      this.writeStatusFile();
+    }
+  }
+  /**
+   * Run the agent with retry logic. Throws on final failure.
+   */
+  async attemptRun(issue, run) {
+    const maxAttempts = this.config.maxRetries + 1;
+    while (run.attempt <= maxAttempts) {
+      try {
+        run.status = "running";
+        await this.runAgent(issue, run);
+        run.status = "completed";
+        this.completeCount++;
         await this.runHook(
           "after-run",
           run.workspacePath,
@@ -371,47 +555,44 @@ class Conductor {
           run.attempt
         ).catch(() => {
         });
-      }
-      if (run.attempt < this.config.maxRetries + 1) {
+        this.takeSnapshot(run.workspacePath, issue);
+        await this.transitionIssue(issue, this.config.inReviewState);
         console.log(
-          `[${issue.identifier}] Failed (attempt ${run.attempt}), retrying...`
+          run.attempt === 1 ? `[${issue.identifier}] Completed successfully` : `[${issue.identifier}] Completed on retry ${run.attempt}`
         );
-        run.attempt++;
-        this.totalAttempts++;
-        const backoffMs = Math.min(1e3 * Math.pow(2, run.attempt - 1), 3e5);
-        await new Promise((r) => setTimeout(r, backoffMs));
-        if (!this.stopping) {
-          try {
-            run.status = "running";
-            await this.runAgent(issue, run);
-            run.status = "completed";
-            this.completeCount++;
-            await this.runHook(
-              "after-run",
-              run.workspacePath,
-              issue,
-              run.attempt
-            ).catch(() => {
-            });
-            await this.transitionIssue(issue, this.config.inReviewState);
-            console.log(
-              `[${issue.identifier}] Completed on retry ${run.attempt}`
-            );
-          } catch (retryErr) {
-            run.status = "failed";
-            run.error = retryErr.message;
-            this.failCount++;
-            console.log(
-              `[${issue.identifier}] Failed after ${run.attempt} attempts: ${run.error}`
-            );
-          }
+        return;
+      } catch (err) {
+        run.status = "failed";
+        run.error = err.message;
+        logger.error("Agent run failed", {
+          identifier: issue.identifier,
+          error: run.error,
+          attempt: run.attempt
+        });
+        if (run.workspacePath) {
+          await this.runHook(
+            "after-run",
+            run.workspacePath,
+            issue,
+            run.attempt
+          ).catch(() => {
+          });
+        }
+        if (run.attempt < maxAttempts && !this.stopping) {
+          console.log(
+            `[${issue.identifier}] Failed (attempt ${run.attempt}), retrying...`
+          );
+          run.attempt++;
+          this.totalAttempts++;
+          const backoffMs = Math.min(
+            1e3 * Math.pow(2, run.attempt - 1),
+            3e5
+          );
+          await new Promise((r) => setTimeout(r, backoffMs));
+        } else {
+          throw err;
         }
-      } else {
-        this.failCount++;
-        console.log(`[${issue.identifier}] Failed: ${run.error}`);
       }
-    } finally {
-      this.running.delete(issueId);
     }
   }
   // ── Workspace Management ──
@@ -492,13 +673,167 @@ class Conductor {
     return identifier.replace(/[^A-Za-z0-9._-]/g, "_");
   }
   // ── Agent Execution ──
-  runAgent(issue, run) {
+  async runAgent(issue, run) {
+    if (this.config.agentMode === "cli") {
+      try {
+        return await this.runAgentCLI(issue, run);
+      } catch (err) {
+        const msg = err.message || "";
+        if (msg.includes("usage limits") || msg.includes("rate_limit") || msg.includes("overloaded")) {
+          logger.warn("CLI mode hit limits, falling back to adapter", {
+            identifier: issue.identifier,
+            error: msg.slice(0, 200)
+          });
+          run.toolCalls = 0;
+          run.filesModified = 0;
+          run.tokensUsed = 0;
+          run.phase = "reading";
+          return this.runAgentAdapter(issue, run);
+        }
+        throw err;
+      }
+    }
+    return this.runAgentAdapter(issue, run);
+  }
+  /**
+   * CLI mode: spawn `claude -p --output-format stream-json` directly.
+   * Uses whatever auth the environment provides (session quota, API key, etc).
+   */
+  runAgentCLI(issue, run) {
     return new Promise((resolve, reject) => {
       const prompt = this.buildPrompt(issue, run.attempt);
+      const proc = spawn(
+        "claude",
+        [
+          "-p",
+          "--output-format",
+          "stream-json",
+          "--dangerously-skip-permissions",
+          prompt
+        ],
+        {
+          cwd: run.workspacePath,
+          env: (() => {
+            const env = { ...process.env };
+            delete env.CLAUDECODE;
+            delete env.ANTHROPIC_API_KEY;
+            return {
+              ...env,
+              SYMPHONY_WORKSPACE_DIR: run.workspacePath,
+              SYMPHONY_ISSUE_ID: issue.id,
+              SYMPHONY_ISSUE_IDENTIFIER: issue.identifier,
+              SYMPHONY_ATTEMPT: String(run.attempt)
+            };
+          })(),
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+      run.process = proc;
+      const logStream = this.openAgentLogStream(issue.identifier);
+      run.logStream = logStream;
+      const tee = new TeeTransform(logStream);
+      proc.stdout.pipe(tee);
+      this.writeAgentStatus(issue.identifier, run);
+      let stderr = "";
+      let lastResultText = "";
+      const timer = setTimeout(() => {
+        logger.warn("Agent turn timeout (cli)", {
+          identifier: issue.identifier,
+          timeoutMs: this.config.turnTimeoutMs
+        });
+        proc.kill("SIGTERM");
+        reject(new Error(`Agent timeout after ${this.config.turnTimeoutMs}ms`));
+      }, this.config.turnTimeoutMs);
+      let lineBuffer = "";
+      tee.on("data", (chunk) => {
+        lineBuffer += chunk.toString();
+        const lines = lineBuffer.split("\n");
+        lineBuffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            const phase = inferPhaseFromStreamJson(event);
+            if (phase) {
+              run.phase = phase;
+            }
+            if (event.type === "assistant") {
+              const message = event.message;
+              const content = message?.content || [];
+              for (const block of content) {
+                if (block.type === "tool_use") {
+                  run.toolCalls++;
+                  const toolLower = (block.name || "").toLowerCase();
+                  if (toolLower.includes("edit") || toolLower.includes("write")) {
+                    run.filesModified++;
+                  }
+                }
+                if (block.type === "text" && block.text) {
+                  run.tokensUsed += Math.ceil(
+                    block.text.length / 4
+                  );
+                }
+              }
+            }
+            if (event.type === "result" && event.result) {
+              lastResultText = typeof event.result === "string" ? event.result : JSON.stringify(event.result);
+            }
+            if (run.toolCalls % 5 === 0 || phase) {
+              this.writeAgentStatus(issue.identifier, run);
+            }
+          } catch {
+          }
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+        const lines = data.toString().split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          logger.debug(`[${issue.identifier}] ${line}`);
+        }
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        reject(new Error(`Failed to spawn claude: ${err.message}`));
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        run.process = null;
+        if (run.logStream && !run.logStream.destroyed) {
+          run.logStream.end();
+        }
+        this.writeAgentStatus(issue.identifier, run);
+        if (code === 0) {
+          logger.info("Agent completed (cli)", {
+            identifier: issue.identifier,
+            toolCalls: run.toolCalls,
+            resultLength: lastResultText.length
+          });
+          resolve();
+        } else {
+          reject(
+            new Error(
+              `Claude exited with code ${code}: ${stderr.slice(0, 500)}`
+            )
+          );
+        }
+      });
+    });
+  }
+  /**
+   * Adapter mode: spawn claude-app-server.cjs via JSON-RPC protocol.
+   * Uses ANTHROPIC_API_KEY for auth.
+   */
+  runAgentAdapter(issue, run) {
+    return new Promise((resolve, reject) => {
+      const prompt = this.buildPrompt(issue, run.attempt);
+      const env = { ...process.env };
+      delete env.CLAUDECODE;
+      delete env.ANTHROPIC_API_KEY;
       const proc = spawn("node", [this.config.appServerPath], {
         cwd: run.workspacePath,
         env: {
-          ...process.env,
+          ...env,
           SYMPHONY_WORKSPACE_DIR: run.workspacePath,
           SYMPHONY_ISSUE_ID: issue.id,
           SYMPHONY_ISSUE_IDENTIFIER: issue.identifier,
@@ -507,6 +842,11 @@ class Conductor {
         stdio: ["pipe", "pipe", "pipe"]
       });
       run.process = proc;
+      const logStream = this.openAgentLogStream(issue.identifier);
+      run.logStream = logStream;
+      const tee = new TeeTransform(logStream);
+      proc.stdout.pipe(tee);
+      this.writeAgentStatus(issue.identifier, run);
       let stderr = "";
       let turnCompleted = false;
       const timer = setTimeout(() => {
@@ -525,7 +865,7 @@ class Conductor {
         proc.stdin.write(JSON.stringify(msg) + "\n");
       };
       let lineBuffer = "";
-      proc.stdout.on("data", (chunk) => {
+      tee.on("data", (chunk) => {
         lineBuffer += chunk.toString();
         const lines = lineBuffer.split("\n");
         lineBuffer = lines.pop() || "";
@@ -534,11 +874,33 @@ class Conductor {
           try {
             const msg = JSON.parse(line);
             this.handleAgentMessage(msg, issue, run);
+            const phase = inferPhase(msg);
+            if (phase) {
+              run.phase = phase;
+            }
+            if (msg.method === "item/commandExecution/started" || msg.method === "item/toolUse/started") {
+              run.toolCalls++;
+            }
+            const params = msg.params;
+            if (msg.method === "item/commandExecution/started" && params) {
+              const tool = (params.tool || params.name || "").toLowerCase();
+              if (tool.includes("edit") || tool.includes("write")) {
+                run.filesModified++;
+              }
+            }
+            if (msg.method === "item/text" && params?.text) {
+              run.tokensUsed += Math.ceil(params.text.length / 4);
+            }
+            if (run.toolCalls % 5 === 0 || phase) {
+              this.writeAgentStatus(issue.identifier, run);
+            }
             if (msg.method === "turn/completed") {
               turnCompleted = true;
+              this.writeAgentStatus(issue.identifier, run);
             }
             if (msg.method === "turn/failed") {
               turnCompleted = true;
+              this.writeAgentStatus(issue.identifier, run);
               const errMsg = msg.params?.error?.message || "Agent turn failed";
               clearTimeout(timer);
               reject(new Error(errMsg));
@@ -562,6 +924,10 @@ class Conductor {
       proc.on("close", (code) => {
         clearTimeout(timer);
         run.process = null;
+        if (run.logStream && !run.logStream.destroyed) {
+          run.logStream.end();
+        }
+        this.writeAgentStatus(issue.identifier, run);
         if (turnCompleted) {
           resolve();
         } else if (code === 0) {
@@ -800,5 +1166,6 @@ class Conductor {
   }
 }
 export {
-  Conductor
+  Conductor,
+  getAgentStatusDir
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.5.2",
-  "description": "Project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, Claude/Codex/OpenCode wrappers, Linear sync, automatic hooks, and log analysis.",
+  "version": "1.5.4",
+  "description": "Lossless, project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, conductor orchestrator, loop/watch monitoring, snapshot capture, pre-flight overlap checks, Claude/Codex/OpenCode wrappers, Linear sync, and automatic hooks.",
   "engines": {
     "node": ">=20.0.0",
     "npm": ">=10.0.0"