@stackmemoryai/stackmemory 0.5.57 → 0.5.59

package/dist/src/core/worktree/worktree-manager.js

@@ -0,0 +1,465 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, basename, dirname } from "path";
+import { homedir } from "os";
+import Database from "better-sqlite3";
+import { logger } from "../monitoring/logger.js";
+import { ProjectManager } from "../projects/project-manager.js";
+import {
+  createErrorHandler
+} from "../errors/index.js";
+class WorktreeManager {
+  static instance;
+  config;
+  configPath;
+  worktreeCache = /* @__PURE__ */ new Map();
+  contextMap = /* @__PURE__ */ new Map();
+  db;
+  constructor() {
+    this.configPath = join(homedir(), ".stackmemory", "worktree-config.json");
+    this.config = this.loadConfig();
+    try {
+      if (this.config.enabled) {
+        this.initialize();
+      }
+    } catch (error) {
+      logger.error(
+        "Failed to initialize WorktreeManager",
+        error instanceof Error ? error : new Error(String(error)),
+        {
+          configPath: this.configPath
+        }
+      );
+      this.config.enabled = false;
+    }
+  }
+  static getInstance() {
+    if (!WorktreeManager.instance) {
+      WorktreeManager.instance = new WorktreeManager();
+    }
+    return WorktreeManager.instance;
+  }
+  /**
+   * Initialize worktree management
+   */
+  initialize() {
+    const dbPath = join(homedir(), ".stackmemory", "worktrees.db");
+    const errorHandler = createErrorHandler({
+      operation: "initialize",
+      dbPath
+    });
+    try {
+      this.db = new Database(dbPath);
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS worktrees (
+          id TEXT PRIMARY KEY,
+          path TEXT NOT NULL UNIQUE,
+          branch TEXT NOT NULL,
+          commit TEXT,
+          is_main BOOLEAN,
+          is_bare BOOLEAN,
+          is_detached BOOLEAN,
+          linked_path TEXT,
+          context_id TEXT UNIQUE,
+          project_id TEXT,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+
+        CREATE TABLE IF NOT EXISTS worktree_contexts (
+          context_id TEXT PRIMARY KEY,
+          worktree_id TEXT NOT NULL,
+          project_id TEXT,
+          branch TEXT,
+          context_path TEXT,
+          db_path TEXT,
+          last_synced DATETIME,
+          metadata JSON,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (worktree_id) REFERENCES worktrees(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS context_sync (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_context TEXT,
+        target_context TEXT,
+        sync_type TEXT, -- 'push', 'pull', 'merge'
+        data JSON,
+        synced_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_worktrees_project ON worktrees(project_id);
+      CREATE INDEX IF NOT EXISTS idx_contexts_worktree ON worktree_contexts(worktree_id);
+    `);
+    } catch (error) {
+      errorHandler(error);
+    }
+  }
+  /**
+   * Load configuration
+   */
+  loadConfig() {
+    if (existsSync(this.configPath)) {
+      try {
+        return JSON.parse(readFileSync(this.configPath, "utf-8"));
+      } catch (error) {
+        logger.error("Failed to load worktree config", error);
+      }
+    }
+    return {
+      enabled: false,
+      autoDetect: true,
+      isolateContexts: true,
+      shareGlobalContext: false,
+      syncInterval: 15,
+      maxWorktrees: 10
+    };
+  }
+  /**
+   * Save configuration
+   */
+  saveConfig(config) {
+    this.config = { ...this.config, ...config };
+    const configDir = dirname(this.configPath);
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+    writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+    if (config.enabled && !this.db) {
+      this.initialize();
+    }
+    logger.info("Worktree configuration updated", { config: this.config });
+  }
+  /**
+   * Detect git worktrees in current repository
+   */
+  detectWorktrees(repoPath) {
+    const path = repoPath || process.cwd();
+    try {
+      const output = execSync("git worktree list --porcelain", {
+        cwd: path,
+        encoding: "utf-8"
+      });
+      const worktrees = [];
+      const lines = output.split("\n");
+      let currentWorktree = {};
+      for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+          if (currentWorktree.path) {
+            worktrees.push(this.finalizeWorktreeInfo(currentWorktree));
+          }
+          currentWorktree = { path: line.substring(9) };
+        } else if (line.startsWith("HEAD ")) {
+          currentWorktree.commit = line.substring(5);
+        } else if (line.startsWith("branch ")) {
+          currentWorktree.branch = line.substring(7);
+        } else if (line === "bare") {
+          currentWorktree.isBare = true;
+        } else if (line === "detached") {
+          currentWorktree.isDetached = true;
+        }
+      }
+      if (currentWorktree.path) {
+        worktrees.push(this.finalizeWorktreeInfo(currentWorktree));
+      }
+      if (worktrees.length > 0) {
+        const mainPath = this.getMainWorktreePath(path);
+        worktrees.forEach((wt) => {
+          wt.isMainWorktree = wt.path === mainPath;
+          if (!wt.isMainWorktree) {
+            wt.linkedPath = mainPath;
+          }
+        });
+      }
+      worktrees.forEach((wt) => {
+        this.worktreeCache.set(wt.path, wt);
+        if (this.config.enabled) {
+          this.saveWorktree(wt);
+        }
+      });
+      logger.info(`Detected ${worktrees.length} worktrees`, {
+        count: worktrees.length,
+        branches: worktrees.map((w) => w.branch).filter(Boolean)
+      });
+      return worktrees;
+    } catch (error) {
+      logger.debug("Not a git repository or git worktree not available");
+      return [];
+    }
+  }
+  /**
+   * Get main worktree path
+   */
+  getMainWorktreePath(path) {
+    try {
+      const gitDir = execSync("git rev-parse --git-common-dir", {
+        cwd: path,
+        encoding: "utf-8"
+      }).trim();
+      if (gitDir.includes("/.git/worktrees/")) {
+        const mainGitDir = gitDir.replace(/\/\.git\/worktrees\/.*$/, "");
+        return mainGitDir;
+      }
+      return dirname(gitDir);
+    } catch {
+      return path;
+    }
+  }
+  /**
+   * Finalize worktree info with defaults
+   */
+  finalizeWorktreeInfo(partial) {
+    return {
+      path: partial.path || "",
+      branch: partial.branch || "detached",
+      commit: partial.commit || "",
+      isMainWorktree: partial.isMainWorktree || false,
+      isBare: partial.isBare || false,
+      isDetached: partial.isDetached || false,
+      linkedPath: partial.linkedPath,
+      contextId: this.generateContextId(
+        partial.path || "",
+        partial.branch || ""
+      )
+    };
+  }
+  /**
+   * Generate unique context ID for worktree
+   */
+  generateContextId(path, branch) {
+    const repoName = basename(dirname(path));
+    const sanitizedBranch = branch.replace(/[^a-zA-Z0-9-]/g, "_");
+    return `${repoName}-${sanitizedBranch}-${Buffer.from(path).toString("base64").substring(0, 8)}`;
+  }
+  /**
+   * Save worktree to database
+   */
+  async saveWorktree(worktree) {
+    if (!this.db) return;
+    const projectManager = ProjectManager.getInstance();
+    const project = await projectManager.detectProject(worktree.path);
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO worktrees 
+      (id, path, branch, commit, is_main, is_bare, is_detached, linked_path, context_id, project_id, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+    `);
+    stmt.run(
+      worktree.contextId,
+      worktree.path,
+      worktree.branch,
+      worktree.commit,
+      worktree.isMainWorktree ? 1 : 0,
+      worktree.isBare ? 1 : 0,
+      worktree.isDetached ? 1 : 0,
+      worktree.linkedPath,
+      worktree.contextId,
+      project.id
+    );
+  }
+  /**
+   * Get or create context for worktree
+   */
+  getWorktreeContext(worktreePath) {
+    const cached = this.contextMap.get(worktreePath);
+    if (cached) {
+      return cached;
+    }
+    const worktree = this.worktreeCache.get(worktreePath) || this.detectWorktrees(worktreePath).find(
+      (w) => w.path === worktreePath
+    );
+    if (!worktree) {
+      throw new Error(`No worktree found at path: ${worktreePath}`);
+    }
+    const contextBasePath = this.config.isolateContexts ? join(homedir(), ".stackmemory", "worktrees", worktree.contextId) : join(worktreePath, ".stackmemory");
+    if (!existsSync(contextBasePath)) {
+      mkdirSync(contextBasePath, { recursive: true });
+    }
+    const context = {
+      worktreeId: worktree.contextId,
+      projectId: "",
+      // Will be filled by project manager
+      branch: worktree.branch,
+      contextPath: contextBasePath,
+      dbPath: join(contextBasePath, "context.db"),
+      lastSynced: /* @__PURE__ */ new Date(),
+      metadata: {
+        isMainWorktree: worktree.isMainWorktree,
+        linkedPath: worktree.linkedPath
+      }
+    };
+    if (this.db && this.config.enabled) {
+      this.saveContext(context);
+    }
+    this.contextMap.set(worktreePath, context);
+    logger.info("Created worktree context", {
+      worktree: worktree.branch,
+      path: contextBasePath
+    });
+    return context;
+  }
+  /**
+   * Save context to database
+   */
+  saveContext(context) {
+    if (!this.db) return;
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO worktree_contexts
+      (context_id, worktree_id, project_id, branch, context_path, db_path, last_synced, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      context.worktreeId,
+      context.worktreeId,
+      context.projectId,
+      context.branch,
+      context.contextPath,
+      context.dbPath,
+      context.lastSynced.toISOString(),
+      JSON.stringify(context.metadata)
+    );
+  }
+  /**
+   * Sync contexts between worktrees
+   */
+  async syncContexts(sourceWorktree, targetWorktree, syncType = "merge") {
+    const source = this.getWorktreeContext(sourceWorktree);
+    const target = this.getWorktreeContext(targetWorktree);
+    logger.info("Syncing contexts between worktrees", {
+      source: source.branch,
+      target: target.branch,
+      type: syncType
+    });
+    const sourceDb = new Database(source.dbPath);
+    const targetDb = new Database(target.dbPath);
+    try {
+      const contexts = sourceDb.prepare(
+        `
+        SELECT * FROM contexts 
+        WHERE created_at > datetime('now', '-7 days')
+        ORDER BY created_at DESC
+      `
+      ).all();
+      if (syncType === "push" || syncType === "merge") {
+        this.mergeContexts(contexts, targetDb, syncType === "merge");
+      }
+      if (syncType === "pull") {
+        const targetContexts = targetDb.prepare(
+          `
+          SELECT * FROM contexts 
+          WHERE created_at > datetime('now', '-7 days')
+          ORDER BY created_at DESC
+        `
+        ).all();
+        this.mergeContexts(targetContexts, sourceDb, false);
+      }
+      if (this.db) {
+        const stmt = this.db.prepare(`
+          INSERT INTO context_sync (source_context, target_context, sync_type, data)
+          VALUES (?, ?, ?, ?)
+        `);
+        stmt.run(
+          source.worktreeId,
+          target.worktreeId,
+          syncType,
+          JSON.stringify({ count: contexts.length })
+        );
+      }
+      logger.info("Context sync completed", {
+        synced: contexts.length,
+        type: syncType
+      });
+    } finally {
+      sourceDb.close();
+      targetDb.close();
+    }
+  }
+  /**
+   * Merge contexts into target database
+   */
+  mergeContexts(contexts, targetDb, bidirectional) {
+    const stmt = targetDb.prepare(`
+      INSERT OR REPLACE INTO contexts (id, type, content, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    for (const ctx of contexts) {
+      try {
+        stmt.run(ctx.id, ctx.type, ctx.content, ctx.metadata, ctx.created_at);
+      } catch (error) {
+        logger.warn("Failed to merge context", { id: ctx.id, error });
+      }
+    }
+  }
+  /**
+   * List all active worktrees
+   */
+  listActiveWorktrees() {
+    if (!this.db) {
+      return Array.from(this.worktreeCache.values());
+    }
+    const stmt = this.db.prepare(`
+      SELECT * FROM worktrees
+      ORDER BY is_main DESC, branch ASC
+    `);
+    const rows = stmt.all();
+    return rows.map((row) => ({
+      path: row.path,
+      branch: row.branch,
+      commit: row.commit,
+      isMainWorktree: row.is_main === 1,
+      isBare: row.is_bare === 1,
+      isDetached: row.is_detached === 1,
+      linkedPath: row.linked_path,
+      contextId: row.context_id
+    }));
+  }
+  /**
+   * Clean up stale worktree contexts
+   */
+  cleanupStaleContexts() {
+    if (!this.db) return;
+    const activeWorktrees = this.detectWorktrees();
+    const activePaths = new Set(activeWorktrees.map((w) => w.path));
+    const stmt = this.db.prepare("SELECT * FROM worktrees");
+    const stored = stmt.all();
+    const deleteStmt = this.db.prepare("DELETE FROM worktrees WHERE id = ?");
+    const deleteContextStmt = this.db.prepare(
+      "DELETE FROM worktree_contexts WHERE worktree_id = ?"
+    );
+    for (const worktree of stored) {
+      if (!activePaths.has(worktree.path)) {
+        deleteStmt.run(worktree.id);
+        deleteContextStmt.run(worktree.id);
+        logger.info("Cleaned up stale worktree context", {
+          path: worktree.path,
+          branch: worktree.branch
+        });
+      }
+    }
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Check if worktree support is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Enable or disable worktree support
+   */
+  setEnabled(enabled) {
+    this.saveConfig({ enabled });
+  }
+}
+export {
+  WorktreeManager
+};
+//# sourceMappingURL=worktree-manager.js.map

package/dist/src/core/worktree/worktree-manager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/worktree/worktree-manager.ts"],
+  "sourcesContent": ["/**\n * Git Worktree Manager for StackMemory\n * Manages multiple instances across git worktrees with context isolation\n */\n\nimport { execSync } from 'child_process';\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\nimport { join, basename, dirname, resolve } from 'path';\nimport { homedir } from 'os';\nimport Database from 'better-sqlite3';\nimport { logger } from '../monitoring/logger.js';\nimport { ProjectManager } from '../projects/project-manager.js';\nimport {\n  DatabaseError,\n  SystemError,\n  ErrorCode,\n  createErrorHandler,\n} from '../errors/index.js';\nimport { retry } from '../errors/recovery.js';\n\nexport interface WorktreeInfo {\n  path: string;\n  branch: string;\n  commit: string;\n  isMainWorktree: boolean;\n  isBare: boolean;\n  isDetached: boolean;\n  linkedPath?: string; // Path to main worktree\n  contextId: string; // Unique context identifier\n}\n\nexport interface WorktreeConfig {\n  enabled: boolean;\n  autoDetect: boolean;\n  isolateContexts: boolean;\n  shareGlobalContext: boolean;\n  syncInterval?: number; // Minutes between syncs\n  maxWorktrees?: number;\n}\n\nexport interface WorktreeContext {\n  worktreeId: string;\n  projectId: string;\n  branch: string;\n  contextPath: string;\n  dbPath: string;\n  lastSynced: Date;\n  metadata: Record<string, any>;\n}\n\nexport class WorktreeManager {\n  private static instance: WorktreeManager;\n  private config: WorktreeConfig;\n  private configPath: string;\n  private worktreeCache: Map<string, WorktreeInfo> = new Map();\n  private contextMap: Map<string, WorktreeContext> = new Map();\n  private db?: Database.Database;\n\n  private constructor() {\n    this.configPath = join(homedir(), '.stackmemory', 'worktree-config.json');\n    this.config = this.loadConfig();\n\n    try {\n      if (this.config.enabled) {\n        this.initialize();\n      }\n    } catch (error: unknown) {\n      logger.error(\n        'Failed to initialize WorktreeManager',\n        error instanceof Error ? error : new Error(String(error)),\n        {\n          configPath: this.configPath,\n        }\n      );\n      // Don't throw here - allow the manager to be created without worktree support\n      this.config.enabled = false;\n    }\n  }\n\n  static getInstance(): WorktreeManager {\n    if (!WorktreeManager.instance) {\n      WorktreeManager.instance = new WorktreeManager();\n    }\n    return WorktreeManager.instance;\n  }\n\n  /**\n   * Initialize worktree management\n   */\n  private initialize(): void {\n    const dbPath = join(homedir(), '.stackmemory', 'worktrees.db');\n    const errorHandler = createErrorHandler({\n      operation: 'initialize',\n      dbPath,\n    });\n\n    try {\n      this.db = new Database(dbPath);\n\n      this.db.exec(`\n        CREATE TABLE IF NOT EXISTS worktrees (\n          id TEXT PRIMARY KEY,\n          path TEXT NOT NULL UNIQUE,\n          branch TEXT NOT NULL,\n          commit TEXT,\n          is_main BOOLEAN,\n          is_bare BOOLEAN,\n          is_detached BOOLEAN,\n          linked_path TEXT,\n          context_id TEXT UNIQUE,\n          project_id TEXT,\n          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP\n        );\n\n        CREATE TABLE IF NOT EXISTS worktree_contexts (\n          context_id TEXT PRIMARY KEY,\n          worktree_id TEXT NOT NULL,\n          project_id TEXT,\n          branch TEXT,\n          context_path TEXT,\n          db_path TEXT,\n          last_synced DATETIME,\n          metadata JSON,\n          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n        FOREIGN KEY (worktree_id) REFERENCES worktrees(id)\n      );\n\n      CREATE TABLE IF NOT EXISTS context_sync (\n        id INTEGER PRIMARY KEY AUTOINCREMENT,\n        source_context TEXT,\n        target_context TEXT,\n        sync_type TEXT, -- 'push', 'pull', 'merge'\n        data JSON,\n        synced_at DATETIME DEFAULT CURRENT_TIMESTAMP\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_worktrees_project ON worktrees(project_id);\n      CREATE INDEX IF NOT EXISTS idx_contexts_worktree ON worktree_contexts(worktree_id);\n    `);\n    } catch (error: unknown) {\n      errorHandler(error);\n    }\n  }\n\n  /**\n   * Load configuration\n   */\n  private loadConfig(): WorktreeConfig {\n    if (existsSync(this.configPath)) {\n      try {\n        return JSON.parse(readFileSync(this.configPath, 'utf-8'));\n      } catch (error: unknown) {\n        logger.error('Failed to load worktree config', error as Error);\n      }\n    }\n\n    // Default config\n    return {\n      enabled: false,\n      autoDetect: true,\n      isolateContexts: true,\n      shareGlobalContext: false,\n      syncInterval: 15,\n      maxWorktrees: 10,\n    };\n  }\n\n  /**\n   * Save configuration\n   */\n  saveConfig(config: Partial<WorktreeConfig>): void {\n    this.config = { ...this.config, ...config };\n\n    const configDir = dirname(this.configPath);\n    if (!existsSync(configDir)) {\n      mkdirSync(configDir, { recursive: true });\n    }\n\n    writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));\n\n    // Reinitialize if just enabled\n    if (config.enabled && !this.db) {\n      this.initialize();\n    }\n\n    logger.info('Worktree configuration updated', { config: this.config });\n  }\n\n  /**\n   * Detect git worktrees in current repository\n   */\n  detectWorktrees(repoPath?: string): WorktreeInfo[] {\n    const path = repoPath || process.cwd();\n\n    try {\n      // Get worktree list\n      const output = execSync('git worktree list --porcelain', {\n        cwd: path,\n        encoding: 'utf-8',\n      });\n\n      const worktrees: WorktreeInfo[] = [];\n      const lines = output.split('\\n');\n      let currentWorktree: Partial<WorktreeInfo> = {};\n\n      for (const line of lines) {\n        if (line.startsWith('worktree ')) {\n          if (currentWorktree.path) {\n            worktrees.push(this.finalizeWorktreeInfo(currentWorktree));\n          }\n          currentWorktree = { path: line.substring(9) };\n        } else if (line.startsWith('HEAD ')) {\n          currentWorktree.commit = line.substring(5);\n        } else if (line.startsWith('branch ')) {\n          currentWorktree.branch = line.substring(7);\n        } else if (line === 'bare') {\n          currentWorktree.isBare = true;\n        } else if (line === 'detached') {\n          currentWorktree.isDetached = true;\n        }\n      }\n\n      // Add last worktree\n      if (currentWorktree.path) {\n        worktrees.push(this.finalizeWorktreeInfo(currentWorktree));\n      }\n\n      // Determine main worktree\n      if (worktrees.length > 0) {\n        const mainPath = this.getMainWorktreePath(path);\n        worktrees.forEach((wt) => {\n          wt.isMainWorktree = wt.path === mainPath;\n          if (!wt.isMainWorktree) {\n            wt.linkedPath = mainPath;\n          }\n        });\n      }\n\n      // Cache results\n      worktrees.forEach((wt) => {\n        this.worktreeCache.set(wt.path, wt);\n        if (this.config.enabled) {\n          this.saveWorktree(wt);\n        }\n      });\n\n      logger.info(`Detected ${worktrees.length} worktrees`, {\n        count: worktrees.length,\n        branches: worktrees.map((w: any) => w.branch).filter(Boolean),\n      });\n\n      return worktrees;\n    } catch (error: unknown) {\n      logger.debug('Not a git repository or git worktree not available');\n      return [];\n    }\n  }\n\n  /**\n   * Get main worktree path\n   */\n  private getMainWorktreePath(path: string): string {\n    try {\n      const gitDir = execSync('git rev-parse --git-common-dir', {\n        cwd: path,\n        encoding: 'utf-8',\n      }).trim();\n\n      // If it's a worktree, find the main repo\n      if (gitDir.includes('/.git/worktrees/')) {\n        const mainGitDir = gitDir.replace(/\\/\\.git\\/worktrees\\/.*$/, '');\n        return mainGitDir;\n      }\n\n      // It's the main worktree\n      return dirname(gitDir);\n    } catch {\n      return path;\n    }\n  }\n\n  /**\n   * Finalize worktree info with defaults\n   */\n  private finalizeWorktreeInfo(partial: Partial<WorktreeInfo>): WorktreeInfo {\n    return {\n      path: partial.path || '',\n      branch: partial.branch || 'detached',\n      commit: partial.commit || '',\n      isMainWorktree: partial.isMainWorktree || false,\n      isBare: partial.isBare || false,\n      isDetached: partial.isDetached || false,\n      linkedPath: partial.linkedPath,\n      contextId: this.generateContextId(\n        partial.path || '',\n        partial.branch || ''\n      ),\n    };\n  }\n\n  /**\n   * Generate unique context ID for worktree\n   */\n  private generateContextId(path: string, branch: string): string {\n    const repoName = basename(dirname(path));\n    const sanitizedBranch = branch.replace(/[^a-zA-Z0-9-]/g, '_');\n    return `${repoName}-${sanitizedBranch}-${Buffer.from(path).toString('base64').substring(0, 8)}`;\n  }\n\n  /**\n   * Save worktree to database\n   */\n  private async saveWorktree(worktree: WorktreeInfo): Promise<void> {\n    if (!this.db) return;\n\n    const projectManager = ProjectManager.getInstance();\n    const project = await projectManager.detectProject(worktree.path);\n\n    const stmt = this.db.prepare(`\n      INSERT OR REPLACE INTO worktrees \n      (id, path, branch, commit, is_main, is_bare, is_detached, linked_path, context_id, project_id, updated_at)\n      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)\n    `);\n\n    stmt.run(\n      worktree.contextId,\n      worktree.path,\n      worktree.branch,\n      worktree.commit,\n      worktree.isMainWorktree ? 1 : 0,\n      worktree.isBare ? 1 : 0,\n      worktree.isDetached ? 1 : 0,\n      worktree.linkedPath,\n      worktree.contextId,\n      project.id\n    );\n  }\n\n  /**\n   * Get or create context for worktree\n   */\n  getWorktreeContext(worktreePath: string): WorktreeContext {\n    // Check cache\n    const cached = this.contextMap.get(worktreePath);\n    if (cached) {\n      return cached;\n    }\n\n    const worktree =\n      this.worktreeCache.get(worktreePath) ||\n      this.detectWorktrees(worktreePath).find(\n        (w: any) => w.path === worktreePath\n      );\n\n    if (!worktree) {\n      throw new Error(`No worktree found at path: ${worktreePath}`);\n    }\n\n    // Create isolated context path\n    const contextBasePath = this.config.isolateContexts\n      ? join(homedir(), '.stackmemory', 'worktrees', worktree.contextId)\n      : join(worktreePath, '.stackmemory');\n\n    // Ensure directory exists\n    if (!existsSync(contextBasePath)) {\n      mkdirSync(contextBasePath, { recursive: true });\n    }\n\n    const context: WorktreeContext = {\n      worktreeId: worktree.contextId,\n      projectId: '', // Will be filled by project manager\n      branch: worktree.branch,\n      contextPath: contextBasePath,\n      dbPath: join(contextBasePath, 'context.db'),\n      lastSynced: new Date(),\n      metadata: {\n        isMainWorktree: worktree.isMainWorktree,\n        linkedPath: worktree.linkedPath,\n      },\n    };\n\n    // Save to database\n    if (this.db && this.config.enabled) {\n      this.saveContext(context);\n    }\n\n    // Cache it\n    this.contextMap.set(worktreePath, context);\n\n    logger.info('Created worktree context', {\n      worktree: worktree.branch,\n      path: contextBasePath,\n    });\n\n    return context;\n  }\n\n  /**\n   * Save context to database\n   */\n  private saveContext(context: WorktreeContext): void {\n    if (!this.db) return;\n\n    const stmt = this.db.prepare(`\n      INSERT OR REPLACE INTO worktree_contexts\n      (context_id, worktree_id, project_id, branch, context_path, db_path, last_synced, metadata)\n      VALUES (?, ?, ?, ?, ?, ?, ?, ?)\n    `);\n\n    stmt.run(\n      context.worktreeId,\n      context.worktreeId,\n      context.projectId,\n      context.branch,\n      context.contextPath,\n      context.dbPath,\n      context.lastSynced.toISOString(),\n      JSON.stringify(context.metadata)\n    );\n  }\n\n  /**\n   * Sync contexts between worktrees\n   */\n  async syncContexts(\n    sourceWorktree: string,\n    targetWorktree: string,\n    syncType: 'push' | 'pull' | 'merge' = 'merge'\n  ): Promise<void> {\n    const source = this.getWorktreeContext(sourceWorktree);\n    const target = this.getWorktreeContext(targetWorktree);\n\n    logger.info('Syncing contexts between worktrees', {\n      source: source.branch,\n      target: target.branch,\n      type: syncType,\n    });\n\n    // Open both databases\n    const sourceDb = new Database(source.dbPath);\n    const targetDb = new Database(target.dbPath);\n\n    try {\n      // Get contexts from source\n      const contexts = sourceDb\n        .prepare(\n          `\n        SELECT * FROM contexts \n        WHERE created_at > datetime('now', '-7 days')\n        ORDER BY created_at DESC\n      `\n        )\n        .all();\n\n      // Sync based on type\n      if (syncType === 'push' || syncType === 'merge') {\n        this.mergeContexts(contexts, targetDb, syncType === 'merge');\n      }\n\n      if (syncType === 'pull') {\n        const targetContexts = targetDb\n          .prepare(\n            `\n          SELECT * FROM contexts \n          WHERE created_at > datetime('now', '-7 days')\n          ORDER BY created_at DESC\n        `\n          )\n          .all();\n\n        this.mergeContexts(targetContexts, sourceDb, false);\n      }\n\n      // Log sync operation\n      if (this.db) {\n        const stmt = this.db.prepare(`\n          INSERT INTO context_sync (source_context, target_context, sync_type, data)\n          VALUES (?, ?, ?, ?)\n        `);\n\n        stmt.run(\n          source.worktreeId,\n          target.worktreeId,\n          syncType,\n          JSON.stringify({ count: contexts.length })\n        );\n      }\n\n      logger.info('Context sync completed', {\n        synced: contexts.length,\n        type: syncType,\n      });\n    } finally {\n      sourceDb.close();\n      targetDb.close();\n    }\n  }\n\n  /**\n   * Merge contexts into target database\n   */\n  private mergeContexts(\n    contexts: any[],\n    targetDb: Database.Database,\n    bidirectional: boolean\n  ): void {\n    const stmt = targetDb.prepare(`\n      INSERT OR REPLACE INTO contexts (id, type, content, metadata, created_at)\n      VALUES (?, ?, ?, ?, ?)\n    `);\n\n    for (const ctx of contexts) {\n      try {\n        stmt.run(ctx.id, ctx.type, ctx.content, ctx.metadata, ctx.created_at);\n      } catch (error: unknown) {\n        logger.warn('Failed to merge context', { id: ctx.id, error });\n      }\n    }\n  }\n\n  /**\n   * List all active worktrees\n   */\n  listActiveWorktrees(): WorktreeInfo[] {\n    if (!this.db) {\n      return Array.from(this.worktreeCache.values());\n    }\n\n    const stmt = this.db.prepare(`\n      SELECT * FROM worktrees\n      ORDER BY is_main DESC, branch ASC\n    `);\n\n    const rows = stmt.all() as any[];\n\n    return rows.map((row: any) => ({\n      path: row.path,\n      branch: row.branch,\n      commit: row.commit,\n      isMainWorktree: row.is_main === 1,\n      isBare: row.is_bare === 1,\n      isDetached: row.is_detached === 1,\n      linkedPath: row.linked_path,\n      contextId: row.context_id,\n    }));\n  }\n\n  /**\n   * Clean up stale worktree contexts\n   */\n  cleanupStaleContexts(): void {\n    if (!this.db) return;\n\n    const activeWorktrees = this.detectWorktrees();\n    const activePaths = new Set(activeWorktrees.map((w: any) => w.path));\n\n    // Get all stored worktrees\n    const stmt = this.db.prepare('SELECT * FROM worktrees');\n    const stored = stmt.all() as any[];\n\n    // Remove stale entries\n    const deleteStmt = this.db.prepare('DELETE FROM worktrees WHERE id = ?');\n    const deleteContextStmt = this.db.prepare(\n      'DELETE FROM worktree_contexts WHERE worktree_id = ?'\n    );\n\n    for (const worktree of stored) {\n      if (!activePaths.has(worktree.path)) {\n        deleteStmt.run(worktree.id);\n        deleteContextStmt.run(worktree.id);\n\n        logger.info('Cleaned up stale worktree context', {\n          path: worktree.path,\n          branch: worktree.branch,\n        });\n      }\n    }\n  }\n\n  /**\n   * Get configuration\n   */\n  getConfig(): WorktreeConfig {\n    return { ...this.config };\n  }\n\n  /**\n   * Check if worktree support is enabled\n   */\n  isEnabled(): boolean {\n    return this.config.enabled;\n  }\n\n  /**\n   * Enable or disable worktree support\n   */\n  setEnabled(enabled: boolean): void {\n    this.saveConfig({ enabled });\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,149 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const DEFAULT_DAEMON_CONFIG = {
+  version: "1.0.0",
+  context: {
+    enabled: true,
+    interval: 15,
+    // 15 minutes
+    checkpointMessage: "Auto-checkpoint"
+  },
+  linear: {
+    enabled: false,
+    // Disabled by default, requires setup
+    interval: 60,
+    // 60 minutes
+    quietHours: { start: 22, end: 7 },
+    retryAttempts: 3,
+    retryDelay: 3e4
+  },
+  fileWatch: {
+    enabled: false,
+    // Disabled by default
+    interval: 0,
+    // Not interval-based
+    paths: ["."],
+    extensions: [".ts", ".js", ".tsx", ".jsx", ".py", ".go", ".rs"],
+    ignore: ["node_modules", ".git", "dist", "build", ".stackmemory"],
+    debounceMs: 2e3
+  },
+  heartbeatInterval: 60,
+  // 1 minute
+  inactivityTimeout: 0,
+  // Disabled by default
+  logLevel: "info"
+};
+function getDaemonDir() {
+  const dir = join(homedir(), ".stackmemory", "daemon");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getLogsDir() {
+  const dir = join(homedir(), ".stackmemory", "logs");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getDaemonPaths() {
+  const daemonDir = getDaemonDir();
+  const logsDir = getLogsDir();
+  return {
+    pidFile: join(daemonDir, "daemon.pid"),
+    statusFile: join(daemonDir, "daemon.status"),
+    configFile: join(daemonDir, "config.json"),
+    logFile: join(logsDir, "daemon.log")
+  };
+}
+function loadDaemonConfig() {
+  const { configFile } = getDaemonPaths();
+  if (!existsSync(configFile)) {
+    return { ...DEFAULT_DAEMON_CONFIG };
+  }
+  try {
+    const content = readFileSync(configFile, "utf8");
+    const config = JSON.parse(content);
+    return {
+      ...DEFAULT_DAEMON_CONFIG,
+      ...config,
+      context: { ...DEFAULT_DAEMON_CONFIG.context, ...config.context },
+      linear: { ...DEFAULT_DAEMON_CONFIG.linear, ...config.linear },
+      fileWatch: { ...DEFAULT_DAEMON_CONFIG.fileWatch, ...config.fileWatch }
+    };
+  } catch {
+    return { ...DEFAULT_DAEMON_CONFIG };
+  }
+}
+function saveDaemonConfig(config) {
+  const { configFile } = getDaemonPaths();
+  const currentConfig = loadDaemonConfig();
+  const newConfig = {
+    ...currentConfig,
+    ...config,
+    context: { ...currentConfig.context, ...config.context },
+    linear: { ...currentConfig.linear, ...config.linear },
+    fileWatch: { ...currentConfig.fileWatch, ...config.fileWatch }
+  };
+  writeFileSync(configFile, JSON.stringify(newConfig, null, 2));
+}
+function readDaemonStatus() {
+  const { statusFile, pidFile } = getDaemonPaths();
+  const defaultStatus = {
+    running: false,
+    services: {
+      context: { enabled: false },
+      linear: { enabled: false },
+      fileWatch: { enabled: false }
+    },
+    errors: []
+  };
+  if (!existsSync(pidFile)) {
+    return defaultStatus;
+  }
+  try {
+    const pidContent = readFileSync(pidFile, "utf8").trim();
+    const pid = parseInt(pidContent, 10);
+    try {
+      process.kill(pid, 0);
+    } catch {
+      return defaultStatus;
+    }
+    if (!existsSync(statusFile)) {
+      return { ...defaultStatus, running: true, pid };
+    }
+    const content = readFileSync(statusFile, "utf8");
+    const status = JSON.parse(content);
+    return {
+      ...status,
+      running: true,
+      pid,
+      uptime: status.startTime ? Date.now() - status.startTime : void 0
+    };
+  } catch {
+    return defaultStatus;
+  }
+}
+function writeDaemonStatus(status) {
+  const { statusFile } = getDaemonPaths();
+  const currentStatus = readDaemonStatus();
+  const newStatus = { ...currentStatus, ...status };
+  writeFileSync(statusFile, JSON.stringify(newStatus, null, 2));
+}
+export {
+  DEFAULT_DAEMON_CONFIG,
+  getDaemonDir,
+  getDaemonPaths,
+  getLogsDir,
+  loadDaemonConfig,
+  readDaemonStatus,
+  saveDaemonConfig,
+  writeDaemonStatus
+};
+//# sourceMappingURL=daemon-config.js.map