@stackmemoryai/stackmemory 1.3.1 → 1.4.0

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

@@ -0,0 +1,87 @@
+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 chalk from "chalk";
+import {
+  PreflightChecker
+} from "../../core/worktree/preflight.js";
+function createPreflightCommand() {
+  const cmd = new Command("preflight").alias("pf").description("Check file overlap before running parallel tasks").argument("<tasks...>", "Task descriptions (quoted strings)").option(
+    "-k, --keywords <keywords>",
+    "Comma-separated keywords per task (task1:kw1,kw2;task2:kw3)"
+  ).option(
+    "-f, --files <files>",
+    "Comma-separated files per task (task1:file1,file2;task2:file3)"
+  ).option("--json", "Output as JSON").action((taskArgs, options) => {
+    const checker = new PreflightChecker();
+    const tasks = taskArgs.map((desc, i) => {
+      const task = {
+        name: `task-${i + 1}`,
+        description: desc
+      };
+      if (options.keywords) {
+        const kwParts = options.keywords.split(";");
+        if (kwParts[i]) {
+          const [, kws] = kwParts[i].split(":");
+          if (kws) task.keywords = kws.split(",");
+        }
+      }
+      if (options.files) {
+        const fileParts = options.files.split(";");
+        if (fileParts[i]) {
+          const [, fs] = fileParts[i].split(":");
+          if (fs) task.files = fs.split(",");
+        }
+      }
+      if (desc.length <= 40) {
+        task.name = desc;
+      }
+      return task;
+    });
+    const result = checker.check(tasks);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(chalk.cyan("\nPre-flight Check\n"));
+    console.log(chalk.gray(`Tasks: ${tasks.length}`));
+    console.log(chalk.gray(`Overlaps: ${result.allOverlaps.length}
+`));
+    if (result.parallelSafe.length === 1 && result.allOverlaps.length === 0) {
+      console.log(chalk.green("All tasks are parallel-safe.\n"));
+      for (const task of result.parallelSafe[0]) {
+        console.log(chalk.green(`  + ${task.name}`));
+      }
+    } else {
+      for (let i = 0; i < result.parallelSafe.length; i++) {
+        const group = result.parallelSafe[i];
+        console.log(chalk.cyan(`Group ${i + 1} (parallel-safe):`));
+        for (const task of group) {
+          console.log(chalk.green(`  + ${task.name}`));
+        }
+      }
+    }
+    if (result.sequential.length > 0) {
+      console.log(chalk.yellow("\nSequential (file overlaps detected):"));
+      for (const entry of result.sequential) {
+        console.log(
+          chalk.yellow(`  "${entry.task.name}" -> after "${entry.after}"`)
+        );
+        for (const overlap of entry.overlaps.slice(0, 5)) {
+          const conf = Math.round(overlap.confidence * 100);
+          console.log(
+            chalk.gray(`    ${overlap.file} (${overlap.source}, ${conf}%)`)
+          );
+        }
+      }
+    }
+    console.log(chalk.gray(`
+${result.summary}`));
+  });
+  return cmd;
+}
+export {
+  createPreflightCommand
+};

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

@@ -0,0 +1,89 @@
+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 chalk from "chalk";
+import { ContextCapture } from "../../core/worktree/capture.js";
+function createSnapshotCommand() {
+  const cmd = new Command("snapshot").alias("snap").description("Point-in-time snapshot of work (what changed and why)");
+  cmd.command("save").alias("s").description("Save a snapshot of current branch state").option("-t, --task <name>", "Task name or description").option(
+    "-b, --base <branch>",
+    "Base branch to diff against (default: auto-detect)"
+  ).option(
+    "-d, --decision <decisions...>",
+    "Key decisions made during this task"
+  ).option("--json", "Output as JSON").action((options) => {
+    const capture = new ContextCapture();
+    const result = capture.capture({
+      task: options.task,
+      baseBranch: options.base,
+      decisions: options.decision
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(chalk.green("\nSnapshot saved.\n"));
+    console.log(chalk.gray(`  Branch: ${result.branch}`));
+    console.log(chalk.gray(`  Base: ${result.baseBranch}`));
+    console.log(chalk.gray(`  Changed: ${result.filesChanged.length} files`));
+    console.log(chalk.gray(`  Created: ${result.filesCreated.length} files`));
+    console.log(chalk.gray(`  Deleted: ${result.filesDeleted.length} files`));
+    console.log(chalk.gray(`  Commits: ${result.commits.length}`));
+    if (result.decisions.length > 0) {
+      console.log(chalk.cyan("\n  Decisions:"));
+      result.decisions.forEach((d) => console.log(chalk.gray(`    - ${d}`)));
+    }
+    if (result.duration) {
+      console.log(chalk.gray(`  Duration: ${result.duration}`));
+    }
+    console.log(chalk.gray(`
+  Saved: ${result.id}`));
+  });
+  cmd.command("list").alias("ls").description("List recent snapshots").option("-n, --limit <n>", "Number of captures to show", "10").option("--json", "Output as JSON").action((options) => {
+    const capture = new ContextCapture();
+    const captures = capture.list(parseInt(options.limit));
+    if (captures.length === 0) {
+      console.log(chalk.yellow("No snapshots found."));
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(captures, null, 2));
+      return;
+    }
+    console.log(chalk.cyan(`
+Recent Snapshots (${captures.length}):
+`));
+    for (const cap of captures) {
+      const date = new Date(cap.timestamp).toLocaleDateString();
+      const files = cap.filesChanged.length + cap.filesCreated.length;
+      console.log(
+        chalk.gray(
+          `  ${date}  ${cap.branch.padEnd(30)}  ${files} files  ${cap.commits.length} commits`
+        )
+      );
+    }
+  });
+  cmd.command("show [branch]").description("Show snapshot details (latest or by branch)").option("--json", "Output as JSON").action((branch, options) => {
+    const capturer = new ContextCapture();
+    const result = capturer.getLatest(branch);
+    if (!result) {
+      console.log(
+        chalk.yellow(
+          branch ? `No snapshot found for branch: ${branch}` : "No snapshots found."
+        )
+      );
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(capturer.format(result));
+  });
+  return cmd;
+}
+export {
+  createSnapshotCommand
+};

package/dist/src/cli/index.js

@@ -57,7 +57,9 @@ 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 { createConductorCommands } from "./commands/orchestrate.js";
+import { createPreflightCommand } from "./commands/preflight.js";
+import { createSnapshotCommand } from "./commands/snapshot.js";
 import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
@@ -508,7 +510,9 @@ program.addCommand(createBenchCommand());
 program.addCommand(createDigestCommands());
 program.addCommand(createTeamCommands());
 program.addCommand(createDesiresCommands());
-program.addCommand(createSymphonyCommands());
+program.addCommand(createConductorCommands());
+program.addCommand(createPreflightCommand());
+program.addCommand(createSnapshotCommand());
 registerSetupCommands(program);
 program.command("mm-spike").description(
   "Run multi-agent planning/implementation spike (planner/implementer/critic)"

package/dist/src/core/retrieval/summary-generator.js

@@ -6,6 +6,7 @@ import {
   DEFAULT_RETRIEVAL_CONFIG
 } from "./types.js";
 import { logger } from "../monitoring/logger.js";
+import { extractKeywords as extractKeywordsShared } from "../utils/text.js";
 class CompressedSummaryGenerator {
   db;
   frameManager;
@@ -570,20 +571,7 @@ class CompressedSummaryGenerator {
     }
   }
   extractKeywords(text) {
-    const stopWords = /* @__PURE__ */ new Set([
-      "the",
-      "a",
-      "an",
-      "and",
-      "or",
-      "but",
-      "in",
-      "on",
-      "at",
-      "to",
-      "for"
-    ]);
-    return text.toLowerCase().split(/\W+/).filter((word) => word.length > 2 && !stopWords.has(word));
+    return extractKeywordsShared(text, { maxCount: 20 });
   }
   /**
    * Clear the cache

package/dist/src/core/utils/fs.js

@@ -0,0 +1,18 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+function pruneOldFiles(dir, ext, maxKeep) {
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(ext)).sort().reverse();
+    for (const old of files.slice(maxKeep)) {
+      unlinkSync(join(dir, old));
+    }
+  } catch {
+  }
+}
+export {
+  pruneOldFiles
+};

package/dist/src/core/utils/git.js

@@ -0,0 +1,91 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { execFileSync } from "child_process";
+function getCurrentBranch(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: cwd || process.cwd(),
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+function detectBaseBranch(cwd) {
+  const dir = cwd || process.cwd();
+  for (const base of ["main", "master", "develop"]) {
+    try {
+      execFileSync("git", ["rev-parse", "--verify", base], {
+        cwd: dir,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      return base;
+    } catch {
+      continue;
+    }
+  }
+  return "main";
+}
+function getDiffStats(baseBranch, cwd) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["diff", "--name-status", `${baseBranch}...HEAD`],
+      { cwd: cwd || process.cwd(), encoding: "utf-8", timeout: 1e4 }
+    );
+    const changed = [];
+    const created = [];
+    const deleted = [];
+    for (const line of output.split("\n").filter((l) => l.trim())) {
+      const [status, ...pathParts] = line.split("	");
+      const filePath = pathParts.join("	");
+      if (!filePath) continue;
+      switch (status.charAt(0)) {
+        case "A":
+          created.push(filePath);
+          break;
+        case "D":
+          deleted.push(filePath);
+          break;
+        case "M":
+        case "R":
+        case "C":
+          changed.push(filePath);
+          break;
+      }
+    }
+    return { changed, created, deleted };
+  } catch {
+    return { changed: [], created: [], deleted: [] };
+  }
+}
+function getCommitsSince(baseBranch, cwd) {
+  try {
+    const output = execFileSync(
+      "git",
+      [
+        "log",
+        `${baseBranch}..HEAD`,
+        "--pretty=format:%H%x00%s%x00%an%x00%aI",
+        "--no-merges"
+      ],
+      { cwd: cwd || process.cwd(), encoding: "utf-8", timeout: 1e4 }
+    );
+    return output.split("\n").filter((l) => l.trim()).map((line) => {
+      const [hash, message, author, date] = line.split("\0");
+      return { hash, message, author, date };
+    });
+  } catch {
+    return [];
+  }
+}
+export {
+  detectBaseBranch,
+  getCommitsSince,
+  getCurrentBranch,
+  getDiffStats
+};

package/dist/src/core/utils/text.js

@@ -0,0 +1,63 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const DEFAULT_STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "and",
+  "or",
+  "but",
+  "not",
+  "this",
+  "that",
+  "it",
+  "its",
+  "all",
+  "any",
+  "add",
+  "update",
+  "fix",
+  "change",
+  "make",
+  "create",
+  "new",
+  "use",
+  "get",
+  "set",
+  "has",
+  "have",
+  "had",
+  "will",
+  "would",
+  "should",
+  "could",
+  "can",
+  "may",
+  "might"
+]);
+function extractKeywords(text, opts) {
+  const minLength = opts?.minLength ?? 3;
+  const maxCount = opts?.maxCount ?? 5;
+  const stopWords = opts?.stopWords ?? DEFAULT_STOP_WORDS;
+  return text.toLowerCase().replace(/[^a-z0-9\s\-_]/g, " ").split(/\s+/).filter((w) => w.length >= minLength && !stopWords.has(w)).slice(0, maxCount);
+}
+export {
+  extractKeywords
+};

package/dist/src/core/worktree/capture.js

@@ -0,0 +1,178 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { formatDuration } from "../../utils/formatting.js";
+import { logger } from "../monitoring/logger.js";
+import {
+  getCurrentBranch,
+  detectBaseBranch,
+  getDiffStats,
+  getCommitsSince
+} from "../utils/git.js";
+import { pruneOldFiles } from "../utils/fs.js";
+const MAX_CAPTURES = 50;
+class ContextCapture {
+  repoPath;
+  capturesDir;
+  constructor(repoPath) {
+    this.repoPath = repoPath || process.cwd();
+    const localDir = join(this.repoPath, ".stackmemory", "captures");
+    const globalDir = join(homedir(), ".stackmemory", "captures");
+    this.capturesDir = existsSync(join(this.repoPath, ".stackmemory")) ? localDir : globalDir;
+    if (!existsSync(this.capturesDir)) {
+      mkdirSync(this.capturesDir, { recursive: true });
+    }
+  }
+  /**
+   * Capture current state after task completion.
+   * Compares current branch against base (default: main).
+   */
+  capture(options) {
+    const branch = getCurrentBranch(this.repoPath);
+    const baseBranch = options?.baseBranch || detectBaseBranch(this.repoPath);
+    const task = options?.task || branch;
+    const { changed, created, deleted } = getDiffStats(
+      baseBranch,
+      this.repoPath
+    );
+    const commits = getCommitsSince(baseBranch, this.repoPath);
+    const commitDecisions = this.extractDecisions(commits);
+    const decisions = [...options?.decisions || [], ...commitDecisions];
+    const duration = this.estimateDuration(commits);
+    const result = {
+      id: `${Date.now()}-${branch.replace(/[^a-zA-Z0-9]/g, "-")}`,
+      task,
+      branch,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      filesChanged: changed,
+      filesCreated: created,
+      filesDeleted: deleted,
+      commits,
+      decisions,
+      duration,
+      baseBranch
+    };
+    this.save(result);
+    logger.info("Context captured", {
+      task,
+      branch,
+      filesChanged: changed.length,
+      filesCreated: created.length,
+      commits: commits.length
+    });
+    return result;
+  }
+  /**
+   * List all captures, newest first.
+   */
+  list(limit = 20) {
+    if (!existsSync(this.capturesDir)) return [];
+    const files = readdirSync(this.capturesDir).filter((f) => f.endsWith(".json")).sort().reverse().slice(0, limit);
+    return files.map((f) => {
+      const content = readFileSync(join(this.capturesDir, f), "utf-8");
+      return JSON.parse(content);
+    });
+  }
+  /**
+   * Get the most recent capture for a branch.
+   */
+  getLatest(branch) {
+    const captures = this.list();
+    if (branch) {
+      return captures.find((c) => c.branch === branch);
+    }
+    return captures[0];
+  }
+  /**
+   * Format a capture as a human-readable summary for session restore.
+   */
+  format(capture) {
+    const lines = [];
+    lines.push(`# Capture: ${capture.task}`);
+    lines.push(`Branch: ${capture.branch} (base: ${capture.baseBranch})`);
+    lines.push(
+      `Time: ${capture.timestamp}${capture.duration ? ` (${capture.duration})` : ""}`
+    );
+    lines.push("");
+    if (capture.filesChanged.length > 0) {
+      lines.push(`## Files Changed (${capture.filesChanged.length})`);
+      capture.filesChanged.forEach((f) => lines.push(`  - ${f}`));
+      lines.push("");
+    }
+    if (capture.filesCreated.length > 0) {
+      lines.push(`## Files Created (${capture.filesCreated.length})`);
+      capture.filesCreated.forEach((f) => lines.push(`  + ${f}`));
+      lines.push("");
+    }
+    if (capture.filesDeleted.length > 0) {
+      lines.push(`## Files Deleted (${capture.filesDeleted.length})`);
+      capture.filesDeleted.forEach((f) => lines.push(`  - ${f}`));
+      lines.push("");
+    }
+    if (capture.commits.length > 0) {
+      lines.push(`## Commits (${capture.commits.length})`);
+      capture.commits.forEach(
+        (c) => lines.push(`  ${c.hash.slice(0, 7)} ${c.message}`)
+      );
+      lines.push("");
+    }
+    if (capture.decisions.length > 0) {
+      lines.push("## Decisions");
+      capture.decisions.forEach((d) => lines.push(`  - ${d}`));
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  // --- Private ---
+  /**
+   * Extract decision-like statements from commit messages.
+   * Looks for patterns like "chose X over Y", "switched to", "decided", etc.
+   */
+  extractDecisions(commits) {
+    const decisionPatterns = [
+      /chose\s+.+\s+over\s+/i,
+      /switched\s+(to|from)\s+/i,
+      /decided\s+/i,
+      /replaced\s+.+\s+with\s+/i,
+      /migrated?\s+(to|from)\s+/i,
+      /refactor/i,
+      /breaking\s+change/i
+    ];
+    const decisions = [];
+    for (const commit of commits) {
+      for (const pattern of decisionPatterns) {
+        if (pattern.test(commit.message)) {
+          decisions.push(commit.message);
+          break;
+        }
+      }
+    }
+    return decisions;
+  }
+  estimateDuration(commits) {
+    if (commits.length < 2) return void 0;
+    const first = new Date(commits[commits.length - 1].date);
+    const last = new Date(commits[0].date);
+    const diffMs = last.getTime() - first.getTime();
+    return formatDuration(diffMs);
+  }
+  save(result) {
+    const filename = `${result.timestamp.replace(/[:.]/g, "-")}-${result.branch.replace(/[^a-zA-Z0-9-]/g, "-").slice(0, 30)}.json`;
+    const filePath = join(this.capturesDir, filename);
+    writeFileSync(filePath, JSON.stringify(result, null, 2));
+    pruneOldFiles(this.capturesDir, ".json", MAX_CAPTURES);
+  }
+}
+export {
+  ContextCapture
+};