@stackmemoryai/stackmemory 1.3.2 → 1.4.0

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
+};

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

@@ -0,0 +1,313 @@
+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";
+import { extname } from "path";
+import { extractKeywords as extractKeywordsShared } from "../utils/text.js";
+class PreflightChecker {
+  repoPath;
+  gitLogCache = /* @__PURE__ */ new Map();
+  constructor(repoPath) {
+    this.repoPath = repoPath || process.cwd();
+  }
+  /**
+   * Run pre-flight check on a set of tasks.
+   * Returns parallel-safe groupings and sequential recommendations.
+   */
+  check(tasks) {
+    if (tasks.length < 2) {
+      return {
+        parallelSafe: [tasks],
+        sequential: [],
+        allOverlaps: [],
+        summary: "Single task - no overlap check needed."
+      };
+    }
+    const taskFiles = /* @__PURE__ */ new Map();
+    const taskKeywords = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      const files = this.predictFiles(task);
+      taskFiles.set(task.name, files);
+      taskKeywords.set(
+        task.name,
+        task.keywords || this.extractKeywords(task.description)
+      );
+    }
+    const allOverlaps = [];
+    const overlapPairs = /* @__PURE__ */ new Map();
+    for (let i = 0; i < tasks.length; i++) {
+      for (let j = i + 1; j < tasks.length; j++) {
+        const a = tasks[i];
+        const b = tasks[j];
+        const filesA = taskFiles.get(a.name);
+        const filesB = taskFiles.get(b.name);
+        const shared = [...filesA].filter((f) => filesB.has(f));
+        if (shared.length > 0) {
+          for (const file of shared) {
+            allOverlaps.push({
+              file,
+              tasks: [a.name, b.name],
+              confidence: this.estimateConfidenceCached(
+                file,
+                taskKeywords.get(a.name),
+                taskKeywords.get(b.name),
+                a,
+                b
+              ),
+              source: this.getSourceCached(
+                file,
+                taskKeywords.get(a.name),
+                taskKeywords.get(b.name),
+                a,
+                b
+              )
+            });
+          }
+          if (!overlapPairs.has(a.name)) overlapPairs.set(a.name, /* @__PURE__ */ new Set());
+          if (!overlapPairs.has(b.name)) overlapPairs.set(b.name, /* @__PURE__ */ new Set());
+          overlapPairs.get(a.name).add(b.name);
+          overlapPairs.get(b.name).add(a.name);
+        }
+      }
+    }
+    const parallelSafe = this.buildParallelGroups(tasks, overlapPairs);
+    const sequential = [];
+    for (const task of tasks) {
+      const conflicts = overlapPairs.get(task.name);
+      if (conflicts && conflicts.size > 0) {
+        const overlaps = allOverlaps.filter((o) => o.tasks.includes(task.name));
+        const largestConflict = [...conflicts].sort((a, b) => {
+          return (taskFiles.get(b)?.size || 0) - (taskFiles.get(a)?.size || 0);
+        })[0];
+        sequential.push({
+          task,
+          after: largestConflict,
+          overlaps
+        });
+      }
+    }
+    const deduped = this.deduplicateSequential(sequential, taskFiles);
+    const summary = this.formatSummary(parallelSafe, deduped, allOverlaps);
+    return {
+      parallelSafe,
+      sequential: deduped,
+      allOverlaps,
+      summary
+    };
+  }
+  /**
+   * Predict which files a task will touch based on multiple signals.
+   */
+  predictFiles(task) {
+    const files = /* @__PURE__ */ new Set();
+    if (task.files) {
+      task.files.forEach((f) => files.add(f));
+    }
+    const keywords = task.keywords || this.extractKeywords(task.description);
+    for (const keyword of keywords) {
+      const historyFiles = this.searchGitHistory(keyword);
+      historyFiles.forEach((f) => files.add(f));
+    }
+    if (task.files && task.files.length > 0) {
+      for (const file of task.files) {
+        const dependents = this.findDependents(file);
+        dependents.forEach((f) => files.add(f));
+      }
+    }
+    for (const keyword of keywords) {
+      const matched = this.searchFilePaths(keyword);
+      matched.forEach((f) => files.add(f));
+    }
+    return files;
+  }
+  /**
+   * Search git log for files changed in commits matching a keyword.
+   */
+  searchGitHistory(keyword, maxCommits = 50) {
+    const cacheKey = keyword.toLowerCase();
+    if (this.gitLogCache.has(cacheKey)) {
+      return this.gitLogCache.get(cacheKey);
+    }
+    try {
+      const output = execFileSync(
+        "git",
+        [
+          "log",
+          `--max-count=${maxCommits}`,
+          "--name-only",
+          "--pretty=format:",
+          "--grep",
+          keyword,
+          "-i"
+        ],
+        { cwd: this.repoPath, encoding: "utf-8", timeout: 1e4 }
+      );
+      const files = output.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+      const freq = /* @__PURE__ */ new Map();
+      for (const f of files) {
+        freq.set(f, (freq.get(f) || 0) + 1);
+      }
+      const result = [...freq.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20).map(([f]) => f);
+      this.gitLogCache.set(cacheKey, result);
+      return result;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Find files that import/depend on a given file (shallow, grep-based).
+   */
+  findDependents(filePath) {
+    const ext = extname(filePath);
+    if (![".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) return [];
+    const baseName = filePath.replace(extname(filePath), "").replace(/\/index$/, "");
+    try {
+      const output = execFileSync(
+        "git",
+        ["grep", "-l", baseName, "--", "*.ts", "*.tsx", "*.js", "*.jsx"],
+        { cwd: this.repoPath, encoding: "utf-8", timeout: 1e4 }
+      );
+      return output.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && l !== filePath);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Search file paths for keyword matches using git ls-files.
+   */
+  searchFilePaths(keyword) {
+    try {
+      const output = execFileSync("git", ["ls-files", `*${keyword}*`], {
+        cwd: this.repoPath,
+        encoding: "utf-8",
+        timeout: 5e3
+      });
+      return output.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).slice(0, 10);
+    } catch {
+      return [];
+    }
+  }
+  extractKeywords(description) {
+    return extractKeywordsShared(description);
+  }
+  isInHistory(keywords, file) {
+    return keywords.some(
+      (k) => (this.gitLogCache.get(k.toLowerCase()) || []).includes(file)
+    );
+  }
+  estimateConfidenceCached(file, keywordsA, keywordsB, taskA, taskB) {
+    if (taskA.files?.includes(file) || taskB.files?.includes(file)) {
+      return 0.9;
+    }
+    if (this.isInHistory(keywordsA, file) && this.isInHistory(keywordsB, file)) {
+      return 0.7;
+    }
+    return 0.3;
+  }
+  getSourceCached(file, keywordsA, keywordsB, taskA, taskB) {
+    if (taskA.files?.includes(file) || taskB.files?.includes(file)) {
+      return "explicit";
+    }
+    if (this.isInHistory(keywordsA, file) || this.isInHistory(keywordsB, file)) {
+      return "git-history";
+    }
+    return "keyword-match";
+  }
+  /**
+   * Build parallel-safe groups via greedy graph coloring.
+   * Tasks that overlap go in different groups.
+   */
+  buildParallelGroups(tasks, overlapPairs) {
+    const groups = [];
+    const assigned = /* @__PURE__ */ new Set();
+    const sorted = [...tasks].sort((a, b) => {
+      const conflictsA = overlapPairs.get(a.name)?.size || 0;
+      const conflictsB = overlapPairs.get(b.name)?.size || 0;
+      return conflictsA - conflictsB;
+    });
+    for (const task of sorted) {
+      if (assigned.has(task.name)) continue;
+      let placed = false;
+      for (const group of groups) {
+        const conflicts = overlapPairs.get(task.name) || /* @__PURE__ */ new Set();
+        const groupHasConflict = group.some((t) => conflicts.has(t.name));
+        if (!groupHasConflict) {
+          group.push(task);
+          assigned.add(task.name);
+          placed = true;
+          break;
+        }
+      }
+      if (!placed) {
+        groups.push([task]);
+        assigned.add(task.name);
+      }
+    }
+    return groups;
+  }
+  /**
+   * Deduplicate sequential recommendations — keep only the smaller task.
+   */
+  deduplicateSequential(sequential, taskFiles) {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const entry of sequential) {
+      const key = [entry.task.name, entry.after].sort().join("|");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const mySize = taskFiles.get(entry.task.name)?.size || 0;
+      const otherSize = taskFiles.get(entry.after)?.size || 0;
+      if (mySize <= otherSize) {
+        result.push(entry);
+      } else {
+        const otherTask = sequential.find((s) => s.task.name === entry.after);
+        if (otherTask) {
+          result.push({
+            task: otherTask.task,
+            after: entry.task.name,
+            overlaps: entry.overlaps
+          });
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Format human-readable summary.
+   */
+  formatSummary(parallelSafe, sequential, overlaps) {
+    const lines = [];
+    if (overlaps.length === 0) {
+      lines.push("All tasks are parallel-safe. No file overlaps detected.");
+      return lines.join("\n");
+    }
+    lines.push(`Found ${overlaps.length} file overlap(s).
+`);
+    if (parallelSafe.length === 1) {
+      lines.push(
+        "All tasks can run in parallel (overlaps are low-confidence)."
+      );
+    } else {
+      lines.push(`Parallel groups (${parallelSafe.length}):`);
+      parallelSafe.forEach((group, i) => {
+        lines.push(`  Group ${i + 1}: ${group.map((t) => t.name).join(", ")}`);
+      });
+    }
+    if (sequential.length > 0) {
+      lines.push("\nSequential recommendations:");
+      for (const entry of sequential) {
+        lines.push(`  "${entry.task.name}" should run after "${entry.after}"`);
+        for (const overlap of entry.overlaps.slice(0, 5)) {
+          lines.push(
+            `    - ${overlap.file} (${overlap.source}, ${Math.round(overlap.confidence * 100)}%)`
+          );
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+}
+export {
+  PreflightChecker
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.3.2",
+  "version": "1.4.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",

package/scripts/git-hooks/post-commit-stackmemory.sh

@@ -268,6 +268,30 @@ record_commit_metrics() {
     return 0
 }
 
+# Auto-capture context after commit
+capture_context() {
+    if [ "$STACKMEMORY_ENABLED" != "true" ]; then
+        return 0
+    fi
+
+    local commit_info="$1"
+    IFS='|' read -r commit_hash commit_msg commit_author branch files_changed <<< "$commit_info"
+
+    # Only capture on significant commits (3+ files or feature/fix commits)
+    if [ "$files_changed" -lt 3 ] && ! echo "$commit_msg" | grep -iE "(feat|fix|refactor|complete|done)" >/dev/null; then
+        return 0
+    fi
+
+    log_info "Capturing context for session continuity..."
+    if stackmemory snapshot save --task "$commit_msg" >/dev/null 2>&1; then
+        log_success "Context captured"
+    else
+        log_warning "Context capture failed (non-critical)"
+    fi
+
+    return 0
+}
+
 # Main execution
 main() {
     log_info "📝 StackMemory post-commit hook starting..."
@@ -297,6 +321,9 @@ main() {
     record_commit_metrics "$commit_info"
     sync_with_linear "$commit_info"
 
+    # Auto-capture context for session continuity
+    capture_context "$commit_info"
+
     log_success "🎉 Post-commit processing completed!"
     return 0
 }