@stackmemoryai/stackmemory 1.3.2 → 1.5.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/package.json

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

package/templates/claude-hooks/skill-eval.cjs

@@ -350,6 +350,12 @@ function evaluate(prompt) {
     if (config.showMatchReasons && match.reasons.length > 0) {
       output += `   Matched: ${match.reasons.slice(0, 3).join(', ')}\n`;
     }
+
+    // Show suggestion if the skill defines one (e.g. loop-monitor)
+    const skillDef = skills[match.name];
+    if (skillDef?.suggestion) {
+      output += `   Suggestion: ${skillDef.suggestion}\n`;
+    }
   }
 
   if (relatedSkills.length > 0) {

package/templates/claude-hooks/skill-rules.json

@@ -255,6 +255,22 @@
       },
       "relatedSkills": ["linear-task-runner"]
     },
+    "loop-monitor": {
+      "description": "Monitor CI, deploys, logs, or external state with stackmemory loop",
+      "priority": 9,
+      "triggers": {
+        "keywords": ["monitor", "watch", "poll", "wait for", "check status", "loop", "keep checking", "deploy status", "ci status", "action status", "run status"],
+        "keywordPatterns": ["\\b(?:monitor|watch|poll|loop)\\b", "wait\\s+(?:for|until)", "keep\\s+checking", "check.*(?:status|state|progress)", "(?:gh|github)\\s+(?:run|action|check)", "deploy.*(?:status|log|done)", "\\buntil\\b.*(?:done|complete|pass|success|fail)"],
+        "intentPatterns": [
+          "(?:monitor|watch|poll|check).*(?:ci|deploy|action|run|build|status|log|inbox)",
+          "(?:wait|loop).*(?:until|for).*(?:done|complete|pass|success|finish)",
+          "(?:keep|continue).*(?:checking|monitoring|watching)",
+          "(?:let me know|notify|alert).*(?:when|if).*(?:done|complete|ready|fail)"
+        ]
+      },
+      "suggestion": "Use `stackmemory loop` to poll a command until a condition is met:\n  stackmemory loop \"<command>\" --until \"<pattern>\" -i 10s -t 30m\n  stackmemory loop \"gh run view <id> --json status -q .status\" --until \"completed\"\n  stackmemory loop \"curl -s http://localhost/health\" --until \"ok\" --json",
+      "relatedSkills": ["github-actions"]
+    },
     "linear-task-runner": {
       "description": "Execute Linear tasks via RLM orchestrator",
       "priority": 8,