@codemap-ai/mcp 1.1.5 → 1.1.10

package/dist/index.js

@@ -3173,6 +3173,7 @@ var require_file_discovery = __commonJS({
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.PARSE_TOOL_VERSION = exports.PARSE_TOOL_NAME = exports.MAX_PARSE_BYTES_BY_LANGUAGE = exports.MAX_PARSE_BYTES = exports.IGNORED_NAMES = void 0;
+    exports.isPathIgnored = isPathIgnored;
     exports.normalizeRepositoryFilePath = normalizeRepositoryFilePath;
     exports.collectSingleFile = collectSingleFile2;
     exports.collectWorkspaceFiles = collectWorkspaceFiles2;
@@ -3183,13 +3184,35 @@ var require_file_discovery = __commonJS({
       ".git",
       ".codemap",
       "node_modules",
-      "dist",
+      ".pnpm",
+      ".pnpm-store",
+      ".dist",
       "build",
       ".next",
       "coverage",
       ".turbo",
-      ".cache"
+      ".cache",
+      ".agents",
+      ".claude",
+      ".codex",
+      ".vercel",
+      "tmp",
+      "temp",
+      "lib",
+      ".continue",
+      ".github",
+      ".vscode",
+      ".cursor",
+      ".opencode",
+      ".windsurf",
+      ".zed",
+      ".gemini",
+      ".ideamrc"
     ]);
+    function isPathIgnored(path19) {
+      const parts = path19.split("/");
+      return parts.some((part) => exports.IGNORED_NAMES.has(part));
+    }
     exports.MAX_PARSE_BYTES = 2 * 1024 * 1024;
     exports.MAX_PARSE_BYTES_BY_LANGUAGE = {
       Gettext: 10 * 1024 * 1024
@@ -232764,19 +232787,6 @@ function stableId(...parts) {
 function terms(query) {
   return query.toLowerCase().split(/[\s\-_/.,:]+/).map((term) => term.replace(/[^a-z0-9]/g, "")).filter((term) => term.length > 1);
 }
-function includesAll(input, queryTerms2) {
-  const lower = input.toLowerCase();
-  return queryTerms2.every((term) => lower.includes(term));
-}
-function scoreText(input, queryTerms2, baseRank) {
-  const lower = input.toLowerCase();
-  let score = 100 - baseRank;
-  for (const term of queryTerms2) {
-    if (lower === term) score += 30;
-    else if (lower.includes(term)) score += 12;
-  }
-  return score;
-}
 function resolveContentStatus(isBinary, parseStatus, content) {
   if (content != null) return "ready";
   if (isBinary) return "binary";
@@ -232878,6 +232888,61 @@ var SCHEMA_SQL = `
   CREATE INDEX IF NOT EXISTS idx_exports_filePath ON exports(filePath);
   CREATE INDEX IF NOT EXISTS idx_exports_exportName ON exports(lower(exportName));
 `;
+var FTS_SCHEMA_SQL = `
+  CREATE VIRTUAL TABLE IF NOT EXISTS files_fts USING fts5(
+    path,
+    content='files',
+    tokenize='unicode61 separators ''/._-'''
+  );
+
+  CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(
+    displayName, filePath, signature,
+    content='symbols',
+    tokenize='unicode61 separators ''/._-'''
+  );
+
+  CREATE VIRTUAL TABLE IF NOT EXISTS exports_fts USING fts5(
+    exportName, filePath,
+    content='exports',
+    tokenize='unicode61 separators ''/._-'''
+  );
+
+  -- files_fts triggers
+  CREATE TRIGGER IF NOT EXISTS files_fts_insert AFTER INSERT ON files BEGIN
+    INSERT INTO files_fts(rowid, path) VALUES (new.rowid, new.path);
+  END;
+  CREATE TRIGGER IF NOT EXISTS files_fts_delete AFTER DELETE ON files BEGIN
+    INSERT INTO files_fts(files_fts, rowid, path) VALUES('delete', old.rowid, old.path);
+  END;
+  CREATE TRIGGER IF NOT EXISTS files_fts_update AFTER UPDATE ON files BEGIN
+    INSERT INTO files_fts(files_fts, rowid, path) VALUES('delete', old.rowid, old.path);
+    INSERT INTO files_fts(rowid, path) VALUES (new.rowid, new.path);
+  END;
+
+  -- symbols_fts triggers
+  CREATE TRIGGER IF NOT EXISTS symbols_fts_insert AFTER INSERT ON symbols BEGIN
+    INSERT INTO symbols_fts(rowid, displayName, filePath, signature) VALUES (new.id, new.displayName, new.filePath, new.signature);
+  END;
+  CREATE TRIGGER IF NOT EXISTS symbols_fts_delete AFTER DELETE ON symbols BEGIN
+    INSERT INTO symbols_fts(symbols_fts, rowid, displayName, filePath, signature) VALUES('delete', old.id, old.displayName, old.filePath, old.signature);
+  END;
+  CREATE TRIGGER IF NOT EXISTS symbols_fts_update AFTER UPDATE ON symbols BEGIN
+    INSERT INTO symbols_fts(symbols_fts, rowid, displayName, filePath, signature) VALUES('delete', old.id, old.displayName, old.filePath, old.signature);
+    INSERT INTO symbols_fts(rowid, displayName, filePath, signature) VALUES (new.id, new.displayName, new.filePath, new.signature);
+  END;
+
+  -- exports_fts triggers
+  CREATE TRIGGER IF NOT EXISTS exports_fts_insert AFTER INSERT ON exports BEGIN
+    INSERT INTO exports_fts(rowid, exportName, filePath) VALUES (new.id, new.exportName, new.filePath);
+  END;
+  CREATE TRIGGER IF NOT EXISTS exports_fts_delete AFTER DELETE ON exports BEGIN
+    INSERT INTO exports_fts(exports_fts, rowid, exportName, filePath) VALUES('delete', old.id, old.exportName, old.filePath);
+  END;
+  CREATE TRIGGER IF NOT EXISTS exports_fts_update AFTER UPDATE ON exports BEGIN
+    INSERT INTO exports_fts(exports_fts, rowid, exportName, filePath) VALUES('delete', old.id, old.exportName, old.filePath);
+    INSERT INTO exports_fts(rowid, exportName, filePath) VALUES (new.id, new.exportName, new.filePath);
+  END;
+`;
 var SQLiteIndexStore = class _SQLiteIndexStore {
   db;
   dbPath;
@@ -232886,6 +232951,20 @@ var SQLiteIndexStore = class _SQLiteIndexStore {
     this.db = new DatabaseSync(dbPath);
     this.db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL;");
     this.db.exec(SCHEMA_SQL);
+    this.db.exec(FTS_SCHEMA_SQL);
+    this.migrateFts();
+  }
+  migrateFts() {
+    const { n } = this.db.prepare("SELECT count(*) as n FROM files_fts").get();
+    if (n === 0) {
+      this.db.exec(`
+        INSERT INTO files_fts(rowid, path) SELECT rowid, path FROM files;
+        INSERT INTO symbols_fts(rowid, displayName, filePath, signature)
+          SELECT id, displayName, filePath, signature FROM symbols;
+        INSERT INTO exports_fts(rowid, exportName, filePath)
+          SELECT id, exportName, filePath FROM exports;
+      `);
+    }
   }
   static open(dbPath) {
     mkdirSync(path8.dirname(dbPath), { recursive: true });
@@ -233210,26 +233289,157 @@ var SQLiteIndexStore = class _SQLiteIndexStore {
       throw error;
     }
   }
+  /**
+   * Batch update multiple files' data. More efficient than calling upsertFile repeatedly
+   * when reindexing dependent files after a source file change.
+   */
+  batchUpsertFiles(files) {
+    this.db.exec("BEGIN");
+    try {
+      const statements = /* @__PURE__ */ new Map();
+      const createStmt = (sql) => {
+        if (!statements.has(sql)) {
+          statements.set(sql, this.db.prepare(sql));
+        }
+        return statements.get(sql);
+      };
+      for (const { file, skipImportedByRebuild } of files) {
+        createStmt("DELETE FROM manifest WHERE path = ?").run(file.path);
+        createStmt("DELETE FROM files WHERE path = ?").run(file.path);
+        createStmt("DELETE FROM symbols WHERE filePath = ?").run(file.path);
+        createStmt("DELETE FROM imports WHERE filePath = ?").run(file.path);
+        createStmt("DELETE FROM exports WHERE filePath = ?").run(file.path);
+        if (!skipImportedByRebuild) {
+          createStmt("DELETE FROM imported_by WHERE targetFilePath = ? OR sourceFilePath = ?").run(file.path, file.path);
+        }
+        createStmt(
+          "INSERT INTO manifest(path, sizeBytes, contentSha256, parseStatus) VALUES(?, ?, ?, ?)"
+        ).run(file.path, file.sizeBytes, file.contentSha256 ?? null, file.parseStatus);
+        createStmt(
+          "INSERT INTO files(path, dirPath, baseName, extension, language, mimeType, sizeBytes, lineCount, parseStatus, isBinary, isText, contentSha256, content) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+        ).run(
+          file.path,
+          file.dirPath,
+          file.baseName,
+          file.extension ?? null,
+          file.language ?? null,
+          file.mimeType ?? null,
+          file.sizeBytes,
+          file.lineCount ?? null,
+          file.parseStatus,
+          file.isBinary ? 1 : 0,
+          file.isText ? 1 : 0,
+          file.contentSha256 ?? null,
+          file.content ?? null
+        );
+        const insertSymbol = createStmt(
+          "INSERT INTO symbols(filePath, localKey, stableKey, displayName, kind, signature, returnType, doc, isExported, parentSymbolLocalKey, line, col, endLine, endCol) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+        );
+        for (const sym of file.symbols) {
+          insertSymbol.run(
+            file.path,
+            sym.localKey,
+            sym.stableKey,
+            sym.displayName,
+            sym.kind,
+            sym.signature ?? null,
+            sym.returnType ?? null,
+            sym.doc ?? null,
+            sym.isExported ? 1 : 0,
+            sym.parentSymbolLocalKey ?? null,
+            sym.line,
+            sym.col,
+            sym.endLine,
+            sym.endCol
+          );
+        }
+        const insertImport = createStmt(
+          "INSERT INTO imports(filePath, localKey, moduleSpecifier, importKind, resolutionKind, targetPathText, targetExternalSymbolKey, line, col, endLine, endCol) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+        );
+        for (const imp of file.imports) {
+          insertImport.run(
+            file.path,
+            imp.localKey,
+            imp.moduleSpecifier,
+            imp.importKind,
+            imp.resolutionKind,
+            imp.targetPathText ?? null,
+            imp.targetExternalSymbolKey ?? null,
+            imp.line,
+            imp.col,
+            imp.endLine,
+            imp.endCol
+          );
+        }
+        const insertIB = createStmt(
+          "INSERT INTO imported_by(targetFilePath, sourceFilePath, moduleSpecifier, importKind, resolutionKind, startLine, startCol, endLine, endCol) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)"
+        );
+        for (const imp of file.imports) {
+          if (!imp.targetPathText) continue;
+          insertIB.run(
+            imp.targetPathText,
+            file.path,
+            imp.moduleSpecifier,
+            imp.importKind,
+            imp.resolutionKind,
+            imp.line,
+            imp.col,
+            imp.endLine,
+            imp.endCol
+          );
+        }
+        const insertExport = createStmt(
+          "INSERT INTO exports(filePath, exportName, exportKind, symbolLocalKey, line, col, endLine, endCol) VALUES(?, ?, ?, ?, ?, ?, ?, ?)"
+        );
+        for (const exp of file.exports) {
+          insertExport.run(
+            file.path,
+            exp.exportName,
+            exp.exportKind,
+            exp.symbolLocalKey ?? null,
+            exp.line,
+            exp.col,
+            exp.endLine,
+            exp.endCol
+          );
+        }
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
   search(query, symbolKinds) {
     const queryTerms2 = terms(query);
     if (queryTerms2.length === 0) return { files: [], symbols: [], exports: [] };
-    const likeConds = (col) => queryTerms2.map(() => `LOWER(${col}) LIKE ?`).join(" AND ");
-    const likeArgs = (col = "") => queryTerms2.map((t) => `%${col}${t}%`);
-    const fileRows = this.db.prepare(`SELECT path, language FROM files WHERE ${likeConds("path")} LIMIT 50`).all(...likeArgs());
-    const files = fileRows.filter((r) => includesAll(r.path, queryTerms2)).sort((a, b) => scoreText(b.path, queryTerms2, 0) - scoreText(a.path, queryTerms2, 0)).slice(0, 25).map((r) => ({ kind: "file", path: r.path, language: r.language }));
-    const symTermCond = `(${likeConds("s.displayName")} OR ${likeConds("s.filePath")})`;
-    const symArgs = [...likeArgs(), ...likeArgs()];
+    const ftsQuery = queryTerms2.map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
+    const fileRows = this.db.prepare(
+      `SELECT f.path, f.language
+         FROM files_fts
+         JOIN files f ON files_fts.rowid = f.rowid
+         WHERE files_fts MATCH ?
+         ORDER BY bm25(files_fts)
+         LIMIT 25`
+    ).all(ftsQuery);
+    const files = fileRows.map((r) => ({
+      kind: "file",
+      path: r.path,
+      language: r.language
+    }));
     let symSql = `
       SELECT s.filePath, s.localKey, s.stableKey, s.displayName, s.kind, s.signature,
              s.parentSymbolLocalKey, s.line, s.col, s.endLine, s.endCol
-      FROM symbols s
-      WHERE ${symTermCond}
+      FROM symbols_fts
+      JOIN symbols s ON symbols_fts.rowid = s.id
+      WHERE symbols_fts MATCH ?
     `;
+    const symArgs = [ftsQuery];
     if (symbolKinds && symbolKinds.length > 0) {
       symSql += ` AND s.kind IN (${symbolKinds.map(() => "?").join(",")})`;
       symArgs.push(...symbolKinds);
     }
-    symSql += " LIMIT 50";
+    symSql += " ORDER BY bm25(symbols_fts) LIMIT 25";
     const symRows = this.db.prepare(symSql).all(...symArgs);
     const parentKeys = [...new Set(symRows.map((r) => r.parentSymbolLocalKey).filter(Boolean))];
     const parentNameMap = /* @__PURE__ */ new Map();
@@ -233237,9 +233447,7 @@ var SQLiteIndexStore = class _SQLiteIndexStore {
       const parentRows = this.db.prepare(`SELECT localKey, displayName FROM symbols WHERE localKey IN (${parentKeys.map(() => "?").join(",")})`).all(...parentKeys);
       for (const pr of parentRows) parentNameMap.set(pr.localKey, pr.displayName);
     }
-    const symbols = symRows.filter((r) => includesAll(`${r.displayName} ${r.signature ?? ""} ${r.filePath}`, queryTerms2)).sort(
-      (a, b) => scoreText(`${b.displayName} ${b.filePath}`, queryTerms2, 0) - scoreText(`${a.displayName} ${a.filePath}`, queryTerms2, 0)
-    ).slice(0, 25).map((r) => ({
+    const symbols = symRows.map((r) => ({
       kind: "symbol",
       id: stableId(r.filePath, r.stableKey),
       displayName: r.displayName,
@@ -233254,10 +233462,12 @@ var SQLiteIndexStore = class _SQLiteIndexStore {
     }));
     const expRows = this.db.prepare(
       `SELECT e.filePath, e.exportName, e.exportKind, e.symbolLocalKey, e.line, e.col, e.endLine, e.endCol
-         FROM exports e
-         WHERE (${likeConds("e.exportName")} OR ${likeConds("e.filePath")})
-         LIMIT 50`
-    ).all(...likeArgs(), ...likeArgs());
+         FROM exports_fts
+         JOIN exports e ON exports_fts.rowid = e.id
+         WHERE exports_fts MATCH ?
+         ORDER BY bm25(exports_fts)
+         LIMIT 25`
+    ).all(ftsQuery);
     const expSymKeys = [...new Set(expRows.map((r) => r.symbolLocalKey).filter(Boolean))];
     const expSymMap = /* @__PURE__ */ new Map();
     if (expSymKeys.length > 0) {
@@ -233266,9 +233476,7 @@ var SQLiteIndexStore = class _SQLiteIndexStore {
       ).all(...expSymKeys);
       for (const sr of symInfoRows) expSymMap.set(sr.localKey, sr);
     }
-    const exports = expRows.filter((r) => includesAll(`${r.exportName} ${r.filePath}`, queryTerms2)).sort(
-      (a, b) => scoreText(`${b.exportName} ${b.filePath}`, queryTerms2, 0) - scoreText(`${a.exportName} ${a.filePath}`, queryTerms2, 0)
-    ).slice(0, 25).map((r) => {
+    const exports = expRows.map((r) => {
       const sym = r.symbolLocalKey ? expSymMap.get(r.symbolLocalKey) ?? null : null;
       return {
         kind: "export",
@@ -233576,6 +233784,28 @@ async function ensureLocalIndex(input) {
   }
   return buildLocalIndex(input);
 }
+async function refreshLocalFile(relativePath, workspaceRootPath) {
+  const store = _cachedStore ?? await readLocalIndex(workspaceRootPath) ?? await buildLocalIndex({ workspaceRootPath });
+  const meta = store.getMeta();
+  if (!meta) return false;
+  const candidate = await (0, import_code_index.collectSingleFile)(relativePath, meta.workspaceRootPath);
+  if (!candidate || !candidate.isParseable) return false;
+  const existingFiles = store.getAllFilePaths();
+  const filePathSet = new Set(existingFiles);
+  filePathSet.add(candidate.path);
+  const resolverConfigs = await (0, import_code_index.loadTypeScriptResolverConfigs)(meta.workspaceRootPath);
+  const semantics = await (0, import_code_index.parseWorkspaceFileSemantics)({
+    file: candidate,
+    filePathSet,
+    projectImportId: "local",
+    workspacePath: meta.workspaceRootPath,
+    resolverConfigs
+  });
+  const localFile = toLocalFile(candidate, semantics);
+  store.upsertFile(localFile);
+  _cachedStore = null;
+  return true;
+}
 async function getLocalIndexSummary(store) {
   const files = await collectFilesForStore(store);
   return store.getSummary(files.length > 0 ? store.isStale(files) : false);
@@ -233619,6 +233849,16 @@ function toRepoRelativePath(filePath, workspaceRootPath) {
   }
   return filePath;
 }
+async function refreshLocalFiles(filePaths, workspaceRootPath) {
+  const store = _cachedStore ?? await readLocalIndex(workspaceRootPath);
+  if (!store) {
+    throw new Error("Could not access local index store");
+  }
+  for (const filePath of filePaths) {
+    await refreshLocalFile(filePath, workspaceRootPath);
+  }
+  _cachedStore = null;
+}
 
 // ../core/src/lib/session-context.ts
 function formatAge(date) {
@@ -234018,6 +234258,458 @@ ${(/* @__PURE__ */ new Date()).toISOString()}
   }
 }
 
+// ../core/src/lib/file-watcher.ts
+var import_code_index2 = __toESM(require_dist(), 1);
+import * as parcelWatcher from "@parcel/watcher";
+var IndexWatcher = class {
+  subscription = null;
+  config;
+  pendingEvents = /* @__PURE__ */ new Map();
+  flushTimer = null;
+  isRunning = false;
+  constructor(config) {
+    this.config = {
+      workspaceRootPath: config.workspaceRootPath,
+      debounceMs: config.debounceMs ?? 200,
+      ignoredPatterns: config.ignoredPatterns ?? [],
+      onEvent: config.onEvent ?? (() => {
+      })
+    };
+  }
+  async start() {
+    if (this.isRunning) {
+      return;
+    }
+    try {
+      this.subscription = await parcelWatcher.subscribe(
+        this.config.workspaceRootPath,
+        (err, events) => {
+          if (err) {
+            console.error("[IndexWatcher] Error:", err);
+            return;
+          }
+          for (const event of events) {
+            this.handleRawEvent(event);
+          }
+        },
+        {
+          ignore: [...import_code_index2.IGNORED_NAMES, ...this.config.ignoredPatterns]
+        }
+      );
+      this.isRunning = true;
+      console.log(
+        `[IndexWatcher] Started watching ${this.config.workspaceRootPath}`
+      );
+    } catch (error) {
+      console.error("[IndexWatcher] Failed to start:", error);
+      throw error;
+    }
+  }
+  async stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    await this.flush();
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.subscription) {
+      await this.subscription.unsubscribe();
+      this.subscription = null;
+    }
+    this.isRunning = false;
+    this.pendingEvents.clear();
+    console.log("[IndexWatcher] Stopped");
+  }
+  async restart() {
+    await this.stop();
+    await this.start();
+  }
+  isActive() {
+    return this.isRunning;
+  }
+  handleRawEvent(event) {
+    const relativePath = event.path.replace(
+      this.config.workspaceRootPath + "/",
+      ""
+    );
+    let type;
+    if (event.type === "create") {
+      type = "create";
+    } else if (event.type === "update") {
+      type = "update";
+    } else if (event.type === "delete") {
+      type = "delete";
+    } else {
+      return;
+    }
+    this.pendingEvents.set(relativePath, {
+      type,
+      path: event.path,
+      relativePath,
+      timestamp: Date.now()
+    });
+    this.scheduleFlush();
+  }
+  scheduleFlush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flush().catch((err) => {
+        console.error("[IndexWatcher] Flush error:", err);
+      });
+    }, this.config.debounceMs);
+  }
+  async flush() {
+    if (this.pendingEvents.size === 0) {
+      return;
+    }
+    const events = Array.from(this.pendingEvents.values());
+    this.pendingEvents.clear();
+    for (const event of events) {
+      const watchEvent = {
+        type: event.type,
+        path: event.path,
+        relativePath: event.relativePath
+      };
+      try {
+        await this.config.onEvent(watchEvent);
+      } catch (error) {
+        console.error(
+          `[IndexWatcher] Error processing event for ${event.relativePath}:`,
+          error
+        );
+      }
+    }
+  }
+};
+
+// ../core/src/lib/symbol-dependency.ts
+var SymbolDependencyGraph = class {
+  edges = /* @__PURE__ */ new Map();
+  reverseEdges = /* @__PURE__ */ new Map();
+  /**
+   * Build the dependency graph from the SQLite index store.
+   * Call this once after initial index build or when restarting the watcher.
+   */
+  buildFromStore(store) {
+    this.edges.clear();
+    this.reverseEdges.clear();
+    const allFilePaths = store.getAllFilePaths();
+    for (const filePath of allFilePaths) {
+      const fileParse = store.getFileParse(filePath);
+      if (!fileParse) continue;
+      const fileEdges = [];
+      for (const imp of fileParse.imports) {
+        if (!imp.targetPathText) continue;
+        const targetFile = store.getFileParse(imp.targetPathText);
+        if (!targetFile) continue;
+        const importedSymbols = this.extractImportedSymbols(
+          imp,
+          targetFile.exports
+        );
+        if (importedSymbols.length > 0) {
+          fileEdges.push({
+            sourceFilePath: filePath,
+            targetFilePath: imp.targetPathText,
+            importedSymbols
+          });
+          if (!this.reverseEdges.has(imp.targetPathText)) {
+            this.reverseEdges.set(imp.targetPathText, /* @__PURE__ */ new Set());
+          }
+          this.reverseEdges.get(imp.targetPathText).add(filePath);
+        }
+      }
+      if (fileEdges.length > 0) {
+        this.edges.set(filePath, fileEdges);
+      }
+    }
+    console.log(
+      `[SymbolDependencyGraph] Built graph: ${this.edges.size} files with dependencies`
+    );
+  }
+  /**
+   * Get all files that import symbols from the given file.
+   * Returns a map of source file -> imported symbol names.
+   */
+  getImporters(targetFilePath) {
+    const result = /* @__PURE__ */ new Map();
+    const importers = this.reverseEdges.get(targetFilePath);
+    if (!importers) return result;
+    for (const sourceFile of importers) {
+      const edges = this.edges.get(sourceFile);
+      if (!edges) continue;
+      for (const edge of edges) {
+        if (edge.targetFilePath === targetFilePath) {
+          if (!result.has(sourceFile)) {
+            result.set(sourceFile, /* @__PURE__ */ new Set());
+          }
+          const symbolSet = result.get(sourceFile);
+          for (const sym of edge.importedSymbols) {
+            symbolSet.add(sym.displayName);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get all files that should be reindexed when the given symbols in
+   * targetFile change. Only returns files that actually import the
+   * changed symbols, not all files that import targetFile.
+   */
+  getAffectedFiles(targetFilePath, changedSymbols) {
+    const affected = /* @__PURE__ */ new Set();
+    const importers = this.getImporters(targetFilePath);
+    for (const [sourceFile, importedSymbols] of importers) {
+      for (const changedSymbol of changedSymbols) {
+        if (importedSymbols.has(changedSymbol)) {
+          affected.add(sourceFile);
+          break;
+        }
+      }
+    }
+    return affected;
+  }
+  /**
+   * Update the graph when a single file changes.
+   * Call this after reindexing a file to keep the graph fresh.
+   */
+  updateFile(store, filePath) {
+    this.edges.delete(filePath);
+    for (const [target, sources] of this.reverseEdges) {
+      sources.delete(filePath);
+      if (sources.size === 0) {
+        this.reverseEdges.delete(target);
+      }
+    }
+    const fileParse = store.getFileParse(filePath);
+    if (!fileParse) return;
+    const fileEdges = [];
+    for (const imp of fileParse.imports) {
+      if (!imp.targetPathText) continue;
+      const targetFile = store.getFileParse(imp.targetPathText);
+      if (!targetFile) continue;
+      const importedSymbols = this.extractImportedSymbols(
+        imp,
+        targetFile.exports
+      );
+      if (importedSymbols.length > 0) {
+        fileEdges.push({
+          sourceFilePath: filePath,
+          targetFilePath: imp.targetPathText,
+          importedSymbols
+        });
+        if (!this.reverseEdges.has(imp.targetPathText)) {
+          this.reverseEdges.set(imp.targetPathText, /* @__PURE__ */ new Set());
+        }
+        this.reverseEdges.get(imp.targetPathText).add(filePath);
+      }
+    }
+    if (fileEdges.length > 0) {
+      this.edges.set(filePath, fileEdges);
+    }
+  }
+  /**
+   * Remove a file from the graph (e.g., when it's deleted).
+   */
+  removeFile(filePath) {
+    this.edges.delete(filePath);
+    for (const [target, sources] of this.reverseEdges) {
+      sources.delete(filePath);
+      if (sources.size === 0) {
+        this.reverseEdges.delete(target);
+      }
+    }
+  }
+  /**
+   * Get the number of files tracked in the graph.
+   */
+  size() {
+    return this.edges.size;
+  }
+  extractImportedSymbols(imp, targetExports) {
+    const symbols = [];
+    if (imp.importKind === "namespace") {
+      for (const exp of targetExports) {
+        if (exp.symbolDisplayName) {
+          symbols.push({
+            displayName: exp.symbolDisplayName,
+            kind: exp.exportKind
+          });
+        }
+      }
+    } else if (imp.importKind === "default") {
+      const defaultExport = targetExports.find(
+        (e) => e.exportKind === "default"
+      );
+      if (defaultExport?.symbolDisplayName) {
+        symbols.push({
+          displayName: defaultExport.symbolDisplayName,
+          kind: "default"
+        });
+      }
+    } else {
+      for (const exp of targetExports) {
+        if (exp.exportKind === "named" && exp.symbolDisplayName) {
+          symbols.push({
+            displayName: exp.symbolDisplayName,
+            kind: exp.exportKind
+          });
+        }
+      }
+    }
+    return symbols;
+  }
+};
+
+// ../core/src/lib/watch-event-handler.ts
+var WatchEventHandler = class {
+  config;
+  graph;
+  constructor(config) {
+    this.config = config;
+    this.graph = config.symbolDependencyGraph;
+  }
+  /**
+   * Process a file watch event and determine if/which files should be reindexed.
+   */
+  async handleEvent(event) {
+    switch (event.type) {
+      case "create":
+        await this.handleFileCreate(event);
+        break;
+      case "update":
+        await this.handleFileUpdate(event);
+        break;
+      case "delete":
+        await this.handleFileDelete(event);
+        break;
+    }
+  }
+  async handleFileCreate(event) {
+    console.log(`[WatchEventHandler] New file detected: ${event.relativePath}`);
+    await this.config.onReindexFile(event.relativePath);
+    this.graph.updateFile(this.config.store, event.relativePath);
+  }
+  getExportNames(filePath) {
+    const parse = this.config.store.getFileParse(filePath);
+    if (!parse) return /* @__PURE__ */ new Set();
+    return new Set(parse.exports.map((e) => e.exportName));
+  }
+  async handleFileUpdate(event) {
+    const filePath = event.relativePath;
+    const importers = this.graph.getImporters(filePath);
+    if (importers.size === 0) {
+      console.log(`[WatchEventHandler] File updated: ${filePath} (no dependents)`);
+      await this.config.onReindexFile(filePath);
+      this.graph.updateFile(this.config.store, filePath);
+      return;
+    }
+    const exportsBefore = this.getExportNames(filePath);
+    await this.config.onReindexFile(filePath);
+    this.graph.updateFile(this.config.store, filePath);
+    const exportsAfter = this.getExportNames(filePath);
+    const exportsChanged = exportsBefore.size !== exportsAfter.size || [...exportsBefore].some((name) => !exportsAfter.has(name)) || [...exportsAfter].some((name) => !exportsBefore.has(name));
+    if (!exportsChanged) {
+      console.log(`[WatchEventHandler] File updated: ${filePath} (exports unchanged, skipping ${importers.size} dependents)`);
+      return;
+    }
+    const dependentFiles = Array.from(importers.keys());
+    console.log(`[WatchEventHandler] File updated: ${filePath} (exports changed, reindexing ${dependentFiles.length} dependents)`);
+    await this.config.onBatchReindex(dependentFiles);
+    for (const importer of dependentFiles) {
+      this.graph.updateFile(this.config.store, importer);
+    }
+  }
+  async handleFileDelete(event) {
+    const filePath = event.relativePath;
+    console.log(`[WatchEventHandler] File deleted: ${filePath}`);
+    this.config.store.removeFileFromIndex(filePath);
+    const importers = this.graph.getImporters(filePath);
+    this.graph.removeFile(filePath);
+    for (const importer of importers.keys()) {
+      try {
+        await this.config.onReindexFile(importer);
+        this.graph.updateFile(this.config.store, importer);
+      } catch (err) {
+        console.error(`[WatchEventHandler] Error reindexing importer ${importer}:`, err);
+      }
+    }
+  }
+};
+
+// ../core/src/lib/auto-indexing.ts
+var _watcher = null;
+var _dependencyGraph = null;
+var _eventHandler = null;
+async function enableAutoIndexing(store, workspaceRootPath) {
+  if (_watcher) {
+    if (_watcher.isActive()) {
+      console.log("[AutoIndexing] Already active");
+      return;
+    }
+    await _watcher.stop().catch(() => {
+    });
+    _watcher = null;
+    _dependencyGraph = null;
+    _eventHandler = null;
+  }
+  _dependencyGraph = new SymbolDependencyGraph();
+  _dependencyGraph.buildFromStore(store);
+  const defaultCallbacks = {
+    onFileChange: async (filePath) => {
+      try {
+        await refreshLocalFile(filePath, workspaceRootPath);
+        console.log(`[AutoIndexing] Reindexed: ${filePath}`);
+      } catch (err) {
+        console.error(`[AutoIndexing] Failed to reindex ${filePath}:`, err);
+      }
+    },
+    onBatchChanges: async (filePaths) => {
+      try {
+        await refreshLocalFiles(filePaths, workspaceRootPath);
+        console.log(`[AutoIndexing] Batch reindexed ${filePaths.length} files`);
+      } catch (err) {
+        console.error(`[AutoIndexing] Batch reindex failed:`, err);
+      }
+    }
+  };
+  _eventHandler = new WatchEventHandler({
+    store,
+    symbolDependencyGraph: _dependencyGraph,
+    onReindexFile: defaultCallbacks.onFileChange,
+    onBatchReindex: defaultCallbacks.onBatchChanges
+  });
+  _watcher = new IndexWatcher({
+    workspaceRootPath,
+    onEvent: async (event) => {
+      try {
+        await _eventHandler.handleEvent(event);
+      } catch (err) {
+        console.error(`[AutoIndexing] Error handling watch event:`, err);
+      }
+    }
+  });
+  await _watcher.start();
+  console.log("[AutoIndexing] Started for:", workspaceRootPath);
+}
+async function disableAutoIndexing() {
+  if (!_watcher?.isActive()) {
+    return;
+  }
+  await _watcher.stop();
+  _watcher = null;
+  _dependencyGraph = null;
+  _eventHandler = null;
+  console.log("[AutoIndexing] Stopped");
+}
+function isAutoIndexingActive() {
+  return _watcher?.isActive() ?? false;
+}
+
 // src/tools/manage-git-connection.ts
 import { z } from "zod";
 
@@ -237317,6 +238009,117 @@ function registerRefreshLocalIndexTool(server2) {
   );
 }
 
+// src/tools/auto-index-control.ts
+import { performance as performance3 } from "perf_hooks";
+function registerEnableAutoIndexingTool(server2) {
+  server2.registerTool(
+    "enable_auto_indexing",
+    {
+      title: "Enable Auto Indexing",
+      description: "Enables automatic file watching and index refresh for the current workspace. When enabled, CodeMap will automatically reindex files when they change, keeping your local SQLite index up-to-date without manual intervention.",
+      inputSchema: {}
+    },
+    withToolError(async () => {
+      const startedAt = performance3.now();
+      const workspaceRoot = process.cwd();
+      const store = await ensureLocalIndex({ force: false });
+      await enableAutoIndexing(store, workspaceRoot);
+      const elapsedMs = Math.round(performance3.now() - startedAt);
+      const summary = await getLocalIndexSummary(store);
+      const output = [
+        "Auto-indexing enabled successfully.",
+        `Workspace: ${workspaceRoot}`,
+        "",
+        "Current index status:",
+        `  Files: ${summary.fileCount}`,
+        `  Symbols: ${summary.symbolCount}`,
+        `  Stale: ${summary.stale ? "yes" : "no"}`,
+        "",
+        "The index will now automatically update when files change."
+      ].join("\n");
+      return success(output, {
+        status: "completed",
+        mode: "local",
+        workspacePath: workspaceRoot,
+        fileCount: summary.fileCount,
+        symbolCount: summary.symbolCount,
+        stale: summary.stale,
+        elapsedMs,
+        suggestedNextTools: ["diff()", "get_project_map()"]
+      });
+    })
+  );
+}
+function registerDisableAutoIndexingTool(server2) {
+  server2.registerTool(
+    "disable_auto_indexing",
+    {
+      title: "Disable Auto Indexing",
+      description: "Disables automatic file watching and index refresh for the current workspace. After disabling, you'll need to manually refresh the index when files change using 'refresh_local_index'.",
+      inputSchema: {}
+    },
+    withToolError(async () => {
+      const startedAt = performance3.now();
+      disableAutoIndexing();
+      const elapsedMs = Math.round(performance3.now() - startedAt);
+      const output = [
+        "Auto-indexing disabled successfully.",
+        "The file watcher has been stopped.",
+        "",
+        "To enable again in the future, use 'enable_auto_indexing'.",
+        "To manually refresh the index when needed, use 'refresh_local_index'."
+      ].join("\n");
+      return success(output, {
+        status: "completed",
+        mode: "local",
+        elapsedMs,
+        suggestedNextTools: ["refresh_local_index(force=true)"]
+      });
+    })
+  );
+}
+function registerCheckAutoIndexStatusTool(server2) {
+  server2.registerTool(
+    "check_auto_index_status",
+    {
+      title: "Check Auto Index Status",
+      description: "Checks the current status of automatic file watching and index refresh. Returns whether auto-indexing is active, the workspace being watched, and current index statistics.",
+      inputSchema: {}
+    },
+    withToolError(async () => {
+      const startedAt = performance3.now();
+      const isActive = isAutoIndexingActive();
+      const workspaceRoot = process.cwd();
+      let statusInfo = [
+        "Auto-indexing status report:",
+        `  Active: ${isActive ? "Yes \u2713" : "No \u2717"}`,
+        `  Workspace: ${workspaceRoot}`
+      ];
+      if (isActive) {
+        statusInfo.push("");
+        statusInfo.push("Auto-indexing is running. Files will be automatically reindexed when changed.");
+        statusInfo.push("Tip: Use 'disable_auto_indexing' to stop watching or 'refresh_local_index' for manual refresh.");
+      } else {
+        statusInfo.push("");
+        statusInfo.push("Auto-indexing is disabled. Use 'enable_auto_indexing' to start watching files automatically.");
+        statusInfo.push("Tip: You can still manually refresh using 'refresh_local_index'.");
+      }
+      const elapsedMs = Math.round(performance3.now() - startedAt);
+      return success(statusInfo.join("\n"), {
+        status: "completed",
+        mode: "local",
+        workspacePath: workspaceRoot,
+        isActive,
+        elapsedMs,
+        suggestedNextTools: [
+          isActive ? "disable_auto_indexing()" : "enable_auto_indexing()",
+          "refresh_local_index(force=true)"
+        ]
+      });
+    })
+  );
+}
+
 // src/tools/get-file.ts
 import { z as z13 } from "zod";
 
@@ -240527,6 +241330,149 @@ function formatReadCall(path19, plan) {
   return `get_file("${path19}", ${parts.join(", ")})`;
 }
 var OUTLINE_PLAN = { include: ["outline"] };
+function buildLocalReadPlan(symbol) {
+  if (!symbol?.name) return OUTLINE_PLAN;
+  return { include: ["symbols"], symbolNames: [symbol.name] };
+}
+function tokenizeLocalQuery(query) {
+  return query.toLowerCase().split(/[\s\-_/.,:]+/).map((term) => term.trim()).filter((term) => term.length > 1);
+}
+function buildLocalReason(path19, query, symbol) {
+  const parts = [];
+  if (symbol?.name) parts.push(`symbol match: ${symbol.name}`);
+  const terms2 = tokenizeLocalQuery(query);
+  const lowerPath = path19.toLowerCase();
+  const matchedTerms = terms2.filter((term) => lowerPath.includes(term));
+  if (matchedTerms.length > 0) {
+    parts.push(`path matches: ${matchedTerms.slice(0, 3).join(", ")}`);
+  }
+  return parts[0] ?? "local index match";
+}
+function buildLocalExploreData(task, results, importerCountsByPath) {
+  const likelyFiles = [];
+  const likelyFilePaths = /* @__PURE__ */ new Set();
+  const importerCounts = /* @__PURE__ */ new Map();
+  const symbolByPath = /* @__PURE__ */ new Map();
+  const symbols = results.symbols.slice(0, 8).map((s) => ({
+    name: s.displayName,
+    kind: s.symbolKind,
+    filePath: s.filePath,
+    startLine: s.startLine ?? null,
+    signature: s.signature ?? null
+  }));
+  for (const symbol of symbols) {
+    const existing = symbolByPath.get(symbol.filePath) ?? [];
+    existing.push(symbol);
+    symbolByPath.set(symbol.filePath, existing);
+  }
+  const pushLikelyFile = (path19, language, confidence, baseReason, blastRadius) => {
+    if (likelyFilePaths.has(path19)) return;
+    const topSymbol = symbolByPath.get(path19)?.[0] ?? null;
+    likelyFiles.push({
+      path: path19,
+      language,
+      confidence,
+      reason: baseReason ?? buildLocalReason(path19, task, topSymbol),
+      readPlan: buildLocalReadPlan(topSymbol),
+      ...blastRadius !== void 0 ? { blastRadius } : {}
+    });
+    likelyFilePaths.add(path19);
+  };
+  for (const symbol of results.symbols.slice(0, 8)) {
+    const importerCount = importerCountsByPath.get(symbol.filePath);
+    if (typeof importerCount === "number") importerCounts.set(symbol.filePath, importerCount);
+    pushLikelyFile(
+      symbol.filePath,
+      null,
+      "high",
+      `symbol match: ${symbol.displayName}`,
+      importerCount
+    );
+  }
+  for (const file of results.files.slice(0, 8)) {
+    const importerCount = importerCountsByPath.get(file.path);
+    if (typeof importerCount === "number") importerCounts.set(file.path, importerCount);
+    pushLikelyFile(
+      file.path,
+      file.language ?? null,
+      likelyFilePaths.size < 4 ? "high" : "medium",
+      void 0,
+      importerCount
+    );
+  }
+  const entrypointMap = /* @__PURE__ */ new Map();
+  for (const path19 of likelyFiles.map((f) => f.path)) {
+    const label = detectEntrypoint(path19);
+    if (label && !entrypointMap.has(path19)) entrypointMap.set(path19, label);
+  }
+  const entrypoints = [...entrypointMap.entries()].map(([path19, label]) => ({
+    path: path19,
+    language: null,
+    confidence: "medium",
+    reason: label,
+    readPlan: OUTLINE_PLAN,
+    ...importerCounts.has(path19) ? { blastRadius: importerCounts.get(path19) } : {}
+  }));
+  return { likelyFiles, entrypoints, symbols, importerCounts };
+}
+async function buildLocalFallbackResponse(projectId, task, fallbackReason) {
+  const { store } = await ensureLocalIndexWithSummary();
+  const localSearch = store.search(task, null);
+  const importerCountsByPath = /* @__PURE__ */ new Map();
+  for (const file of localSearch.files.slice(0, 8)) {
+    const parse = store.getFileParse(file.path);
+    importerCountsByPath.set(file.path, parse?.importedBy.length ?? 0);
+  }
+  for (const symbol of localSearch.symbols.slice(0, 8)) {
+    if (importerCountsByPath.has(symbol.filePath)) continue;
+    const parse = store.getFileParse(symbol.filePath);
+    importerCountsByPath.set(symbol.filePath, parse?.importedBy.length ?? 0);
+  }
+  const localData = buildLocalExploreData(task, localSearch, importerCountsByPath);
+  const risks = [];
+  const risksSeen = /* @__PURE__ */ new Set();
+  for (const path19 of [
+    ...localData.likelyFiles.map((f) => f.path),
+    ...localData.entrypoints.map((f) => f.path)
+  ]) {
+    if (risksSeen.has(path19)) continue;
+    const risk = detectPathRisk(path19);
+    if (risk) {
+      risks.push(risk);
+      risksSeen.add(path19);
+    }
+  }
+  const recommendedReads = [];
+  let priority = 1;
+  for (const f of [...localData.entrypoints, ...localData.likelyFiles]) {
+    recommendedReads.push({
+      path: f.path,
+      priority: priority++,
+      readPlan: f.readPlan,
+      why: f.reason
+    });
+  }
+  const packBase = {
+    task,
+    likelyFiles: localData.likelyFiles,
+    entrypoints: localData.entrypoints,
+    symbols: localData.symbols,
+    risks,
+    recommendedReads
+  };
+  const summary = [
+    buildSummary(packBase),
+    `Source: local SQLite index (${fallbackReason})`
+  ].join("\n");
+  const suggestedNextTools = buildNextTools(packBase);
+  const pack = { ...packBase, summary, suggestedNextTools };
+  return success(buildTextOutput(pack), {
+    projectId,
+    available: true,
+    source: "local",
+    ...pack
+  });
+}
 function buildSummary(pack) {
   const lines = [];
   const domains = [
@@ -240672,19 +241618,10 @@ function registerExploreTaskTool(server2, config) {
         );
       }
       if (await shouldUseLocalIndexBeforeRemote(client, resolvedProjectId)) {
-        const hint = `search_codebase("${task.slice(0, 60)}")`;
-        return success(
-          `Cloud index not ready for task: "${task}"
-
-Use search_codebase with the local index instead:
-\u2192 ${hint}`,
-          {
-            projectId: resolvedProjectId,
-            task,
-            available: false,
-            source: "local",
-            suggestedNextTools: [hint, "get_project_map()  // browse project structure"]
-          }
+        return buildLocalFallbackResponse(
+          resolvedProjectId,
+          task,
+          "cloud index not ready"
         );
       }
       const [searchResult, editLocsResult, semanticResult] = await Promise.allSettled([
@@ -240708,6 +241645,13 @@ Use search_codebase with the local index instead:
       const cloudFailed = bothFailed && shouldFallbackToLocal(
         searchResult.status === "rejected" ? searchResult.reason : null
       );
+      if (cloudFailed) {
+        return buildLocalFallbackResponse(
+          resolvedProjectId,
+          task,
+          "cloud API unavailable"
+        );
+      }
       const likelyFiles = editLocs.suggestions.filter((s) => s.confidence === "high" || s.confidence === "medium").slice(0, 8).map((s) => ({
         path: s.path,
         language: s.language ?? null,
@@ -240841,11 +241785,6 @@ Use search_codebase with the local index instead:
       const packBase = { task, likelyFiles, entrypoints, symbols, risks, recommendedReads };
       const summary = buildSummary(packBase);
       const suggestedNextTools = buildNextTools(packBase);
-      if (cloudFailed) {
-        suggestedNextTools.unshift(
-          `search_codebase("${task.slice(0, 60)}")  // cloud unavailable \u2014 use local index`
-        );
-      }
       const pack = { ...packBase, summary, suggestedNextTools };
       return success(buildTextOutput(pack), {
         projectId: resolvedProjectId,
@@ -240878,6 +241817,9 @@ async function runMcpServer() {
   registerGetProjectMapTool(server2, config);
   registerDiffTool(server2, config);
   registerRefreshLocalIndexTool(server2);
+  registerEnableAutoIndexingTool(server2);
+  registerDisableAutoIndexingTool(server2);
+  registerCheckAutoIndexStatusTool(server2);
   registerWebSearchTool(server2);
   registerReimportTool(server2, config);
   if (toolMode === "standard" || toolMode === "full") {
@@ -240898,6 +241840,11 @@ async function runMcpServer() {
   registerAgentRuleResources(server2);
   const transport = new StdioServerTransport();
   await server2.connect(transport);
+  ensureLocalIndex({ force: false }).then((store) => {
+    const workspaceRootPath = store.getMeta()?.workspaceRootPath;
+    if (workspaceRootPath) return enableAutoIndexing(store, workspaceRootPath);
+  }).catch(() => {
+  });
   await autoInjectRules(server2, process.cwd());
   const sessionCtx = await buildSessionContext(process.cwd()).catch(() => null);
   if (sessionCtx) process.stderr.write(sessionCtx + "\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemap-ai/mcp",
-  "version": "1.1.5",
+  "version": "1.1.10",
   "type": "module",
   "description": "CodeMap MCP server for IDE integrations",
   "license": "MIT",
@@ -22,7 +22,7 @@
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typescript": "~5.9.2",
-    "@codemap-ai/core": "1.1.5"
+    "@codemap-ai/core": "1.1.10"
   },
   "publishConfig": {
     "access": "public"