@stackmemoryai/stackmemory 1.3.1 → 1.4.0

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/dist/src/integrations/claude-code/subagent-client.js

@@ -19,7 +19,6 @@ import {
 import { AnthropicBatchClient } from "../anthropic/batch-client.js";
 class ClaudeCodeSubagentClient {
   tempDir;
-  activeSubagents = /* @__PURE__ */ new Map();
   mockMode;
   constructor(mockMode = false) {
     this.mockMode = mockMode;
@@ -344,13 +343,7 @@ Context (JSON): ${JSON.stringify(request.context)}`;
    */
   spawnClaude(prompt, timeout) {
     return new Promise((resolve, reject) => {
-      const args = [
-        "-p",
-        "--output-format",
-        "stream-json",
-        "--dangerously-skip-permissions",
-        prompt
-      ];
+      const args = ["-p", "--output-format", "stream-json", prompt];
       const claude = spawn("claude", args, {
         cwd: process.cwd(),
         env: { ...process.env },
@@ -548,84 +541,11 @@ function greetUser(name: string): string {
       }
     }
   }
-  /**
-   * Create a mock Task tool response for development
-   * This simulates what Claude Code's Task tool would return
-   */
-  async mockTaskToolExecution(request) {
-    const startTime = Date.now();
-    await new Promise(
-      (resolve) => setTimeout(resolve, 1e3 + Math.random() * 2e3)
-    );
-    const mockResponses = {
-      planning: {
-        tasks: [
-          { id: "1", type: "analyze", description: "Analyze requirements" },
-          { id: "2", type: "implement", description: "Implement solution" },
-          { id: "3", type: "test", description: "Test implementation" },
-          { id: "4", type: "review", description: "Review and improve" }
-        ],
-        dependencies: { "2": ["1"], "3": ["2"], "4": ["3"] }
-      },
-      code: {
-        implementation: `
-export class Solution {
-  constructor(private config: any) {}
-  
-  async execute(input: string): Promise<string> {
-    // Implementation generated by Code subagent
-    return this.process(input);
-  }
-  
-  private process(input: string): string {
-    return \`Processed: \${input}\`;
-  }
-}`,
-        files: ["src/solution.ts"]
-      },
-      testing: {
-        tests: `
-describe('Solution', () => {
-  it('should process input correctly', () => {
-    const solution = new Solution({});
-    const result = solution.execute('test');
-    expect(result).toBe('Processed: test');
-  });
-  
-  it('should handle edge cases', () => {
-    // Edge case tests
-  });
-});`,
-        coverage: { lines: 95, branches: 88, functions: 100 }
-      },
-      review: {
-        quality: 0.82,
-        issues: [
-          { severity: "high", message: "Missing error handling" },
-          { severity: "medium", message: "Could improve type safety" }
-        ],
-        suggestions: [
-          "Add try-catch blocks",
-          "Use stricter TypeScript types",
-          "Add input validation"
-        ]
-      }
-    };
-    return {
-      success: true,
-      result: mockResponses[request.type] || { status: "completed" },
-      output: `Mock ${request.type} subagent completed successfully`,
-      duration: Date.now() - startTime,
-      subagentType: request.type,
-      tokens: Math.floor(Math.random() * 5e3) + 1e3
-    };
-  }
   /**
    * Get active subagent statistics
    */
   getStats() {
     return {
-      activeSubagents: this.activeSubagents.size,
       tempDir: this.tempDir
     };
   }
@@ -633,10 +553,6 @@ describe('Solution', () => {
    * Cleanup all resources
    */
   async cleanupAll() {
-    for (const [id, controller] of this.activeSubagents) {
-      controller.abort();
-    }
-    this.activeSubagents.clear();
     if (fs.existsSync(this.tempDir)) {
       const files = await fs.promises.readdir(this.tempDir);
       for (const file of files) {

package/dist/src/integrations/claude-code/task-coordinator.js

@@ -166,11 +166,16 @@ class ClaudeCodeTaskCoordinator {
       completedTasks: this.completedTasks.length
     });
     if (this.activeTasks.size > 0) {
-      const timeoutPromise = new Promise(
-        (resolve) => setTimeout(resolve, 3e4)
-      );
+      let timer;
+      const timeoutPromise = new Promise((resolve) => {
+        timer = setTimeout(resolve, 3e4);
+      });
       const completionPromise = this.waitForTaskCompletion();
-      await Promise.race([completionPromise, timeoutPromise]);
+      try {
+        await Promise.race([completionPromise, timeoutPromise]);
+      } finally {
+        clearTimeout(timer);
+      }
       if (this.activeTasks.size > 0) {
         logger.warn("Force terminating active tasks", {
           remainingTasks: this.activeTasks.size

package/package.json

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