@stackmemoryai/stackmemory 0.5.57 → 0.5.59

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/daemon/daemon-config.ts"],
+  "sourcesContent": ["/**\n * Daemon Configuration Management\n * Handles loading, saving, and validating daemon configuration\n */\n\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\nimport { join } from 'path';\nimport { homedir } from 'os';\n\nexport interface DaemonServiceConfig {\n  enabled: boolean;\n  interval: number; // minutes\n}\n\nexport interface ContextServiceConfig extends DaemonServiceConfig {\n  checkpointMessage?: string;\n}\n\nexport interface LinearServiceConfig extends DaemonServiceConfig {\n  quietHours?: {\n    start: number; // hour 0-23\n    end: number;\n  };\n  retryAttempts: number;\n  retryDelay: number; // ms\n}\n\nexport interface FileWatchConfig extends DaemonServiceConfig {\n  paths: string[];\n  extensions: string[];\n  ignore: string[];\n  debounceMs: number;\n}\n\nexport interface DaemonConfig {\n  version: string;\n  context: ContextServiceConfig;\n  linear: LinearServiceConfig;\n  fileWatch: FileWatchConfig;\n  heartbeatInterval: number; // seconds\n  inactivityTimeout: number; // minutes, 0 = disabled\n  logLevel: 'debug' | 'info' | 'warn' | 'error';\n}\n\nexport const DEFAULT_DAEMON_CONFIG: DaemonConfig = {\n  version: '1.0.0',\n  context: {\n    enabled: true,\n    interval: 15, // 15 minutes\n    checkpointMessage: 'Auto-checkpoint',\n  },\n  linear: {\n    enabled: false, // Disabled by default, requires setup\n    interval: 60, // 60 minutes\n    quietHours: { start: 22, end: 7 },\n    retryAttempts: 3,\n    retryDelay: 30000,\n  },\n  fileWatch: {\n    enabled: false, // Disabled by default\n    interval: 0, // Not interval-based\n    paths: ['.'],\n    extensions: ['.ts', '.js', '.tsx', '.jsx', '.py', '.go', '.rs'],\n    ignore: ['node_modules', '.git', 'dist', 'build', '.stackmemory'],\n    debounceMs: 2000,\n  },\n  heartbeatInterval: 60, // 1 minute\n  inactivityTimeout: 0, // Disabled by default\n  logLevel: 'info',\n};\n\nexport interface DaemonStatus {\n  running: boolean;\n  pid?: number;\n  startTime?: number;\n  uptime?: number;\n  services: {\n    context: { enabled: boolean; lastRun?: number; saveCount?: number };\n    linear: { enabled: boolean; lastRun?: number; syncCount?: number };\n    fileWatch: { enabled: boolean; eventsProcessed?: number };\n  };\n  errors: string[];\n}\n\n/**\n * Get the daemon directory path\n */\nexport function getDaemonDir(): string {\n  const dir = join(homedir(), '.stackmemory', 'daemon');\n  if (!existsSync(dir)) {\n    mkdirSync(dir, { recursive: true });\n  }\n  return dir;\n}\n\n/**\n * Get the logs directory path\n */\nexport function getLogsDir(): string {\n  const dir = join(homedir(), '.stackmemory', 'logs');\n  if (!existsSync(dir)) {\n    mkdirSync(dir, { recursive: true });\n  }\n  return dir;\n}\n\n/**\n * Get daemon file paths\n */\nexport function getDaemonPaths() {\n  const daemonDir = getDaemonDir();\n  const logsDir = getLogsDir();\n  return {\n    pidFile: join(daemonDir, 'daemon.pid'),\n    statusFile: join(daemonDir, 'daemon.status'),\n    configFile: join(daemonDir, 'config.json'),\n    logFile: join(logsDir, 'daemon.log'),\n  };\n}\n\n/**\n * Load daemon configuration\n */\nexport function loadDaemonConfig(): DaemonConfig {\n  const { configFile } = getDaemonPaths();\n\n  if (!existsSync(configFile)) {\n    return { ...DEFAULT_DAEMON_CONFIG };\n  }\n\n  try {\n    const content = readFileSync(configFile, 'utf8');\n    const config = JSON.parse(content) as Partial<DaemonConfig>;\n    return {\n      ...DEFAULT_DAEMON_CONFIG,\n      ...config,\n      context: { ...DEFAULT_DAEMON_CONFIG.context, ...config.context },\n      linear: { ...DEFAULT_DAEMON_CONFIG.linear, ...config.linear },\n      fileWatch: { ...DEFAULT_DAEMON_CONFIG.fileWatch, ...config.fileWatch },\n    };\n  } catch {\n    return { ...DEFAULT_DAEMON_CONFIG };\n  }\n}\n\n/**\n * Save daemon configuration\n */\nexport function saveDaemonConfig(config: Partial<DaemonConfig>): void {\n  const { configFile } = getDaemonPaths();\n  const currentConfig = loadDaemonConfig();\n  const newConfig = {\n    ...currentConfig,\n    ...config,\n    context: { ...currentConfig.context, ...config.context },\n    linear: { ...currentConfig.linear, ...config.linear },\n    fileWatch: { ...currentConfig.fileWatch, ...config.fileWatch },\n  };\n  writeFileSync(configFile, JSON.stringify(newConfig, null, 2));\n}\n\n/**\n * Read daemon status\n */\nexport function readDaemonStatus(): DaemonStatus {\n  const { statusFile, pidFile } = getDaemonPaths();\n\n  const defaultStatus: DaemonStatus = {\n    running: false,\n    services: {\n      context: { enabled: false },\n      linear: { enabled: false },\n      fileWatch: { enabled: false },\n    },\n    errors: [],\n  };\n\n  // Check PID file first\n  if (!existsSync(pidFile)) {\n    return defaultStatus;\n  }\n\n  try {\n    const pidContent = readFileSync(pidFile, 'utf8').trim();\n    const pid = parseInt(pidContent, 10);\n\n    // Check if process is running\n    try {\n      process.kill(pid, 0);\n    } catch {\n      // Process not running\n      return defaultStatus;\n    }\n\n    // Read status file\n    if (!existsSync(statusFile)) {\n      return { ...defaultStatus, running: true, pid };\n    }\n\n    const content = readFileSync(statusFile, 'utf8');\n    const status = JSON.parse(content) as DaemonStatus;\n    return {\n      ...status,\n      running: true,\n      pid,\n      uptime: status.startTime ? Date.now() - status.startTime : undefined,\n    };\n  } catch {\n    return defaultStatus;\n  }\n}\n\n/**\n * Write daemon status\n */\nexport function writeDaemonStatus(status: Partial<DaemonStatus>): void {\n  const { statusFile } = getDaemonPaths();\n  const currentStatus = readDaemonStatus();\n  const newStatus = { ...currentStatus, ...status };\n  writeFileSync(statusFile, JSON.stringify(newStatus, null, 2));\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,122 @@
+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
+};
+//# sourceMappingURL=context-service.js.map

package/dist/src/daemon/services/context-service.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/daemon/services/context-service.ts"],
+  "sourcesContent": ["/**\n * Context Auto-Save Service\n * Periodically saves context checkpoints\n */\n\nimport { existsSync } from 'fs';\nimport { join } from 'path';\nimport { execSync } from 'child_process';\nimport { homedir } from 'os';\nimport type { ContextServiceConfig } from '../daemon-config.js';\n\nexport interface ContextServiceState {\n  lastSaveTime: number;\n  saveCount: number;\n  errors: string[];\n}\n\nexport class DaemonContextService {\n  private config: ContextServiceConfig;\n  private state: ContextServiceState;\n  private intervalId?: NodeJS.Timeout;\n  private isRunning = false;\n  private onLog: (level: string, message: string, data?: unknown) => void;\n\n  constructor(\n    config: ContextServiceConfig,\n    onLog: (level: string, message: string, data?: unknown) => void\n  ) {\n    this.config = config;\n    this.onLog = onLog;\n    this.state = {\n      lastSaveTime: 0,\n      saveCount: 0,\n      errors: [],\n    };\n  }\n\n  start(): void {\n    if (this.isRunning || !this.config.enabled) {\n      return;\n    }\n\n    this.isRunning = true;\n    const intervalMs = this.config.interval * 60 * 1000;\n\n    this.onLog('INFO', 'Context service started', {\n      interval: this.config.interval,\n    });\n\n    // Initial save\n    this.saveContext();\n\n    // Schedule periodic saves\n    this.intervalId = setInterval(() => {\n      this.saveContext();\n    }, intervalMs);\n  }\n\n  stop(): void {\n    if (this.intervalId) {\n      clearInterval(this.intervalId);\n      this.intervalId = undefined;\n    }\n    this.isRunning = false;\n    this.onLog('INFO', 'Context service stopped');\n  }\n\n  getState(): ContextServiceState {\n    return { ...this.state };\n  }\n\n  updateConfig(config: Partial<ContextServiceConfig>): void {\n    const wasRunning = this.isRunning;\n    if (wasRunning) {\n      this.stop();\n    }\n\n    this.config = { ...this.config, ...config };\n\n    if (wasRunning && this.config.enabled) {\n      this.start();\n    }\n  }\n\n  forceSave(): void {\n    this.saveContext();\n  }\n\n  private saveContext(): void {\n    if (!this.isRunning) return;\n\n    try {\n      const stackmemoryBin = this.getStackMemoryBin();\n\n      if (!stackmemoryBin) {\n        this.onLog('WARN', 'StackMemory binary not found');\n        return;\n      }\n\n      const message =\n        this.config.checkpointMessage ||\n        `Auto-checkpoint #${this.state.saveCount + 1}`;\n      const fullMessage = `${message} at ${new Date().toISOString()}`;\n\n      execSync(`\"${stackmemoryBin}\" context add observation \"${fullMessage}\"`, {\n        timeout: 30000,\n        encoding: 'utf8',\n        stdio: 'pipe',\n      });\n\n      this.state.saveCount++;\n      this.state.lastSaveTime = Date.now();\n\n      this.onLog('INFO', 'Context saved', {\n        saveCount: this.state.saveCount,\n      });\n    } catch (err) {\n      const errorMsg = err instanceof Error ? err.message : String(err);\n\n      // Only log if not a transient error\n      if (!errorMsg.includes('EBUSY') && !errorMsg.includes('EAGAIN')) {\n        this.state.errors.push(errorMsg);\n        this.onLog('WARN', 'Failed to save context', { error: errorMsg });\n\n        // Keep only last 10 errors\n        if (this.state.errors.length > 10) {\n          this.state.errors = this.state.errors.slice(-10);\n        }\n      }\n    }\n  }\n\n  private getStackMemoryBin(): string | null {\n    const homeDir = homedir();\n\n    // Check common locations\n    const locations = [\n      join(homeDir, '.stackmemory', 'bin', 'stackmemory'),\n      join(homeDir, '.local', 'bin', 'stackmemory'),\n      '/usr/local/bin/stackmemory',\n      '/opt/homebrew/bin/stackmemory',\n    ];\n\n    for (const loc of locations) {\n      if (existsSync(loc)) {\n        return loc;\n      }\n    }\n\n    // Try to find in PATH\n    try {\n      const result = execSync('which stackmemory', {\n        encoding: 'utf8',\n        stdio: 'pipe',\n      }).trim();\n      if (result && existsSync(result)) {\n        return result;\n      }\n    } catch {\n      // Not in PATH\n    }\n\n    return null;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,136 @@
+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 { homedir } from "os";
+class DaemonLinearService {
+  config;
+  state;
+  intervalId;
+  isRunning = false;
+  onLog;
+  constructor(config, onLog) {
+    this.config = config;
+    this.onLog = onLog;
+    this.state = {
+      lastSyncTime: 0,
+      syncCount: 0,
+      errors: []
+    };
+  }
+  async start() {
+    if (this.isRunning || !this.config.enabled) {
+      return;
+    }
+    if (!this.isLinearConfigured()) {
+      this.onLog("WARN", "Linear not configured, skipping linear service");
+      return;
+    }
+    this.isRunning = true;
+    const intervalMs = this.config.interval * 60 * 1e3;
+    this.onLog("INFO", "Linear service started", {
+      interval: this.config.interval,
+      quietHours: this.config.quietHours
+    });
+    await this.performSync();
+    this.intervalId = setInterval(async () => {
+      await this.performSync();
+    }, intervalMs);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    this.isRunning = false;
+    this.onLog("INFO", "Linear service stopped");
+  }
+  getState() {
+    return {
+      ...this.state,
+      nextSyncTime: this.isRunning ? this.state.lastSyncTime + this.config.interval * 60 * 1e3 : void 0
+    };
+  }
+  updateConfig(config) {
+    const wasRunning = this.isRunning;
+    if (wasRunning) {
+      this.stop();
+    }
+    this.config = { ...this.config, ...config };
+    if (wasRunning && this.config.enabled) {
+      this.start();
+    }
+  }
+  async forceSync() {
+    await this.performSync();
+  }
+  async performSync() {
+    if (!this.isRunning) return;
+    if (this.isInQuietHours()) {
+      this.onLog("DEBUG", "Skipping sync during quiet hours");
+      return;
+    }
+    try {
+      const { LinearAutoSyncService } = await import("../../integrations/linear/auto-sync.js");
+      const projectRoot = this.findProjectRoot();
+      if (!projectRoot) {
+        this.onLog("WARN", "No project root found for Linear sync");
+        return;
+      }
+      const syncService = new LinearAutoSyncService(projectRoot, {
+        enabled: true,
+        interval: this.config.interval,
+        retryAttempts: this.config.retryAttempts,
+        retryDelay: this.config.retryDelay,
+        quietHours: this.config.quietHours
+      });
+      await syncService.forceSync();
+      syncService.stop();
+      this.state.syncCount++;
+      this.state.lastSyncTime = Date.now();
+      this.onLog("INFO", "Linear sync completed", {
+        syncCount: this.state.syncCount
+      });
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.state.errors.push(errorMsg);
+      this.onLog("ERROR", "Linear sync failed", { error: errorMsg });
+      if (this.state.errors.length > 10) {
+        this.state.errors = this.state.errors.slice(-10);
+      }
+    }
+  }
+  isLinearConfigured() {
+    const homeDir = homedir();
+    const configPath = join(homeDir, ".stackmemory", "linear-auth.json");
+    return existsSync(configPath) || !!process.env["LINEAR_API_KEY"];
+  }
+  findProjectRoot() {
+    const cwd = process.cwd();
+    if (existsSync(join(cwd, ".stackmemory"))) {
+      return cwd;
+    }
+    const homeDir = homedir();
+    if (existsSync(join(homeDir, ".stackmemory"))) {
+      return homeDir;
+    }
+    return null;
+  }
+  isInQuietHours() {
+    if (!this.config.quietHours) return false;
+    const now = /* @__PURE__ */ new Date();
+    const currentHour = now.getHours();
+    const { start, end } = this.config.quietHours;
+    if (start > end) {
+      return currentHour >= start || currentHour < end;
+    } else {
+      return currentHour >= start && currentHour < end;
+    }
+  }
+}
+export {
+  DaemonLinearService
+};
+//# sourceMappingURL=linear-service.js.map

package/dist/src/daemon/services/linear-service.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/daemon/services/linear-service.ts"],
+  "sourcesContent": ["/**\n * Linear Sync Service Wrapper\n * Wraps LinearAutoSyncService for daemon integration\n */\n\nimport { existsSync } from 'fs';\nimport { join } from 'path';\nimport { homedir } from 'os';\nimport type { LinearServiceConfig } from '../daemon-config.js';\n\nexport interface LinearServiceState {\n  lastSyncTime: number;\n  syncCount: number;\n  errors: string[];\n  nextSyncTime?: number;\n}\n\nexport class DaemonLinearService {\n  private config: LinearServiceConfig;\n  private state: LinearServiceState;\n  private intervalId?: NodeJS.Timeout;\n  private isRunning = false;\n  private onLog: (level: string, message: string, data?: unknown) => void;\n\n  constructor(\n    config: LinearServiceConfig,\n    onLog: (level: string, message: string, data?: unknown) => void\n  ) {\n    this.config = config;\n    this.onLog = onLog;\n    this.state = {\n      lastSyncTime: 0,\n      syncCount: 0,\n      errors: [],\n    };\n  }\n\n  async start(): Promise<void> {\n    if (this.isRunning || !this.config.enabled) {\n      return;\n    }\n\n    // Check if Linear is configured\n    if (!this.isLinearConfigured()) {\n      this.onLog('WARN', 'Linear not configured, skipping linear service');\n      return;\n    }\n\n    this.isRunning = true;\n    const intervalMs = this.config.interval * 60 * 1000;\n\n    this.onLog('INFO', 'Linear service started', {\n      interval: this.config.interval,\n      quietHours: this.config.quietHours,\n    });\n\n    // Initial sync\n    await this.performSync();\n\n    // Schedule periodic syncs\n    this.intervalId = setInterval(async () => {\n      await this.performSync();\n    }, intervalMs);\n  }\n\n  stop(): void {\n    if (this.intervalId) {\n      clearInterval(this.intervalId);\n      this.intervalId = undefined;\n    }\n    this.isRunning = false;\n    this.onLog('INFO', 'Linear service stopped');\n  }\n\n  getState(): LinearServiceState {\n    return {\n      ...this.state,\n      nextSyncTime: this.isRunning\n        ? this.state.lastSyncTime + this.config.interval * 60 * 1000\n        : undefined,\n    };\n  }\n\n  updateConfig(config: Partial<LinearServiceConfig>): void {\n    const wasRunning = this.isRunning;\n    if (wasRunning) {\n      this.stop();\n    }\n\n    this.config = { ...this.config, ...config };\n\n    if (wasRunning && this.config.enabled) {\n      this.start();\n    }\n  }\n\n  async forceSync(): Promise<void> {\n    await this.performSync();\n  }\n\n  private async performSync(): Promise<void> {\n    if (!this.isRunning) return;\n\n    // Check quiet hours\n    if (this.isInQuietHours()) {\n      this.onLog('DEBUG', 'Skipping sync during quiet hours');\n      return;\n    }\n\n    try {\n      // Dynamically import LinearAutoSyncService to avoid loading if not needed\n      const { LinearAutoSyncService } =\n        await import('../../integrations/linear/auto-sync.js');\n\n      const projectRoot = this.findProjectRoot();\n      if (!projectRoot) {\n        this.onLog('WARN', 'No project root found for Linear sync');\n        return;\n      }\n\n      const syncService = new LinearAutoSyncService(projectRoot, {\n        enabled: true,\n        interval: this.config.interval,\n        retryAttempts: this.config.retryAttempts,\n        retryDelay: this.config.retryDelay,\n        quietHours: this.config.quietHours,\n      });\n\n      await syncService.forceSync();\n      syncService.stop();\n\n      this.state.syncCount++;\n      this.state.lastSyncTime = Date.now();\n\n      this.onLog('INFO', 'Linear sync completed', {\n        syncCount: this.state.syncCount,\n      });\n    } catch (err) {\n      const errorMsg = err instanceof Error ? err.message : String(err);\n      this.state.errors.push(errorMsg);\n      this.onLog('ERROR', 'Linear sync failed', { error: errorMsg });\n\n      // Keep only last 10 errors\n      if (this.state.errors.length > 10) {\n        this.state.errors = this.state.errors.slice(-10);\n      }\n    }\n  }\n\n  private isLinearConfigured(): boolean {\n    const homeDir = homedir();\n    const configPath = join(homeDir, '.stackmemory', 'linear-auth.json');\n    return existsSync(configPath) || !!process.env['LINEAR_API_KEY'];\n  }\n\n  private findProjectRoot(): string | null {\n    // Check common locations\n    const cwd = process.cwd();\n    if (existsSync(join(cwd, '.stackmemory'))) {\n      return cwd;\n    }\n\n    // Check home directory\n    const homeDir = homedir();\n    if (existsSync(join(homeDir, '.stackmemory'))) {\n      return homeDir;\n    }\n\n    return null;\n  }\n\n  private isInQuietHours(): boolean {\n    if (!this.config.quietHours) return false;\n\n    const now = new Date();\n    const currentHour = now.getHours();\n    const { start, end } = this.config.quietHours;\n\n    if (start > end) {\n      // Quiet hours span midnight (e.g., 22:00 - 07:00)\n      return currentHour >= start || currentHour < end;\n    } else {\n      // Quiet hours within same day\n      return currentHour >= start && currentHour < end;\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+class SessionDaemon {
+  config;
+  state;
+  stackmemoryDir;
+  sessionsDir;
+  logsDir;
+  pidFile;
+  heartbeatFile;
+  logFile;
+  saveInterval = null;
+  heartbeatInterval = null;
+  activityCheckInterval = null;
+  isShuttingDown = false;
+  constructor(sessionId2, options2) {
+    const homeDir = process.env["HOME"] || process.env["USERPROFILE"] || "";
+    this.stackmemoryDir = path.join(homeDir, ".stackmemory");
+    this.sessionsDir = path.join(this.stackmemoryDir, "sessions");
+    this.logsDir = path.join(this.stackmemoryDir, "logs");
+    this.config = {
+      sessionId: sessionId2,
+      saveIntervalMs: options2?.saveIntervalMs ?? 15 * 60 * 1e3,
+      inactivityTimeoutMs: options2?.inactivityTimeoutMs ?? 30 * 60 * 1e3,
+      heartbeatIntervalMs: options2?.heartbeatIntervalMs ?? 60 * 1e3
+    };
+    this.pidFile = path.join(this.sessionsDir, `${sessionId2}.pid`);
+    this.heartbeatFile = path.join(this.sessionsDir, `${sessionId2}.heartbeat`);
+    this.logFile = path.join(this.logsDir, "daemon.log");
+    this.state = {
+      startTime: Date.now(),
+      lastSaveTime: Date.now(),
+      lastActivityTime: Date.now(),
+      saveCount: 0,
+      errors: []
+    };
+    this.ensureDirectories();
+  }
+  ensureDirectories() {
+    [this.sessionsDir, this.logsDir].forEach((dir) => {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    });
+  }
+  log(level, message, data) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      sessionId: this.config.sessionId,
+      message,
+      data
+    };
+    const logLine = JSON.stringify(entry) + "\n";
+    try {
+      fs.appendFileSync(this.logFile, logLine);
+    } catch {
+      console.error(`[${entry.timestamp}] ${level}: ${message}`, data);
+    }
+  }
+  checkIdempotency() {
+    if (fs.existsSync(this.pidFile)) {
+      try {
+        const existingPid = fs.readFileSync(this.pidFile, "utf8").trim();
+        const pid = parseInt(existingPid, 10);
+        try {
+          process.kill(pid, 0);
+          this.log("WARN", "Daemon already running for this session", {
+            existingPid: pid
+          });
+          return false;
+        } catch {
+          this.log("INFO", "Cleaning up stale PID file", { stalePid: pid });
+          fs.unlinkSync(this.pidFile);
+        }
+      } catch {
+        try {
+          fs.unlinkSync(this.pidFile);
+        } catch {
+        }
+      }
+    }
+    return true;
+  }
+  writePidFile() {
+    fs.writeFileSync(this.pidFile, process.pid.toString());
+    this.log("INFO", "PID file created", {
+      pid: process.pid,
+      file: this.pidFile
+    });
+  }
+  updateHeartbeat() {
+    const heartbeatData = {
+      pid: process.pid,
+      sessionId: this.config.sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uptime: Date.now() - this.state.startTime,
+      saveCount: this.state.saveCount,
+      lastSaveTime: new Date(this.state.lastSaveTime).toISOString()
+    };
+    try {
+      fs.writeFileSync(
+        this.heartbeatFile,
+        JSON.stringify(heartbeatData, null, 2)
+      );
+    } catch (err) {
+      this.log("ERROR", "Failed to update heartbeat file", {
+        error: String(err)
+      });
+    }
+  }
+  saveContext() {
+    if (this.isShuttingDown) return;
+    try {
+      const stackmemoryBin = path.join(
+        this.stackmemoryDir,
+        "bin",
+        "stackmemory"
+      );
+      if (!fs.existsSync(stackmemoryBin)) {
+        this.log("WARN", "StackMemory binary not found", {
+          path: stackmemoryBin
+        });
+        return;
+      }
+      const message = `Auto-checkpoint #${this.state.saveCount + 1} at ${(/* @__PURE__ */ new Date()).toISOString()}`;
+      execSync(`"${stackmemoryBin}" context add observation "${message}"`, {
+        timeout: 3e4,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      this.state.saveCount++;
+      this.state.lastSaveTime = Date.now();
+      this.log("INFO", "Context saved successfully", {
+        saveCount: this.state.saveCount,
+        intervalMs: this.config.saveIntervalMs
+      });
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      if (!errorMsg.includes("EBUSY") && !errorMsg.includes("EAGAIN")) {
+        this.state.errors.push(errorMsg);
+        this.log("WARN", "Failed to save context", { error: errorMsg });
+      }
+      if (this.state.errors.length > 50) {
+        this.log("ERROR", "Too many errors, initiating shutdown");
+        this.shutdown("too_many_errors");
+      }
+    }
+  }
+  checkActivity() {
+    if (this.isShuttingDown) return;
+    const sessionFile = path.join(
+      this.stackmemoryDir,
+      "traces",
+      "current-session.json"
+    );
+    try {
+      if (fs.existsSync(sessionFile)) {
+        const stats = fs.statSync(sessionFile);
+        const lastModified = stats.mtimeMs;
+        if (lastModified > this.state.lastActivityTime) {
+          this.state.lastActivityTime = lastModified;
+          this.log("DEBUG", "Activity detected", {
+            lastModified: new Date(lastModified).toISOString()
+          });
+        }
+      }
+    } catch {
+    }
+    const inactiveTime = Date.now() - this.state.lastActivityTime;
+    if (inactiveTime > this.config.inactivityTimeoutMs) {
+      this.log("INFO", "Inactivity timeout reached", {
+        inactiveTimeMs: inactiveTime,
+        timeoutMs: this.config.inactivityTimeoutMs
+      });
+      this.shutdown("inactivity_timeout");
+    }
+  }
+  setupSignalHandlers() {
+    const handleSignal = (signal) => {
+      this.log("INFO", `Received ${signal}, shutting down gracefully`);
+      this.shutdown(signal.toLowerCase());
+    };
+    process.on("SIGTERM", () => handleSignal("SIGTERM"));
+    process.on("SIGINT", () => handleSignal("SIGINT"));
+    process.on("SIGHUP", () => handleSignal("SIGHUP"));
+    process.on("uncaughtException", (err) => {
+      this.log("ERROR", "Uncaught exception", {
+        error: err.message,
+        stack: err.stack
+      });
+      this.shutdown("uncaught_exception");
+    });
+    process.on("unhandledRejection", (reason) => {
+      this.log("ERROR", "Unhandled rejection", { reason: String(reason) });
+    });
+  }
+  cleanup() {
+    try {
+      if (fs.existsSync(this.pidFile)) {
+        fs.unlinkSync(this.pidFile);
+        this.log("INFO", "PID file removed");
+      }
+    } catch (e) {
+      this.log("WARN", "Failed to remove PID file", { error: String(e) });
+    }
+    try {
+      const finalHeartbeat = {
+        pid: process.pid,
+        sessionId: this.config.sessionId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "shutdown",
+        uptime: Date.now() - this.state.startTime,
+        totalSaves: this.state.saveCount
+      };
+      fs.writeFileSync(
+        this.heartbeatFile,
+        JSON.stringify(finalHeartbeat, null, 2)
+      );
+    } catch {
+    }
+  }
+  shutdown(reason) {
+    if (this.isShuttingDown) return;
+    this.isShuttingDown = true;
+    this.log("INFO", "Daemon shutting down", {
+      reason,
+      uptime: Date.now() - this.state.startTime,
+      totalSaves: this.state.saveCount,
+      errors: this.state.errors.length
+    });
+    if (this.saveInterval) {
+      clearInterval(this.saveInterval);
+      this.saveInterval = null;
+    }
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.activityCheckInterval) {
+      clearInterval(this.activityCheckInterval);
+      this.activityCheckInterval = null;
+    }
+    try {
+      this.saveContext();
+    } catch {
+    }
+    this.cleanup();
+    process.exit(
+      reason === "inactivity_timeout" || reason === "sigterm" ? 0 : 1
+    );
+  }
+  start() {
+    if (!this.checkIdempotency()) {
+      this.log("INFO", "Exiting - daemon already running");
+      process.exit(0);
+    }
+    this.writePidFile();
+    this.setupSignalHandlers();
+    this.log("INFO", "Session daemon started", {
+      sessionId: this.config.sessionId,
+      pid: process.pid,
+      saveIntervalMs: this.config.saveIntervalMs,
+      inactivityTimeoutMs: this.config.inactivityTimeoutMs
+    });
+    this.updateHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      this.updateHeartbeat();
+    }, this.config.heartbeatIntervalMs);
+    this.saveInterval = setInterval(() => {
+      this.saveContext();
+    }, this.config.saveIntervalMs);
+    this.activityCheckInterval = setInterval(() => {
+      this.checkActivity();
+    }, 60 * 1e3);
+    this.saveContext();
+  }
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let sessionId2 = `session-${Date.now()}`;
+  const options2 = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--session-id" && args[i + 1]) {
+      sessionId2 = args[i + 1];
+      i++;
+    } else if (arg === "--save-interval" && args[i + 1]) {
+      options2.saveIntervalMs = parseInt(args[i + 1], 10) * 1e3;
+      i++;
+    } else if (arg === "--inactivity-timeout" && args[i + 1]) {
+      options2.inactivityTimeoutMs = parseInt(args[i + 1], 10) * 1e3;
+      i++;
+    } else if (arg === "--heartbeat-interval" && args[i + 1]) {
+      options2.heartbeatIntervalMs = parseInt(args[i + 1], 10) * 1e3;
+      i++;
+    } else if (!arg.startsWith("--")) {
+      sessionId2 = arg;
+    }
+  }
+  return { sessionId: sessionId2, options: options2 };
+}
+const { sessionId, options } = parseArgs();
+const daemon = new SessionDaemon(sessionId, options);
+daemon.start();
+//# sourceMappingURL=session-daemon.js.map