@stackmemoryai/stackmemory 1.2.9 → 1.3.0

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

@@ -0,0 +1,267 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import Database from "better-sqlite3";
+import { logger } from "../../core/monitoring/logger.js";
+function getGlobalStorePath() {
+  const dir = join(homedir(), ".stackmemory", "symphony");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getGlobalDb() {
+  const dbPath = join(getGlobalStorePath(), "context.db");
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS symphony_contexts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      issue_id TEXT NOT NULL,
+      attempt INTEGER NOT NULL DEFAULT 1,
+      workspace TEXT,
+      captured_at INTEGER NOT NULL,
+      context_type TEXT NOT NULL DEFAULT 'run',
+      summary TEXT,
+      frames_json TEXT,
+      anchors_json TEXT,
+      events_json TEXT,
+      metadata_json TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_symphony_issue
+      ON symphony_contexts(issue_id);
+    CREATE INDEX IF NOT EXISTS idx_symphony_captured
+      ON symphony_contexts(captured_at);
+  `);
+  return db;
+}
+function createSymphonyCommands() {
+  const cmd = new Command("symphony");
+  cmd.description("Symphony orchestrator integration commands");
+  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;
+    const attempt = parseInt(options.attempt, 10);
+    const dbPath = join(workspace, ".stackmemory", "context.db");
+    let summary = "";
+    let framesJson = "[]";
+    let anchorsJson = "[]";
+    let eventsJson = "[]";
+    if (existsSync(dbPath)) {
+      try {
+        const db = new Database(dbPath, { readonly: true });
+        const frames = db.prepare(
+          "SELECT frame_id, name, type, digest_text, created_at FROM frames ORDER BY created_at DESC LIMIT 20"
+        ).all();
+        framesJson = JSON.stringify(frames);
+        const anchors = db.prepare(
+          "SELECT anchor_id, type, text, priority FROM anchors WHERE type IN ('DECISION', 'FACT', 'CONSTRAINT', 'RISK') ORDER BY priority DESC LIMIT 30"
+        ).all();
+        anchorsJson = JSON.stringify(anchors);
+        const events = db.prepare(
+          "SELECT event_type, payload, ts FROM events ORDER BY ts DESC LIMIT 50"
+        ).all();
+        eventsJson = JSON.stringify(events);
+        const digests = frames.filter((f) => f.digest_text).map((f) => f.digest_text).slice(0, 5);
+        summary = digests.join("\n");
+        db.close();
+      } catch (err) {
+        logger.warn("Failed to read workspace database", {
+          error: err.message
+        });
+      }
+    }
+    let metadata = { workspace, attempt };
+    try {
+      const { execSync } = await import("child_process");
+      const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: workspace,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      }).trim();
+      const lastCommit = execSync("git log -1 --oneline", {
+        cwd: workspace,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      }).trim();
+      metadata = { ...metadata, branch, lastCommit };
+    } catch {
+    }
+    const globalDb = getGlobalDb();
+    globalDb.prepare(
+      `INSERT INTO symphony_contexts
+           (issue_id, attempt, workspace, captured_at, context_type, summary, frames_json, anchors_json, events_json, metadata_json)
+           VALUES (?, ?, ?, ?, 'run', ?, ?, ?, ?, ?)`
+    ).run(
+      issueId,
+      attempt,
+      workspace,
+      Math.floor(Date.now() / 1e3),
+      summary,
+      framesJson,
+      anchorsJson,
+      eventsJson,
+      JSON.stringify(metadata)
+    );
+    globalDb.close();
+    const frameCount = JSON.parse(framesJson).length;
+    const anchorCount = JSON.parse(anchorsJson).length;
+    console.log(
+      `Captured ${frameCount} frames, ${anchorCount} anchors for ${issueId} (attempt ${attempt})`
+    );
+  });
+  cmd.command("restore").description("Restore context from prior runs into workspace").requiredOption("--issue <id>", "Issue identifier (e.g., STA-476)").option("--workspace <path>", "Workspace directory", process.cwd()).option("--related", "Also include context from related issues", false).action(async (options) => {
+    const workspace = options.workspace;
+    const issueId = options.issue;
+    const globalDbPath = join(getGlobalStorePath(), "context.db");
+    if (!existsSync(globalDbPath)) {
+      console.log("No prior Symphony context found");
+      return;
+    }
+    const globalDb = getGlobalDb();
+    const contexts = globalDb.prepare(
+      `SELECT issue_id, attempt, summary, anchors_json, metadata_json, captured_at
+           FROM symphony_contexts
+           WHERE issue_id = ?
+           ORDER BY captured_at DESC
+           LIMIT 10`
+    ).all(issueId);
+    if (contexts.length === 0 && !options.related) {
+      console.log(`No prior context for ${issueId}`);
+      globalDb.close();
+      return;
+    }
+    const lines = [
+      `# Prior Context for ${issueId}`,
+      "",
+      `Found ${contexts.length} prior run(s).`,
+      ""
+    ];
+    for (const ctx of contexts) {
+      const date = new Date(ctx.captured_at * 1e3).toISOString();
+      lines.push(`## Attempt ${ctx.attempt} (${date})`);
+      if (ctx.summary) {
+        lines.push("", ctx.summary);
+      }
+      try {
+        const anchors = JSON.parse(ctx.anchors_json || "[]");
+        const decisions = anchors.filter((a) => a.type === "DECISION");
+        const risks = anchors.filter((a) => a.type === "RISK");
+        if (decisions.length > 0) {
+          lines.push("", "### Decisions");
+          for (const d of decisions.slice(0, 10)) {
+            lines.push(`- ${d.text}`);
+          }
+        }
+        if (risks.length > 0) {
+          lines.push("", "### Risks");
+          for (const r of risks.slice(0, 5)) {
+            lines.push(`- ${r.text}`);
+          }
+        }
+      } catch {
+      }
+      try {
+        const meta = JSON.parse(ctx.metadata_json || "{}");
+        if (meta.branch || meta.lastCommit) {
+          lines.push("", "### Git State");
+          if (meta.branch) lines.push(`- Branch: ${meta.branch}`);
+          if (meta.lastCommit)
+            lines.push(`- Last commit: ${meta.lastCommit}`);
+        }
+      } catch {
+      }
+      lines.push("");
+    }
+    const restoreDir = join(workspace, ".stackmemory");
+    if (!existsSync(restoreDir)) {
+      mkdirSync(restoreDir, { recursive: true });
+    }
+    const restorePath = join(restoreDir, "symphony-context.md");
+    writeFileSync(restorePath, lines.join("\n"));
+    globalDb.close();
+    console.log(
+      `Restored ${contexts.length} prior run(s) for ${issueId} \u2192 ${restorePath}`
+    );
+  });
+  cmd.command("archive").description("Archive workspace context before removal").requiredOption("--issue <id>", "Issue identifier (e.g., STA-476)").option("--workspace <path>", "Workspace directory", process.cwd()).action(async (options) => {
+    const workspace = options.workspace;
+    const issueId = options.issue;
+    const dbPath = join(workspace, ".stackmemory", "context.db");
+    if (!existsSync(dbPath)) {
+      console.log(`No context to archive for ${issueId}`);
+      return;
+    }
+    const db = new Database(dbPath, { readonly: true });
+    const frames = db.prepare("SELECT * FROM frames ORDER BY created_at DESC").all();
+    const anchors = db.prepare("SELECT * FROM anchors").all();
+    const events = db.prepare("SELECT * FROM events ORDER BY ts DESC LIMIT 100").all();
+    const digests = frames.filter((f) => f.digest_text).map((f) => f.digest_text).slice(0, 10);
+    db.close();
+    const globalDb = getGlobalDb();
+    globalDb.prepare(
+      `INSERT INTO symphony_contexts
+           (issue_id, attempt, workspace, captured_at, context_type, summary, frames_json, anchors_json, events_json, metadata_json)
+           VALUES (?, 0, ?, ?, 'archive', ?, ?, ?, ?, ?)`
+    ).run(
+      issueId,
+      workspace,
+      Math.floor(Date.now() / 1e3),
+      digests.join("\n"),
+      JSON.stringify(frames),
+      JSON.stringify(anchors),
+      JSON.stringify(events),
+      JSON.stringify({ archived: true, workspace })
+    );
+    globalDb.close();
+    console.log(
+      `Archived ${frames.length} frames, ${anchors.length} anchors for ${issueId}`
+    );
+  });
+  cmd.command("search").description("Search across all Symphony issue contexts").argument("<query>", "Search query").option("--limit <n>", "Max results", "10").action(async (query, options) => {
+    const globalDbPath = join(getGlobalStorePath(), "context.db");
+    if (!existsSync(globalDbPath)) {
+      console.log("No Symphony context database found");
+      return;
+    }
+    const limit = parseInt(options.limit, 10);
+    const globalDb = getGlobalDb();
+    const results = globalDb.prepare(
+      `SELECT issue_id, attempt, context_type, summary, anchors_json, captured_at
+           FROM symphony_contexts
+           WHERE summary LIKE ? OR anchors_json LIKE ?
+           ORDER BY captured_at DESC
+           LIMIT ?`
+    ).all(`%${query}%`, `%${query}%`, limit);
+    if (results.length === 0) {
+      console.log(`No results for "${query}"`);
+      globalDb.close();
+      return;
+    }
+    console.log(`Found ${results.length} result(s) for "${query}":
+`);
+    for (const r of results) {
+      const date = new Date(r.captured_at * 1e3).toISOString().slice(0, 16);
+      console.log(
+        `  ${r.issue_id} [${r.context_type}] attempt ${r.attempt} (${date})`
+      );
+      if (r.summary) {
+        const snippet = r.summary.slice(0, 120).replace(/\n/g, " ");
+        console.log(`    ${snippet}`);
+      }
+    }
+    globalDb.close();
+  });
+  return cmd;
+}
+export {
+  createSymphonyCommands
+};

package/dist/src/cli/index.js

@@ -57,6 +57,7 @@ import { createBenchCommand } from "./commands/bench.js";
 import { createDigestCommands } from "./commands/digest.js";
 import { createTeamCommands } from "./commands/team.js";
 import { createDesiresCommands } from "./commands/desires.js";
+import { createSymphonyCommands } from "./commands/symphony.js";
 import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
@@ -507,6 +508,7 @@ program.addCommand(createBenchCommand());
 program.addCommand(createDigestCommands());
 program.addCommand(createTeamCommands());
 program.addCommand(createDesiresCommands());
+program.addCommand(createSymphonyCommands());
 registerSetupCommands(program);
 program.command("mm-spike").description(
   "Run multi-agent planning/implementation spike (planner/implementer/critic)"

package/dist/src/core/context/frame-handoff-manager.js

@@ -12,6 +12,7 @@ import {
 class FrameHandoffManager {
   dualStackManager;
   activeHandoffs = /* @__PURE__ */ new Map();
+  handoffMetadata = /* @__PURE__ */ new Map();
   pendingApprovals = /* @__PURE__ */ new Map();
   notifications = /* @__PURE__ */ new Map();
   constructor(dualStackManager) {
@@ -53,6 +54,7 @@ class FrameHandoffManager {
         errors: []
       };
       this.activeHandoffs.set(requestId, progress);
+      this.handoffMetadata.set(requestId, metadata);
       await this.createHandoffNotifications(requestId, metadata, targetUserId);
       await this.scheduleHandoffReminders(requestId, metadata);
       logger.info(`Initiated enhanced handoff: ${requestId}`, {
@@ -372,12 +374,13 @@ class FrameHandoffManager {
   async notifyChangesRequested(requestId, approval) {
     const progress = this.activeHandoffs.get(requestId);
     if (!progress) return;
+    const metadata = this.handoffMetadata.get(requestId);
+    const requesterId = metadata?.initiatorId || "unknown";
     const changeRequestNotification = {
       id: `${requestId}-changes-${Date.now()}`,
       type: "request",
       requestId,
-      recipientId: "requester",
-      // TODO: Get actual requester from handoff metadata
+      recipientId: requesterId,
       title: "Changes Requested for Handoff",
       message: `${approval.reviewerId} has requested changes: ${approval.feedback || "See detailed suggestions"}`,
       actionRequired: true,
@@ -385,9 +388,9 @@ class FrameHandoffManager {
       // 48 hours
       createdAt: /* @__PURE__ */ new Date()
     };
-    const notifications = this.notifications.get("requester") || [];
+    const notifications = this.notifications.get(requesterId) || [];
     notifications.push(changeRequestNotification);
-    this.notifications.set("requester", notifications);
+    this.notifications.set(requesterId, notifications);
     logger.info(`Changes requested for handoff: ${requestId}`, {
       reviewer: approval.reviewerId,
       feedback: approval.feedback,

package/dist/src/core/database/database-adapter.js

@@ -9,6 +9,13 @@ class DatabaseAdapter {
     this.projectId = projectId;
     this.config = config || {};
   }
+  // Paginated table reads (for migration)
+  async getTablePage(table, offset, limit) {
+    void table;
+    void offset;
+    void limit;
+    return [];
+  }
   /** Returns the configured embedding provider, if any */
   getEmbeddingProvider() {
     return void 0;

package/dist/src/core/database/migration-manager.js

@@ -307,25 +307,12 @@ class MigrationManager extends EventEmitter {
     }
     const safeLimit = Math.max(1, Math.min(limit, 1e4));
     const safeOffset = Math.max(0, offset);
-    void safeLimit;
-    void safeOffset;
-    switch (table) {
-      case "frames":
-        return [];
-      // Placeholder
-      case "events":
-        return [];
-      // Placeholder
-      case "anchors":
-        return [];
-      // Placeholder
-      default:
-        throw new DatabaseError(
-          `Unsupported table: ${table}`,
-          ErrorCode.DB_QUERY_FAILED,
-          { table }
-        );
-    }
+    const validTable = table;
+    return this.config.sourceAdapter.getTablePage(
+      validTable,
+      safeOffset,
+      safeLimit
+    );
   }
   async migrateBatch(table, batch) {
     const allowedTables = ["frames", "events", "anchors"];

package/dist/src/core/database/sqlite-adapter.js

@@ -1222,6 +1222,24 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
       }
     });
   }
+  async getTablePage(table, offset, limit) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const safeLimit = Math.max(1, Math.min(limit, 1e4));
+    const safeOffset = Math.max(0, offset);
+    const allowedTables = ["frames", "events", "anchors"];
+    if (!allowedTables.includes(table)) {
+      throw new DatabaseError(
+        `Invalid table name: ${table}`,
+        ErrorCode.DB_QUERY_FAILED,
+        { table }
+      );
+    }
+    return this.db.prepare(`SELECT * FROM ${table} ORDER BY rowid LIMIT ? OFFSET ?`).all(safeLimit, safeOffset);
+  }
   async vacuum() {
     if (!this.db)
       throw new DatabaseError(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.2.9",
+  "version": "1.3.0",
   "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.",
   "engines": {
     "node": ">=20.0.0",