@stackmemoryai/stackmemory 1.2.2 → 1.2.4

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/integrations/linear/config.js

@@ -62,7 +62,9 @@ class LinearConfigManager {
    * Get default configuration with project isolation
    */
   getDefaultConfig() {
-    const projectId = this.isolationManager.getProjectIdentification(this.projectRoot);
+    const projectId = this.isolationManager.getProjectIdentification(
+      this.projectRoot
+    );
     return {
       enabled: true,
       interval: 5,

package/dist/src/integrations/linear/sync.js

@@ -5,7 +5,6 @@ const __dirname = __pathDirname(__filename);
 import { readFileSync, writeFileSync, existsSync } from "fs";
 import { join } from "path";
 import { logger } from "../../core/monitoring/logger.js";
-import { IntegrationError, ErrorCode } from "../../core/errors/index.js";
 import { LinearClient } from "./client.js";
 class LinearSyncEngine {
   taskStore;
@@ -15,6 +14,7 @@ class LinearSyncEngine {
   mappings = /* @__PURE__ */ new Map();
   projectRoot;
   mappingsPath;
+  _isConfigured = true;
   constructor(taskStore, authManager, config, projectRoot) {
     this.taskStore = taskStore;
     this.authManager = authManager;
@@ -33,10 +33,9 @@ class LinearSyncEngine {
     } else {
       const tokens = this.authManager.loadTokens();
       if (!tokens) {
-        throw new IntegrationError(
-          'Linear API key or authentication tokens not found. Set LINEAR_API_KEY environment variable or run "stackmemory linear setup" first.',
-          ErrorCode.LINEAR_SYNC_FAILED
-        );
+        logger.info("Linear API key not configured \u2014 skipping Linear sync");
+        this._isConfigured = false;
+        return;
       }
       this.linearClient = new LinearClient({
         apiKey: tokens.accessToken,
@@ -49,6 +48,12 @@ class LinearSyncEngine {
     }
     this.loadMappings();
   }
+  /**
+   * Check if Linear credentials are available
+   */
+  get isConfigured() {
+    return this._isConfigured;
+  }
   /**
    * Update sync configuration
    */
@@ -59,6 +64,14 @@ class LinearSyncEngine {
    * Perform bi-directional sync
    */
   async sync() {
+    if (!this._isConfigured) {
+      return {
+        success: true,
+        synced: { toLinear: 0, fromLinear: 0, updated: 0 },
+        conflicts: [],
+        errors: []
+      };
+    }
     if (!this.config.enabled) {
       return {
         success: false,

package/dist/src/integrations/mcp/handlers/code-execution-handlers.js

@@ -27,7 +27,12 @@ class CodeExecutionHandler {
    * Execute code in a controlled environment
    */
   async executeCode(params) {
-    const { language, code, workingDirectory, timeout = EXECUTION_TIMEOUT } = params;
+    const {
+      language,
+      code,
+      workingDirectory,
+      timeout = EXECUTION_TIMEOUT
+    } = params;
     if (!this.allowedLanguages.includes(language.toLowerCase())) {
       return {
         success: false,
@@ -43,7 +48,12 @@ class CodeExecutionHandler {
     );
     try {
       await fs.writeFile(tempFile, code, "utf-8");
-      const result = await this.runCode(language, tempFile, workingDirectory || this.sandboxDir, timeout);
+      const result = await this.runCode(
+        language,
+        tempFile,
+        workingDirectory || this.sandboxDir,
+        timeout
+      );
       await fs.unlink(tempFile).catch(() => {
       });
       return result;
@@ -98,8 +108,15 @@ class CodeExecutionHandler {
         clearTimeout(timeoutId);
         let outputFile;
         if (truncated) {
-          outputFile = join(this.sandboxDir, `output_${randomBytes(8).toString("hex")}.txt`);
-          await fs.writeFile(outputFile, stdout + "\n---STDERR---\n" + stderr, "utf-8").catch(() => {
+          outputFile = join(
+            this.sandboxDir,
+            `output_${randomBytes(8).toString("hex")}.txt`
+          );
+          await fs.writeFile(
+            outputFile,
+            stdout + "\n---STDERR---\n" + stderr,
+            "utf-8"
+          ).catch(() => {
           });
         }
         resolve({
@@ -175,12 +192,21 @@ class CodeExecutionHandler {
     const warnings = [];
     const dangerousPatterns = [
       { pattern: /import\s+os/i, message: "Importing os module detected" },
-      { pattern: /import\s+subprocess/i, message: "Subprocess module detected" },
+      {
+        pattern: /import\s+subprocess/i,
+        message: "Subprocess module detected"
+      },
       { pattern: /exec\s*\(/i, message: "exec() function detected" },
       { pattern: /eval\s*\(/i, message: "eval() function detected" },
       { pattern: /__import__/i, message: "__import__ detected" },
-      { pattern: /open\s*\([^)]*['"]\//i, message: "Absolute path file access detected" },
-      { pattern: /require\s*\([^)]*child_process/i, message: "child_process module detected" },
+      {
+        pattern: /open\s*\([^)]*['"]\//i,
+        message: "Absolute path file access detected"
+      },
+      {
+        pattern: /require\s*\([^)]*child_process/i,
+        message: "child_process module detected"
+      },
       { pattern: /require\s*\([^)]*fs/i, message: "fs module access detected" }
     ];
     for (const { pattern, message } of dangerousPatterns) {