@stackmemoryai/stackmemory 0.2.9 → 0.3.0

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

@@ -0,0 +1,214 @@
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { logger } from "../monitoring/logger.js";
+import {
+  ErrorCode,
+  getErrorMessage,
+  wrapError
+} from "../errors/index.js";
+import { withTimeout, gracefulDegrade } from "../errors/recovery.js";
+class UpdateChecker {
+  static CACHE_FILE = join(
+    homedir(),
+    ".stackmemory",
+    "update-check.json"
+  );
+  static CHECK_INTERVAL = 24 * 60 * 60 * 1e3;
+  // 24 hours
+  static PACKAGE_NAME = "@stackmemoryai/stackmemory";
+  /**
+   * Check for updates and display notification if needed
+   */
+  static async checkForUpdates(currentVersion, silent = false) {
+    try {
+      const cache = this.loadCache();
+      const now = Date.now();
+      if (cache && now - cache.lastChecked < this.CHECK_INTERVAL) {
+        if (!silent && cache.latestVersion && cache.latestVersion !== currentVersion) {
+          this.displayUpdateNotification(currentVersion, cache.latestVersion);
+        }
+        return;
+      }
+      const latestVersion = await this.fetchLatestVersion();
+      this.saveCache({
+        lastChecked: now,
+        latestVersion,
+        currentVersion
+      });
+      if (!silent && latestVersion && this.isNewerVersion(currentVersion, latestVersion)) {
+        this.displayUpdateNotification(currentVersion, latestVersion);
+      }
+    } catch (error) {
+      const wrappedError = wrapError(
+        error,
+        "Update check failed",
+        ErrorCode.INTERNAL_ERROR,
+        { currentVersion, silent }
+      );
+      logger.debug("Update check failed:", {
+        error: getErrorMessage(error),
+        context: wrappedError.context
+      });
+    }
+  }
+  /**
+   * Fetch latest version from npm registry
+   */
+  static async fetchLatestVersion() {
+    try {
+      const fetchVersion = async () => {
+        const output = execSync(`npm view ${this.PACKAGE_NAME} version`, {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"],
+          timeout: 5e3
+          // 5 second timeout
+        }).trim();
+        return output;
+      };
+      return await gracefulDegrade(
+        () => withTimeout(fetchVersion, 5e3, "npm registry timeout"),
+        "",
+        { operation: "fetchLatestVersion", package: this.PACKAGE_NAME }
+      );
+    } catch (error) {
+      const wrappedError = wrapError(
+        error,
+        "Failed to fetch latest version from npm",
+        ErrorCode.SERVICE_UNAVAILABLE,
+        { package: this.PACKAGE_NAME }
+      );
+      logger.debug("Failed to fetch latest version:", {
+        error: getErrorMessage(error),
+        context: wrappedError.context
+      });
+      return "";
+    }
+  }
+  /**
+   * Compare version strings
+   */
+  static isNewerVersion(current, latest) {
+    try {
+      const currentParts = current.split(".").map(Number);
+      const latestParts = latest.split(".").map(Number);
+      if (currentParts.some(isNaN) || latestParts.some(isNaN)) {
+        logger.debug("Invalid version format:", { current, latest });
+        return false;
+      }
+      for (let i = 0; i < 3; i++) {
+        const latestPart = latestParts[i] ?? 0;
+        const currentPart = currentParts[i] ?? 0;
+        if (latestPart > currentPart) return true;
+        if (latestPart < currentPart) return false;
+      }
+      return false;
+    } catch (error) {
+      logger.debug("Version comparison failed:", {
+        error: getErrorMessage(error),
+        current,
+        latest
+      });
+      return false;
+    }
+  }
+  /**
+   * Display update notification
+   */
+  static displayUpdateNotification(current, latest) {
+    console.log("\n" + "\u2500".repeat(60));
+    console.log("\u{1F4E6} StackMemory Update Available!");
+    console.log(`   Current: v${current}`);
+    console.log(`   Latest:  v${latest}`);
+    console.log("\n   Update with:");
+    console.log("   npm install -g @stackmemoryai/stackmemory@latest");
+    console.log("\u2500".repeat(60) + "\n");
+  }
+  /**
+   * Load update cache
+   */
+  static loadCache() {
+    try {
+      if (!existsSync(this.CACHE_FILE)) {
+        return null;
+      }
+      const data = readFileSync(this.CACHE_FILE, "utf-8");
+      const cache = JSON.parse(data);
+      if (typeof cache.lastChecked !== "number" || typeof cache.latestVersion !== "string" || typeof cache.currentVersion !== "string") {
+        logger.debug("Invalid cache format, ignoring");
+        return null;
+      }
+      return cache;
+    } catch (error) {
+      const wrappedError = wrapError(
+        error,
+        "Failed to load update cache",
+        ErrorCode.INTERNAL_ERROR,
+        { cacheFile: this.CACHE_FILE }
+      );
+      logger.debug("Failed to load update cache:", {
+        error: getErrorMessage(error),
+        context: wrappedError.context
+      });
+      return null;
+    }
+  }
+  /**
+   * Save update cache
+   */
+  static saveCache(cache) {
+    try {
+      const dir = join(homedir(), ".stackmemory");
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 493 });
+      }
+      const tempFile = `${this.CACHE_FILE}.tmp`;
+      writeFileSync(tempFile, JSON.stringify(cache, null, 2), {
+        mode: 420
+      });
+      if (existsSync(this.CACHE_FILE)) {
+        writeFileSync(this.CACHE_FILE, JSON.stringify(cache, null, 2));
+      } else {
+        writeFileSync(this.CACHE_FILE, JSON.stringify(cache, null, 2));
+      }
+    } catch (error) {
+      const wrappedError = wrapError(
+        error,
+        "Failed to save update cache",
+        ErrorCode.INTERNAL_ERROR,
+        { cacheFile: this.CACHE_FILE, cache }
+      );
+      logger.debug("Failed to save update cache:", {
+        error: getErrorMessage(error),
+        context: wrappedError.context
+      });
+    }
+  }
+  /**
+   * Force check for updates (ignores cache)
+   */
+  static async forceCheck(currentVersion) {
+    try {
+      const latestVersion = await this.fetchLatestVersion();
+      this.saveCache({
+        lastChecked: Date.now(),
+        latestVersion,
+        currentVersion
+      });
+      if (latestVersion) {
+        if (this.isNewerVersion(currentVersion, latestVersion)) {
+          this.displayUpdateNotification(currentVersion, latestVersion);
+        } else {
+          console.log(`\u2705 StackMemory is up to date (v${currentVersion})`);
+        }
+      }
+    } catch (error) {
+      console.error("\u274C Update check failed:", error.message);
+    }
+  }
+}
+export {
+  UpdateChecker
+};
+//# sourceMappingURL=update-checker.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/utils/update-checker.ts"],
+  "sourcesContent": ["/**\n * Update checker for StackMemory\n * Checks npm registry for newer versions\n */\n\nimport { execSync } from 'child_process';\nimport { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';\nimport { join } from 'path';\nimport { homedir } from 'os';\nimport { logger } from '../monitoring/logger.js';\nimport { \n  SystemError, \n  ErrorCode, \n  getErrorMessage,\n  wrapError\n} from '../errors/index.js';\nimport { withTimeout, gracefulDegrade } from '../errors/recovery.js';\n\ninterface UpdateCache {\n  lastChecked: number;\n  latestVersion: string;\n  currentVersion: string;\n}\n\nexport class UpdateChecker {\n  private static CACHE_FILE = join(\n    homedir(),\n    '.stackmemory',\n    'update-check.json'\n  );\n  private static CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours\n  private static PACKAGE_NAME = '@stackmemoryai/stackmemory';\n\n  /**\n   * Check for updates and display notification if needed\n   */\n  static async checkForUpdates(\n    currentVersion: string,\n    silent = false\n  ): Promise<void> {\n    try {\n      // Check cache first\n      const cache = this.loadCache();\n      const now = Date.now();\n\n      // Skip check if we checked recently\n      if (cache && now - cache.lastChecked < this.CHECK_INTERVAL) {\n        if (\n          !silent &&\n          cache.latestVersion &&\n          cache.latestVersion !== currentVersion\n        ) {\n          this.displayUpdateNotification(currentVersion, cache.latestVersion);\n        }\n        return;\n      }\n\n      // Fetch latest version from npm\n      const latestVersion = await this.fetchLatestVersion();\n\n      // Update cache\n      this.saveCache({\n        lastChecked: now,\n        latestVersion,\n        currentVersion,\n      });\n\n      // Display notification if update available\n      if (\n        !silent &&\n        latestVersion &&\n        this.isNewerVersion(currentVersion, latestVersion)\n      ) {\n        this.displayUpdateNotification(currentVersion, latestVersion);\n      }\n    } catch (error) {\n      // Log the error with proper context but don't interrupt user workflow\n      const wrappedError = wrapError(\n        error,\n        'Update check failed',\n        ErrorCode.INTERNAL_ERROR,\n        { currentVersion, silent }\n      );\n      logger.debug('Update check failed:', { \n        error: getErrorMessage(error),\n        context: wrappedError.context \n      });\n    }\n  }\n\n  /**\n   * Fetch latest version from npm registry\n   */\n  private static async fetchLatestVersion(): Promise<string> {\n    try {\n      // Use timeout to prevent hanging on slow network\n      const fetchVersion = async () => {\n        const output = execSync(`npm view ${this.PACKAGE_NAME} version`, {\n          encoding: 'utf-8',\n          stdio: ['pipe', 'pipe', 'ignore'],\n          timeout: 5000, // 5 second timeout\n        }).trim();\n        return output;\n      };\n\n      // Wrap with timeout and graceful degradation\n      return await gracefulDegrade(\n        () => withTimeout(fetchVersion, 5000, 'npm registry timeout'),\n        '',\n        { operation: 'fetchLatestVersion', package: this.PACKAGE_NAME }\n      );\n    } catch (error) {\n      const wrappedError = wrapError(\n        error,\n        'Failed to fetch latest version from npm',\n        ErrorCode.SERVICE_UNAVAILABLE,\n        { package: this.PACKAGE_NAME }\n      );\n      logger.debug('Failed to fetch latest version:', {\n        error: getErrorMessage(error),\n        context: wrappedError.context,\n      });\n      return '';\n    }\n  }\n\n  /**\n   * Compare version strings\n   */\n  private static isNewerVersion(current: string, latest: string): boolean {\n    try {\n      const currentParts = current.split('.').map(Number);\n      const latestParts = latest.split('.').map(Number);\n\n      // Handle malformed version strings\n      if (currentParts.some(isNaN) || latestParts.some(isNaN)) {\n        logger.debug('Invalid version format:', { current, latest });\n        return false;\n      }\n\n      for (let i = 0; i < 3; i++) {\n        const latestPart = latestParts[i] ?? 0;\n        const currentPart = currentParts[i] ?? 0;\n        if (latestPart > currentPart) return true;\n        if (latestPart < currentPart) return false;\n      }\n      return false;\n    } catch (error) {\n      logger.debug('Version comparison failed:', {\n        error: getErrorMessage(error),\n        current,\n        latest,\n      });\n      return false;\n    }\n  }\n\n  /**\n   * Display update notification\n   */\n  private static displayUpdateNotification(\n    current: string,\n    latest: string\n  ): void {\n    console.log('\\n' + '\u2500'.repeat(60));\n    console.log('\uD83D\uDCE6 StackMemory Update Available!');\n    console.log(`   Current: v${current}`);\n    console.log(`   Latest:  v${latest}`);\n    console.log('\\n   Update with:');\n    console.log('   npm install -g @stackmemoryai/stackmemory@latest');\n    console.log('\u2500'.repeat(60) + '\\n');\n  }\n\n  /**\n   * Load update cache\n   */\n  private static loadCache(): UpdateCache | null {\n    try {\n      if (!existsSync(this.CACHE_FILE)) {\n        return null;\n      }\n\n      const data = readFileSync(this.CACHE_FILE, 'utf-8');\n      const cache = JSON.parse(data) as UpdateCache;\n\n      // Validate cache structure\n      if (\n        typeof cache.lastChecked !== 'number' ||\n        typeof cache.latestVersion !== 'string' ||\n        typeof cache.currentVersion !== 'string'\n      ) {\n        logger.debug('Invalid cache format, ignoring');\n        return null;\n      }\n\n      return cache;\n    } catch (error) {\n      // Cache errors should not interrupt operation\n      const wrappedError = wrapError(\n        error,\n        'Failed to load update cache',\n        ErrorCode.INTERNAL_ERROR,\n        { cacheFile: this.CACHE_FILE }\n      );\n      logger.debug('Failed to load update cache:', {\n        error: getErrorMessage(error),\n        context: wrappedError.context,\n      });\n      return null;\n    }\n  }\n\n  /**\n   * Save update cache\n   */\n  private static saveCache(cache: UpdateCache): void {\n    try {\n      const dir = join(homedir(), '.stackmemory');\n      \n      // Create directory if it doesn't exist (safer than execSync)\n      if (!existsSync(dir)) {\n        mkdirSync(dir, { recursive: true, mode: 0o755 });\n      }\n      \n      // Write cache with atomic operation (write to temp, then rename)\n      const tempFile = `${this.CACHE_FILE}.tmp`;\n      writeFileSync(tempFile, JSON.stringify(cache, null, 2), {\n        mode: 0o644,\n      });\n      \n      // Atomic rename\n      if (existsSync(this.CACHE_FILE)) {\n        writeFileSync(this.CACHE_FILE, JSON.stringify(cache, null, 2));\n      } else {\n        writeFileSync(this.CACHE_FILE, JSON.stringify(cache, null, 2));\n      }\n    } catch (error) {\n      // Cache save errors should not interrupt operation\n      const wrappedError = wrapError(\n        error,\n        'Failed to save update cache',\n        ErrorCode.INTERNAL_ERROR,\n        { cacheFile: this.CACHE_FILE, cache }\n      );\n      logger.debug('Failed to save update cache:', {\n        error: getErrorMessage(error),\n        context: wrappedError.context,\n      });\n    }\n  }\n\n  /**\n   * Force check for updates (ignores cache)\n   */\n  static async forceCheck(currentVersion: string): Promise<void> {\n    try {\n      const latestVersion = await this.fetchLatestVersion();\n\n      // Update cache\n      this.saveCache({\n        lastChecked: Date.now(),\n        latestVersion,\n        currentVersion,\n      });\n\n      if (latestVersion) {\n        if (this.isNewerVersion(currentVersion, latestVersion)) {\n          this.displayUpdateNotification(currentVersion, latestVersion);\n        } else {\n          console.log(`\u2705 StackMemory is up to date (v${currentVersion})`);\n        }\n      }\n    } catch (error) {\n      console.error('\u274C Update check failed:', (error as Error).message);\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,450 @@
+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