@stackmemoryai/stackmemory 1.3.0 → 1.3.2

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

@@ -0,0 +1,676 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+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 { join } from "path";
+import { tmpdir } from "os";
+import { logger } from "../../core/monitoring/logger.js";
+import {
+  LinearClient
+} from "../../integrations/linear/client.js";
+import { LinearAuthManager } from "../../integrations/linear/auth.js";
+const DEFAULT_CONFIG = {
+  activeStates: ["Todo"],
+  terminalStates: ["Done", "Cancelled", "Canceled", "Closed"],
+  inProgressState: "In Progress",
+  inReviewState: "In Review",
+  pollIntervalMs: 3e4,
+  maxConcurrent: 3,
+  workspaceRoot: join(tmpdir(), "symphony_workspaces"),
+  repoRoot: process.cwd(),
+  baseBranch: "main",
+  appServerPath: join(
+    __dirname,
+    "..",
+    "..",
+    "..",
+    "scripts",
+    "symphony",
+    "claude-app-server.cjs"
+  ),
+  turnTimeoutMs: 36e5,
+  maxRetries: 1,
+  hookTimeoutMs: 6e4
+};
+class SymphonyOrchestrator {
+  config;
+  client = null;
+  running = /* @__PURE__ */ new Map();
+  claimed = /* @__PURE__ */ new Set();
+  completed = /* @__PURE__ */ new Set();
+  pollTimer = null;
+  startedAt = 0;
+  totalAttempts = 0;
+  failCount = 0;
+  completeCount = 0;
+  stopping = false;
+  stateCache = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Start the orchestrator loop.
+   * Resolves when stopped via stop() or SIGINT/SIGTERM.
+   */
+  async start() {
+    this.startedAt = Date.now();
+    this.stopping = false;
+    if (!existsSync(this.config.appServerPath)) {
+      const altPath = join(
+        this.config.repoRoot,
+        "scripts",
+        "symphony",
+        "claude-app-server.cjs"
+      );
+      if (existsSync(altPath)) {
+        this.config.appServerPath = altPath;
+      } else {
+        throw new Error(
+          `claude-app-server.cjs not found at ${this.config.appServerPath}`
+        );
+      }
+    }
+    if (!existsSync(this.config.workspaceRoot)) {
+      mkdirSync(this.config.workspaceRoot, { recursive: true });
+    }
+    this.client = await this.createLinearClient();
+    await this.cacheWorkflowStates();
+    logger.info("Symphony orchestrator started", {
+      activeStates: this.config.activeStates,
+      maxConcurrent: this.config.maxConcurrent,
+      pollIntervalMs: this.config.pollIntervalMs,
+      workspaceRoot: this.config.workspaceRoot
+    });
+    console.log(
+      `Symphony started \u2014 polling every ${this.config.pollIntervalMs / 1e3}s, max ${this.config.maxConcurrent} concurrent`
+    );
+    const shutdown = () => this.stop();
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    try {
+      await this.poll();
+    } catch (err) {
+      logger.error("Initial poll failed", { error: err.message });
+    }
+    await this.schedulePoll();
+  }
+  /**
+   * Gracefully stop the orchestrator.
+   * Waits for running agents to finish (up to 30s), then force-kills.
+   */
+  async stop() {
+    if (this.stopping) return;
+    this.stopping = true;
+    console.log("\nSymphony stopping...");
+    logger.info("Symphony orchestrator stopping", {
+      runningCount: this.running.size
+    });
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    for (const [issueId, run] of this.running) {
+      if (run.process && !run.process.killed) {
+        logger.info("Killing agent process", {
+          issueId,
+          identifier: run.issue.identifier
+        });
+        run.process.kill("SIGTERM");
+      }
+    }
+    const deadline = Date.now() + 1e4;
+    while (this.running.size > 0 && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    for (const [_issueId, run] of this.running) {
+      if (run.process && !run.process.killed) {
+        run.process.kill("SIGKILL");
+      }
+    }
+    this.running.clear();
+    this.claimed.clear();
+    console.log(
+      `Symphony stopped. Completed: ${this.completeCount}, Failed: ${this.failCount}`
+    );
+  }
+  /**
+   * Get current orchestrator stats.
+   */
+  getStats() {
+    const issues = Array.from(this.running.values()).map((r) => ({
+      identifier: r.issue.identifier,
+      status: r.status,
+      attempt: r.attempt,
+      runtime: Date.now() - r.startedAt
+    }));
+    return {
+      running: this.running.size,
+      completed: this.completeCount,
+      failed: this.failCount,
+      totalAttempts: this.totalAttempts,
+      uptime: Date.now() - this.startedAt,
+      issues
+    };
+  }
+  // ── Polling ──
+  async schedulePoll() {
+    while (!this.stopping) {
+      await new Promise((resolve) => {
+        this.pollTimer = setTimeout(resolve, this.config.pollIntervalMs);
+      });
+      if (this.stopping) break;
+      try {
+        await this.poll();
+      } catch (err) {
+        logger.error("Poll cycle failed", { error: err.message });
+      }
+    }
+  }
+  async poll() {
+    if (!this.client || this.stopping) return;
+    await this.reconcile();
+    const available = this.config.maxConcurrent - this.running.size;
+    if (available <= 0) {
+      logger.debug("At capacity, skipping dispatch", {
+        running: this.running.size,
+        max: this.config.maxConcurrent
+      });
+      return;
+    }
+    const candidates = await this.fetchCandidates();
+    if (candidates.length === 0) return;
+    const eligible = candidates.filter(
+      (issue) => !this.claimed.has(issue.id) && !this.completed.has(issue.id)
+    );
+    if (eligible.length === 0) return;
+    const toDispatch = eligible.sort((a, b) => (a.priority || 4) - (b.priority || 4)).slice(0, available);
+    logger.info("Dispatching issues", {
+      count: toDispatch.length,
+      identifiers: toDispatch.map((i) => i.identifier)
+    });
+    for (const issue of toDispatch) {
+      this.dispatch(issue).catch((err) => {
+        logger.error("Dispatch failed", {
+          identifier: issue.identifier,
+          error: err.message
+        });
+      });
+    }
+  }
+  async fetchCandidates() {
+    if (!this.client) return [];
+    const allCandidates = [];
+    const issues = await this.client.getIssues({
+      teamId: this.config.teamId,
+      limit: 50
+    });
+    const activeStatesLower = this.config.activeStates.map(
+      (s) => s.trim().toLowerCase()
+    );
+    for (const issue of issues) {
+      const stateName = issue.state.name.trim().toLowerCase();
+      if (activeStatesLower.includes(stateName)) {
+        allCandidates.push(issue);
+      }
+    }
+    return allCandidates;
+  }
+  // ── Dispatch ──
+  async dispatch(issue) {
+    const issueId = issue.id;
+    this.claimed.add(issueId);
+    const run = {
+      issue,
+      workspacePath: "",
+      process: null,
+      attempt: 1,
+      startedAt: Date.now(),
+      status: "starting"
+    };
+    this.running.set(issueId, run);
+    this.totalAttempts++;
+    console.log(`[${issue.identifier}] Dispatching: ${issue.title}`);
+    try {
+      const workspacePath = await this.createWorkspace(issue);
+      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);
+      await this.transitionIssue(issue, this.config.inReviewState);
+      console.log(`[${issue.identifier}] Completed successfully`);
+    } 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) {
+        await this.runHook(
+          "after-run",
+          run.workspacePath,
+          issue,
+          run.attempt
+        ).catch(() => {
+        });
+      }
+      if (run.attempt < this.config.maxRetries + 1) {
+        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));
+        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}`
+            );
+          }
+        }
+      } else {
+        this.failCount++;
+        console.log(`[${issue.identifier}] Failed: ${run.error}`);
+      }
+    } finally {
+      this.running.delete(issueId);
+    }
+  }
+  // ── Workspace Management ──
+  async createWorkspace(issue) {
+    const wsKey = this.sanitizeIdentifier(issue.identifier);
+    const wsPath = join(this.config.workspaceRoot, wsKey);
+    if (existsSync(wsPath)) {
+      logger.info("Reusing existing workspace", {
+        identifier: issue.identifier,
+        path: wsPath
+      });
+      return wsPath;
+    }
+    const branchName = `symphony/${wsKey}`;
+    try {
+      execSync("git fetch origin", {
+        cwd: this.config.repoRoot,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+      execSync(
+        `git worktree add "${wsPath}" -b "${branchName}" "origin/${this.config.baseBranch}"`,
+        {
+          cwd: this.config.repoRoot,
+          stdio: "pipe",
+          timeout: 3e4
+        }
+      );
+      logger.info("Created workspace", {
+        identifier: issue.identifier,
+        path: wsPath,
+        branch: branchName
+      });
+    } catch (err) {
+      try {
+        execSync(`git worktree add "${wsPath}" "${branchName}"`, {
+          cwd: this.config.repoRoot,
+          stdio: "pipe",
+          timeout: 3e4
+        });
+      } catch {
+        throw new Error(
+          `Failed to create workspace for ${issue.identifier}: ${err.message}`
+        );
+      }
+    }
+    return wsPath;
+  }
+  async removeWorkspace(issue) {
+    const wsKey = this.sanitizeIdentifier(issue.identifier);
+    const wsPath = join(this.config.workspaceRoot, wsKey);
+    if (!existsSync(wsPath)) return;
+    await this.runHook("before-remove", wsPath, issue).catch(() => {
+    });
+    try {
+      execSync(`git worktree remove "${wsPath}" --force`, {
+        cwd: this.config.repoRoot,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+    } catch {
+      try {
+        rmSync(wsPath, { recursive: true, force: true });
+        execSync("git worktree prune", {
+          cwd: this.config.repoRoot,
+          stdio: "pipe",
+          timeout: 1e4
+        });
+      } catch {
+        logger.warn("Failed to clean workspace", {
+          identifier: issue.identifier,
+          path: wsPath
+        });
+      }
+    }
+  }
+  sanitizeIdentifier(identifier) {
+    return identifier.replace(/[^A-Za-z0-9._-]/g, "_");
+  }
+  // ── Agent Execution ──
+  runAgent(issue, run) {
+    return new Promise((resolve, reject) => {
+      const prompt = this.buildPrompt(issue, run.attempt);
+      const proc = spawn("node", [this.config.appServerPath], {
+        cwd: run.workspacePath,
+        env: {
+          ...process.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;
+      let stderr = "";
+      let turnCompleted = false;
+      let timer;
+      timer = setTimeout(() => {
+        if (!turnCompleted) {
+          logger.warn("Agent turn timeout", {
+            identifier: issue.identifier,
+            timeoutMs: this.config.turnTimeoutMs
+          });
+          proc.kill("SIGTERM");
+          reject(
+            new Error(`Agent timeout after ${this.config.turnTimeoutMs}ms`)
+          );
+        }
+      }, this.config.turnTimeoutMs);
+      const send = (msg) => {
+        proc.stdin.write(JSON.stringify(msg) + "\n");
+      };
+      let lineBuffer = "";
+      proc.stdout.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 msg = JSON.parse(line);
+            this.handleAgentMessage(msg, issue, run);
+            if (msg.method === "turn/completed") {
+              turnCompleted = true;
+            }
+            if (msg.method === "turn/failed") {
+              turnCompleted = true;
+              const errMsg = msg.params?.error?.message || "Agent turn failed";
+              clearTimeout(timer);
+              reject(new Error(errMsg));
+              return;
+            }
+          } 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 agent: ${err.message}`));
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        run.process = null;
+        if (turnCompleted) {
+          resolve();
+        } else if (code === 0) {
+          resolve();
+        } else {
+          reject(
+            new Error(`Agent exited with code ${code}: ${stderr.slice(0, 500)}`)
+          );
+        }
+      });
+      send({ jsonrpc: "2.0", id: 1, method: "initialize", params: {} });
+      setTimeout(() => {
+        send({
+          jsonrpc: "2.0",
+          id: 2,
+          method: "thread/start",
+          params: { cwd: run.workspacePath }
+        });
+        setTimeout(() => {
+          send({
+            jsonrpc: "2.0",
+            id: 3,
+            method: "turn/start",
+            params: {
+              cwd: run.workspacePath,
+              input: [{ type: "text", text: prompt }]
+            }
+          });
+        }, 100);
+      }, 100);
+    });
+  }
+  handleAgentMessage(msg, issue, _run) {
+    if (msg.method === "item/commandExecution/started") {
+      logger.debug("Agent tool use", {
+        identifier: issue.identifier,
+        tool: msg.params?.tool
+      });
+    }
+    if (msg.method === "turn/completed") {
+      const output = msg.params?.result?.output;
+      if (Array.isArray(output)) {
+        const text = output.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        if (text) {
+          logger.info("Agent completed", {
+            identifier: issue.identifier,
+            outputLength: text.length
+          });
+        }
+      }
+    }
+  }
+  buildPrompt(issue, attempt) {
+    const lines = [
+      `You are working on Linear issue ${issue.identifier}: ${issue.title}`,
+      ""
+    ];
+    if (issue.description) {
+      lines.push("## Description", "", issue.description, "");
+    }
+    if (issue.labels.length > 0) {
+      lines.push(`Labels: ${issue.labels.map((l) => l.name).join(", ")}`);
+    }
+    lines.push(
+      `Priority: ${["None", "Urgent", "High", "Medium", "Low"][issue.priority] || "None"}`
+    );
+    if (attempt > 1) {
+      lines.push(
+        "",
+        `This is attempt ${attempt}. Check .stackmemory/symphony-context.md for context from prior attempts.`
+      );
+    }
+    lines.push(
+      "",
+      "## Instructions",
+      "",
+      "1. Read the issue description carefully",
+      "2. Implement the requested changes",
+      "3. Write or update tests as needed",
+      "4. Run lint and tests to verify",
+      "5. Commit your changes with a descriptive message",
+      "",
+      "Work in the current directory. All changes will be on a dedicated branch."
+    );
+    return lines.join("\n");
+  }
+  // ── Hooks ──
+  async runHook(hookName, workspacePath, issue, attempt) {
+    const hookPath = join(
+      this.config.repoRoot,
+      "scripts",
+      "symphony",
+      `${hookName}.sh`
+    );
+    if (!existsSync(hookPath)) {
+      logger.debug("Hook not found, skipping", { hookName, hookPath });
+      return;
+    }
+    logger.debug("Running hook", { hookName, identifier: issue.identifier });
+    try {
+      execSync(`bash "${hookPath}"`, {
+        cwd: workspacePath,
+        timeout: this.config.hookTimeoutMs,
+        stdio: "pipe",
+        env: {
+          ...process.env,
+          SYMPHONY_WORKSPACE_DIR: workspacePath,
+          SYMPHONY_ISSUE_ID: issue.id,
+          SYMPHONY_ISSUE_IDENTIFIER: issue.identifier,
+          SYMPHONY_ATTEMPT: String(attempt || 1)
+        }
+      });
+    } catch (err) {
+      logger.warn("Hook failed", {
+        hookName,
+        identifier: issue.identifier,
+        error: err.message
+      });
+      if (hookName === "after-create") {
+        throw new Error(`Hook ${hookName} failed: ${err.message}`);
+      }
+    }
+  }
+  // ── State Transitions ──
+  async cacheWorkflowStates() {
+    if (!this.client || !this.config.teamId) return;
+    try {
+      const states = await this.client.getWorkflowStates(this.config.teamId);
+      for (const state of states) {
+        this.stateCache.set(state.name.trim().toLowerCase(), {
+          id: state.id,
+          name: state.name
+        });
+      }
+      logger.debug("Cached workflow states", { count: this.stateCache.size });
+    } catch (err) {
+      logger.warn("Failed to cache workflow states", {
+        error: err.message
+      });
+    }
+  }
+  async transitionIssue(issue, targetStateName) {
+    if (!this.client) return;
+    const stateKey = targetStateName.trim().toLowerCase();
+    const state = this.stateCache.get(stateKey);
+    if (!state) {
+      logger.warn("Target state not found in cache", {
+        targetState: targetStateName,
+        available: Array.from(this.stateCache.keys())
+      });
+      return;
+    }
+    try {
+      await this.client.updateIssueState(issue.id, state.id);
+      logger.info("Transitioned issue", {
+        identifier: issue.identifier,
+        from: issue.state.name,
+        to: state.name
+      });
+    } catch (err) {
+      logger.warn("Failed to transition issue", {
+        identifier: issue.identifier,
+        targetState: state.name,
+        error: err.message
+      });
+    }
+  }
+  // ── Reconciliation ──
+  async reconcile() {
+    if (!this.client || this.running.size === 0) return;
+    const terminalLower = this.config.terminalStates.map(
+      (s) => s.trim().toLowerCase()
+    );
+    for (const [issueId, run] of this.running) {
+      try {
+        const issues = await this.client.getIssues({ limit: 1 });
+        const fresh = issues.find((i) => i.id === issueId);
+        if (!fresh) continue;
+        const currentState = fresh.state.name.trim().toLowerCase();
+        if (terminalLower.includes(currentState)) {
+          logger.info(
+            "Issue moved to terminal state externally, stopping agent",
+            {
+              identifier: run.issue.identifier,
+              state: fresh.state.name
+            }
+          );
+          if (run.process && !run.process.killed) {
+            run.process.kill("SIGTERM");
+          }
+          await this.removeWorkspace(run.issue);
+          this.running.delete(issueId);
+          this.completed.add(issueId);
+        }
+      } catch (err) {
+        logger.debug("Reconciliation check failed for issue", {
+          issueId,
+          error: err.message
+        });
+      }
+    }
+  }
+  // ── Linear Client ──
+  async createLinearClient() {
+    try {
+      const authManager = new LinearAuthManager(this.config.repoRoot);
+      const token = await authManager.getValidToken();
+      return new LinearClient({ apiKey: token, useBearer: true });
+    } catch {
+      const apiKey = process.env.LINEAR_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "Linear authentication required. Run `stackmemory linear setup` or set LINEAR_API_KEY."
+        );
+      }
+      return new LinearClient({ apiKey });
+    }
+  }
+}
+export {
+  SymphonyOrchestrator
+};