@stackmemoryai/stackmemory 1.2.1 → 1.2.4

package/dist/src/core/execution/parallel-executor.js

@@ -106,7 +106,11 @@ class ParallelExecutor extends EventEmitter {
           taskId,
           error: lastError.message
         });
-        this.emit("task-retry", { taskId, attempt: attempts, error: lastError });
+        this.emit("task-retry", {
+          taskId,
+          attempt: attempts,
+          error: lastError
+        });
         if (attempts < maxRetries) {
           await this.delay(Math.pow(2, attempts) * 1e3);
         }

package/dist/src/core/projects/project-isolation.js

@@ -25,9 +25,20 @@ class ProjectIsolationManager {
     try {
       const remoteUrl = this.getGitRemoteUrl(projectRoot);
       const gitInfo = this.parseGitRemote(remoteUrl);
-      const projectId = this.createStableProjectId(gitInfo.organization, gitInfo.repository);
-      const workspaceFilter = this.createWorkspaceFilter(gitInfo.organization, gitInfo.repository, projectRoot);
-      const linearConfig = this.getLinearConfiguration(gitInfo.organization, gitInfo.repository, projectRoot);
+      const projectId = this.createStableProjectId(
+        gitInfo.organization,
+        gitInfo.repository
+      );
+      const workspaceFilter = this.createWorkspaceFilter(
+        gitInfo.organization,
+        gitInfo.repository,
+        projectRoot
+      );
+      const linearConfig = this.getLinearConfiguration(
+        gitInfo.organization,
+        gitInfo.repository,
+        projectRoot
+      );
       const identification = {
         projectId,
         organization: gitInfo.organization,
@@ -45,7 +56,10 @@ class ProjectIsolationManager {
       });
       return identification;
     } catch (error) {
-      logger.warn("Could not determine git remote, using fallback identification", { error });
+      logger.warn(
+        "Could not determine git remote, using fallback identification",
+        { error }
+      );
       const fallback = this.createFallbackIdentification(projectRoot);
       this.projectCache.set(cacheKey, fallback);
       return fallback;

package/dist/src/core/security/index.js

@@ -15,6 +15,7 @@ import {
   validateInput,
   createAggregateSchema,
   validateShellArg,
+  validateShellCommand,
   safeJsonParse
 } from "./input-sanitizer.js";
 export {
@@ -30,5 +31,6 @@ export {
   sanitizeIdentifier,
   validateInput,
   validateShellArg,
+  validateShellCommand,
   validateTableName
 };

package/dist/src/core/security/input-sanitizer.js

@@ -280,6 +280,28 @@ function createAggregateSchema(allowedFields) {
     limit: z.number().int().min(1).max(1e3).optional()
   });
 }
+const DANGEROUS_SHELL_PATTERNS = [
+  /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|--recursive)\b/i,
+  // rm -rf, rm -fr, rm --recursive
+  /\brm\s+-[a-zA-Z]*r\b/i,
+  // rm -r (any flag combo with r)
+  /\bmkfs\b/i,
+  /\bdd\s+if=/i,
+  /\b:\(\)\s*\{/i
+  // fork bomb
+];
+function validateShellCommand(command) {
+  for (const pattern of DANGEROUS_SHELL_PATTERNS) {
+    if (pattern.test(command)) {
+      throw new ValidationError(
+        `Blocked dangerous shell command: ${command.substring(0, 80)}`,
+        ErrorCode.VALIDATION_FAILED,
+        { reason: "dangerous_command" }
+      );
+    }
+  }
+  return command;
+}
 function validateShellArg(arg) {
   if (!arg) return "";
   const dangerousChars = /[;&|`$(){}[\]<>!#*?~\n\r]/;
@@ -316,5 +338,6 @@ export {
   sanitizeIdentifier,
   validateInput,
   validateShellArg,
+  validateShellCommand,
   validateTableName
 };

package/dist/src/core/utils/update-checker.js

@@ -63,12 +63,16 @@ class UpdateChecker {
   static async fetchLatestVersion() {
     try {
       const fetchVersion = async () => {
-        const output = execFileSync("npm", ["view", this.PACKAGE_NAME, "version"], {
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "ignore"],
-          timeout: 5e3
-          // 5 second timeout
-        }).trim();
+        const output = execFileSync(
+          "npm",
+          ["view", this.PACKAGE_NAME, "version"],
+          {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
+            timeout: 5e3
+            // 5 second timeout
+          }
+        ).trim();
         return output;
       };
       return await gracefulDegrade(

package/dist/src/daemon/daemon-config.js

@@ -30,8 +30,9 @@ const DEFAULT_DAEMON_CONFIG = {
     ftsRebuildInterval: 24,
     // hours
     embeddingBatchSize: 50,
-    vacuumInterval: 168
+    vacuumInterval: 168,
     // weekly
+    gcIntervalSeconds: 60
   },
   memory: {
     enabled: true,

package/dist/src/daemon/services/auto-save-service.js

@@ -0,0 +1,121 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { existsSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+import { homedir } from "os";
+class DaemonContextService {
+  config;
+  state;
+  intervalId;
+  isRunning = false;
+  onLog;
+  constructor(config, onLog) {
+    this.config = config;
+    this.onLog = onLog;
+    this.state = {
+      lastSaveTime: 0,
+      saveCount: 0,
+      errors: []
+    };
+  }
+  start() {
+    if (this.isRunning || !this.config.enabled) {
+      return;
+    }
+    this.isRunning = true;
+    const intervalMs = this.config.interval * 60 * 1e3;
+    this.onLog("INFO", "Context service started", {
+      interval: this.config.interval
+    });
+    this.saveContext();
+    this.intervalId = setInterval(() => {
+      this.saveContext();
+    }, intervalMs);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    this.isRunning = false;
+    this.onLog("INFO", "Context service stopped");
+  }
+  getState() {
+    return { ...this.state };
+  }
+  updateConfig(config) {
+    const wasRunning = this.isRunning;
+    if (wasRunning) {
+      this.stop();
+    }
+    this.config = { ...this.config, ...config };
+    if (wasRunning && this.config.enabled) {
+      this.start();
+    }
+  }
+  forceSave() {
+    this.saveContext();
+  }
+  saveContext() {
+    if (!this.isRunning) return;
+    try {
+      const stackmemoryBin = this.getStackMemoryBin();
+      if (!stackmemoryBin) {
+        this.onLog("WARN", "StackMemory binary not found");
+        return;
+      }
+      const message = this.config.checkpointMessage || `Auto-checkpoint #${this.state.saveCount + 1}`;
+      const fullMessage = `${message} at ${(/* @__PURE__ */ new Date()).toISOString()}`;
+      execSync(`"${stackmemoryBin}" context add observation "${fullMessage}"`, {
+        timeout: 3e4,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      this.state.saveCount++;
+      this.state.lastSaveTime = Date.now();
+      this.onLog("INFO", "Context saved", {
+        saveCount: this.state.saveCount
+      });
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      if (!errorMsg.includes("EBUSY") && !errorMsg.includes("EAGAIN")) {
+        this.state.errors.push(errorMsg);
+        this.onLog("WARN", "Failed to save context", { error: errorMsg });
+        if (this.state.errors.length > 10) {
+          this.state.errors = this.state.errors.slice(-10);
+        }
+      }
+    }
+  }
+  getStackMemoryBin() {
+    const homeDir = homedir();
+    const locations = [
+      join(homeDir, ".stackmemory", "bin", "stackmemory"),
+      join(homeDir, ".local", "bin", "stackmemory"),
+      "/usr/local/bin/stackmemory",
+      "/opt/homebrew/bin/stackmemory"
+    ];
+    for (const loc of locations) {
+      if (existsSync(loc)) {
+        return loc;
+      }
+    }
+    try {
+      const result = execSync("which stackmemory", {
+        encoding: "utf8",
+        stdio: "pipe"
+      }).trim();
+      if (result && existsSync(result)) {
+        return result;
+      }
+    } catch {
+    }
+    return null;
+  }
+}
+export {
+  DaemonContextService
+};

package/dist/src/daemon/services/maintenance-service.js

@@ -10,6 +10,7 @@ class DaemonMaintenanceService {
   state;
   embeddingProvider = null;
   intervalId;
+  gcIntervalId;
   isRunning = false;
   onLog;
   constructor(config, onLog) {
@@ -48,12 +49,26 @@ class DaemonMaintenanceService {
         );
       });
     }, intervalMs);
+    if (this.config.gcEnabled !== false) {
+      const gcMs = (this.config.gcIntervalSeconds ?? 60) * 1e3;
+      this.gcIntervalId = setInterval(() => {
+        this.runGCCycle().catch((err) => {
+          this.addError(
+            `GC cycle: ${err instanceof Error ? err.message : String(err)}`
+          );
+        });
+      }, gcMs);
+    }
   }
   stop() {
     if (this.intervalId) {
       clearInterval(this.intervalId);
       this.intervalId = void 0;
     }
+    if (this.gcIntervalId) {
+      clearInterval(this.gcIntervalId);
+      this.gcIntervalId = void 0;
+    }
     this.isRunning = false;
     this.onLog("INFO", "Maintenance service stopped");
   }
@@ -93,6 +108,7 @@ class DaemonMaintenanceService {
       await this.backfillEmbeddings(db);
       await this.maybeVacuum(db);
       await this.generateMissingDigests(db);
+      await this.recomputeScores(db);
       await this.runGC(db);
       await db.disconnect();
       this.state.lastRunTime = Date.now();
@@ -280,14 +296,73 @@ class DaemonMaintenanceService {
       );
     }
   }
+  /**
+   * Dedicated lightweight GC cycle (runs more frequently than full maintenance).
+   * Queries active run_ids for protection and delegates to adapter.runGC().
+   */
+  async runGCCycle() {
+    try {
+      const db = await this.getDatabase();
+      if (!db) return;
+      const rawDb = db.getRawDatabase?.();
+      let protectedRunIds = [];
+      if (rawDb) {
+        const rows = rawDb.prepare(
+          "SELECT DISTINCT run_id FROM frames WHERE state = 'active' LIMIT 10"
+        ).all();
+        protectedRunIds = rows.map((r) => r.run_id);
+      }
+      const result = await db.runGC({
+        retentionDays: this.config.gcRetentionDays ?? 90,
+        batchSize: this.config.gcBatchSize ?? 100,
+        dryRun: false,
+        protectedRunIds
+      });
+      this.state.framesGarbageCollected += result.framesDeleted;
+      this.state.lastGcRun = Date.now();
+      if (result.framesDeleted > 0) {
+        this.onLog(
+          "INFO",
+          `GC cycle deleted ${result.framesDeleted} expired frames`
+        );
+      }
+      await db.disconnect();
+    } catch (err) {
+      this.addError(
+        `GC cycle: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  async recomputeScores(db) {
+    try {
+      if (typeof db.recomputeImportanceScores !== "function") return;
+      const updated = db.recomputeImportanceScores(100);
+      if (updated > 0) {
+        this.onLog("INFO", `Recomputed ${updated} importance scores`);
+      }
+    } catch (err) {
+      this.addError(
+        `Score recompute: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
   async runGC(db) {
     try {
       if (this.config.gcEnabled === false) return;
       if (typeof db.runGC !== "function") return;
+      const rawDb = db.getRawDatabase?.();
+      let protectedRunIds = [];
+      if (rawDb) {
+        const rows = rawDb.prepare(
+          "SELECT DISTINCT run_id FROM frames WHERE state = 'active' LIMIT 10"
+        ).all();
+        protectedRunIds = rows.map((r) => r.run_id);
+      }
       const result = await db.runGC({
         retentionDays: this.config.gcRetentionDays ?? 90,
         batchSize: this.config.gcBatchSize ?? 100,
-        dryRun: false
+        dryRun: false,
+        protectedRunIds
       });
       this.state.framesGarbageCollected += result.framesDeleted;
       this.state.lastGcRun = Date.now();

package/dist/src/features/sweep/prompt-builder.js

@@ -49,7 +49,7 @@ function trimContentAroundCursor(lines, cursorLine, cursorCol, maxTokens) {
   const windowSize = Math.floor(targetChars / avgLineLength);
   const halfWindow = Math.floor(windowSize / 2);
   let start = Math.max(0, cursorLine - halfWindow);
-  let end = Math.min(lines.length, start + windowSize);
+  const end = Math.min(lines.length, start + windowSize);
   if (end === lines.length) {
     start = Math.max(0, end - windowSize);
   }
@@ -60,7 +60,7 @@ function trimContentAroundCursor(lines, cursorLine, cursorCol, maxTokens) {
   };
 }
 function parseCompletion(completionText, originalLines, windowStart, windowEnd) {
-  let text = completionText.replace(/<\|file_sep\|>$/, "").replace(/<\/s>$/, "").trimEnd();
+  const text = completionText.replace(/<\|file_sep\|>$/, "").replace(/<\/s>$/, "").trimEnd();
   if (!text || text.trim().length === 0) {
     return null;
   }

package/dist/src/hooks/graphiti-hooks.js

@@ -20,6 +20,17 @@ class GraphitiHooks {
     emitter.registerHandler("session_start", this.onSessionStart.bind(this));
     emitter.registerHandler("file_change", this.onFileChange.bind(this));
     emitter.registerHandler("session_end", this.onSessionEnd.bind(this));
+    emitter.registerHandler("input_idle", this.onInputIdle.bind(this));
+    emitter.registerHandler("context_switch", this.onContextSwitch.bind(this));
+    emitter.registerHandler("prompt_submit", this.onPromptSubmit.bind(this));
+    emitter.registerHandler("tool_use", this.onToolUse.bind(this));
+    emitter.registerHandler(
+      "suggestion_ready",
+      this.onSuggestionReady.bind(this)
+    );
+    emitter.registerHandler("agent_start", this.onAgentStart.bind(this));
+    emitter.registerHandler("agent_complete", this.onAgentComplete.bind(this));
+    emitter.registerHandler("agent_error", this.onAgentError.bind(this));
     logger.info("Graphiti hooks registered", {
       endpoint: this.config.endpoint,
       backend: this.config.backend,
@@ -82,6 +93,144 @@ class GraphitiHooks {
       });
     }
   }
+  async onInputIdle(event) {
+    const idle = event;
+    try {
+      const episode = {
+        type: "input_idle",
+        content: {
+          idleDuration: idle.data.idleDuration,
+          lastInput: idle.data.lastInput
+        },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti input_idle episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onContextSwitch(event) {
+    const ctx = event;
+    try {
+      const episode = {
+        type: "context_switch",
+        content: {
+          fromBranch: ctx.data.fromBranch,
+          toBranch: ctx.data.toBranch,
+          fromProject: ctx.data.fromProject,
+          toProject: ctx.data.toProject
+        },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti context_switch episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onPromptSubmit(event) {
+    try {
+      const episode = {
+        type: "prompt_submit",
+        content: event.data || {},
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti prompt_submit episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onToolUse(event) {
+    try {
+      const episode = {
+        type: "tool_use",
+        content: event.data || {},
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti tool_use episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onSuggestionReady(event) {
+    const suggestion = event;
+    try {
+      const episode = {
+        type: "suggestion_ready",
+        content: {
+          source: suggestion.data.source,
+          confidence: suggestion.data.confidence,
+          preview: suggestion.data.preview
+        },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti suggestion_ready episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onAgentStart(event) {
+    const e = event;
+    try {
+      const episode = {
+        type: "agent_start",
+        content: { agentType: e.data.agentType, task: e.data.task },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti agent_start episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onAgentComplete(event) {
+    const e = event;
+    try {
+      const episode = {
+        type: "agent_complete",
+        content: { ...e.data },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti agent_complete episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onAgentError(event) {
+    const e = event;
+    try {
+      const episode = {
+        type: "agent_error",
+        content: { agentType: e.data.agentType, error: e.data.error },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti agent_error episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   // Expose a simple temporal query helper for future MCP tooling
   async buildTemporalContext(query = {}) {
     const now = Date.now();

package/dist/src/hooks/session-summary.js

@@ -3,6 +3,8 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
 import { pickNextLinearTask } from "./linear-task-picker.js";
 function formatDuration(ms) {
   const seconds = Math.floor(ms / 1e3);
@@ -125,6 +127,34 @@ async function generateSuggestions(context) {
     }
   } catch {
   }
+  try {
+    const patchDir = path.join(process.cwd(), ".stackmemory", "patches");
+    if (fs.existsSync(patchDir)) {
+      const patches = fs.readdirSync(patchDir).filter((f) => f.endsWith(".patch"));
+      if (patches.length > 0) {
+        suggestions.push({
+          key: String(keyIndex++),
+          label: `Review ${patches.length} pending patch${patches.length > 1 ? "es" : ""}`,
+          action: `ls -la .stackmemory/patches/`,
+          priority: 75
+        });
+      }
+    }
+  } catch {
+  }
+  try {
+    const tmpEntries = fs.readdirSync("/tmp").filter((d) => d.startsWith("sm-spec-"));
+    if (tmpEntries.length > 0) {
+      const latest = path.join("/tmp", tmpEntries[tmpEntries.length - 1]);
+      suggestions.push({
+        key: String(keyIndex++),
+        label: `Inspect spec branch (${tmpEntries.length} workspace${tmpEntries.length > 1 ? "s" : ""})`,
+        action: `cd ${latest} && git log --oneline -5`,
+        priority: 65
+      });
+    }
+  } catch {
+  }
   const durationMs = Date.now() - context.sessionStartTime;
   if (durationMs > 30 * 60 * 1e3) {
     suggestions.push({