opencode-codebase-index 0.1.10 → 0.2.0

package/dist/index.cjs

@@ -693,6 +693,8 @@ function getDefaultIndexingConfig() {
     autoIndex: false,
     watchFiles: true,
     maxFileSize: 1048576,
+    maxChunksPerFile: 100,
+    semanticOnly: false,
     retries: 3,
     retryDelayMs: 1e3
   };
@@ -726,6 +728,8 @@ function parseConfig(raw) {
     autoIndex: typeof rawIndexing.autoIndex === "boolean" ? rawIndexing.autoIndex : defaultIndexing.autoIndex,
     watchFiles: typeof rawIndexing.watchFiles === "boolean" ? rawIndexing.watchFiles : defaultIndexing.watchFiles,
     maxFileSize: typeof rawIndexing.maxFileSize === "number" ? rawIndexing.maxFileSize : defaultIndexing.maxFileSize,
+    maxChunksPerFile: typeof rawIndexing.maxChunksPerFile === "number" ? Math.max(1, rawIndexing.maxChunksPerFile) : defaultIndexing.maxChunksPerFile,
+    semanticOnly: typeof rawIndexing.semanticOnly === "boolean" ? rawIndexing.semanticOnly : defaultIndexing.semanticOnly,
     retries: typeof rawIndexing.retries === "number" ? rawIndexing.retries : defaultIndexing.retries,
     retryDelayMs: typeof rawIndexing.retryDelayMs === "number" ? rawIndexing.retryDelayMs : defaultIndexing.retryDelayMs
   };
@@ -2189,7 +2193,10 @@ function shouldIncludeFile(filePath, projectRoot, includePatterns, excludePatter
   return false;
 }
 function matchGlob(filePath, pattern) {
-  const regexPattern = pattern.replace(/\*\*/g, "<<<DOUBLESTAR>>>").replace(/\*/g, "[^/]*").replace(/<<<DOUBLESTAR>>>/g, ".*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, p1) => `(${p1.split(",").join("|")})`);
+  let regexPattern = pattern.replace(/\*\*/g, "<<<DOUBLESTAR>>>").replace(/\*/g, "[^/]*").replace(/<<<DOUBLESTAR>>>/g, ".*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, p1) => `(${p1.split(",").join("|")})`);
+  if (regexPattern.startsWith(".*/")) {
+    regexPattern = `(.*\\/)?${regexPattern.slice(3)}`;
+  }
   const regex = new RegExp(`^${regexPattern}$`);
   return regex.test(filePath);
 }
@@ -2626,158 +2633,204 @@ function generateChunkId(filePath, chunk) {
 function generateChunkHash(chunk) {
   return hashContent(chunk.content);
 }
-
-// src/indexer/inverted-index.ts
-var import_fs3 = require("fs");
-var path4 = __toESM(require("path"), 1);
 var InvertedIndex = class {
-  indexPath;
-  termToChunks = /* @__PURE__ */ new Map();
-  chunkTokens = /* @__PURE__ */ new Map();
-  totalTokenCount = 0;
+  inner;
   constructor(indexPath) {
-    this.indexPath = path4.join(indexPath, "inverted-index.json");
+    this.inner = new native.InvertedIndex(indexPath);
   }
   load() {
-    if (!(0, import_fs3.existsSync)(this.indexPath)) {
-      return;
-    }
-    try {
-      const content = (0, import_fs3.readFileSync)(this.indexPath, "utf-8");
-      const data = JSON.parse(content);
-      for (const [term, chunkIds] of Object.entries(data.termToChunks)) {
-        this.termToChunks.set(term, new Set(chunkIds));
-      }
-      for (const [chunkId, tokens] of Object.entries(data.chunkTokens)) {
-        const tokenMap = new Map(Object.entries(tokens).map(([k, v]) => [k, v]));
-        this.chunkTokens.set(chunkId, tokenMap);
-        for (const count of tokenMap.values()) {
-          this.totalTokenCount += count;
-        }
-      }
-    } catch {
-      this.termToChunks.clear();
-      this.chunkTokens.clear();
-      this.totalTokenCount = 0;
-    }
+    this.inner.load();
   }
   save() {
-    const data = {
-      termToChunks: {},
-      chunkTokens: {},
-      avgDocLength: this.getAvgDocLength()
-    };
-    for (const [term, chunkIds] of this.termToChunks) {
-      data.termToChunks[term] = Array.from(chunkIds);
-    }
-    for (const [chunkId, tokens] of this.chunkTokens) {
-      data.chunkTokens[chunkId] = Object.fromEntries(tokens);
-    }
-    (0, import_fs3.writeFileSync)(this.indexPath, JSON.stringify(data));
+    this.inner.save();
   }
   addChunk(chunkId, content) {
-    const tokens = this.tokenize(content);
-    const termFreq = /* @__PURE__ */ new Map();
-    for (const token of tokens) {
-      termFreq.set(token, (termFreq.get(token) || 0) + 1);
-      const chunks = this.termToChunks.get(token) || /* @__PURE__ */ new Set();
-      chunks.add(chunkId);
-      this.termToChunks.set(token, chunks);
-    }
-    this.chunkTokens.set(chunkId, termFreq);
-    this.totalTokenCount += tokens.length;
+    this.inner.addChunk(chunkId, content);
   }
   removeChunk(chunkId) {
-    const tokens = this.chunkTokens.get(chunkId);
-    if (!tokens) return;
-    for (const [token, count] of tokens) {
-      this.totalTokenCount -= count;
-      const chunks = this.termToChunks.get(token);
-      if (chunks) {
-        chunks.delete(chunkId);
-        if (chunks.size === 0) {
-          this.termToChunks.delete(token);
-        }
-      }
-    }
-    this.chunkTokens.delete(chunkId);
+    return this.inner.removeChunk(chunkId);
   }
-  search(query) {
-    const queryTokens = this.tokenize(query);
-    if (queryTokens.length === 0) {
-      return /* @__PURE__ */ new Map();
-    }
-    const candidateChunks = /* @__PURE__ */ new Set();
-    for (const token of queryTokens) {
-      const chunks = this.termToChunks.get(token);
-      if (chunks) {
-        for (const chunkId of chunks) {
-          candidateChunks.add(chunkId);
-        }
-      }
+  search(query, limit) {
+    const results = this.inner.search(query, limit ?? 100);
+    const map = /* @__PURE__ */ new Map();
+    for (const r of results) {
+      map.set(r.chunkId, r.score);
     }
-    const scores = /* @__PURE__ */ new Map();
-    const k1 = 1.2;
-    const b = 0.75;
-    const N = this.chunkTokens.size;
-    const avgDocLength = this.getAvgDocLength();
-    for (const chunkId of candidateChunks) {
-      const termFreq = this.chunkTokens.get(chunkId);
-      if (!termFreq) continue;
-      const docLength = Array.from(termFreq.values()).reduce((a, b2) => a + b2, 0);
-      let score = 0;
-      for (const term of queryTokens) {
-        const tf = termFreq.get(term) || 0;
-        if (tf === 0) continue;
-        const df = this.termToChunks.get(term)?.size || 0;
-        const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
-        const tfNorm = tf * (k1 + 1) / (tf + k1 * (1 - b + b * (docLength / avgDocLength)));
-        score += idf * tfNorm;
-      }
-      scores.set(chunkId, score);
-    }
-    const maxScore = Math.max(...scores.values(), 1);
-    for (const [chunkId, score] of scores) {
-      scores.set(chunkId, score / maxScore);
-    }
-    return scores;
+    return map;
   }
   hasChunk(chunkId) {
-    return this.chunkTokens.has(chunkId);
+    return this.inner.hasChunk(chunkId);
   }
   clear() {
-    this.termToChunks.clear();
-    this.chunkTokens.clear();
-    this.totalTokenCount = 0;
+    this.inner.clear();
   }
   getDocumentCount() {
-    return this.chunkTokens.size;
+    return this.inner.documentCount();
+  }
+};
+var Database = class {
+  inner;
+  constructor(dbPath) {
+    this.inner = new native.Database(dbPath);
+  }
+  embeddingExists(contentHash) {
+    return this.inner.embeddingExists(contentHash);
+  }
+  getEmbedding(contentHash) {
+    return this.inner.getEmbedding(contentHash) ?? null;
+  }
+  upsertEmbedding(contentHash, embedding, chunkText, model) {
+    this.inner.upsertEmbedding(contentHash, embedding, chunkText, model);
+  }
+  getMissingEmbeddings(contentHashes) {
+    return this.inner.getMissingEmbeddings(contentHashes);
+  }
+  upsertChunk(chunk) {
+    this.inner.upsertChunk(chunk);
+  }
+  getChunk(chunkId) {
+    return this.inner.getChunk(chunkId) ?? null;
   }
-  getAvgDocLength() {
-    const count = this.chunkTokens.size;
-    return count > 0 ? this.totalTokenCount / count : 100;
+  getChunksByFile(filePath) {
+    return this.inner.getChunksByFile(filePath);
   }
-  tokenize(text) {
-    return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => t.length > 2);
+  deleteChunksByFile(filePath) {
+    return this.inner.deleteChunksByFile(filePath);
+  }
+  addChunksToBranch(branch, chunkIds) {
+    this.inner.addChunksToBranch(branch, chunkIds);
+  }
+  clearBranch(branch) {
+    return this.inner.clearBranch(branch);
+  }
+  getBranchChunkIds(branch) {
+    return this.inner.getBranchChunkIds(branch);
+  }
+  getBranchDelta(branch, baseBranch) {
+    return this.inner.getBranchDelta(branch, baseBranch);
+  }
+  chunkExistsOnBranch(branch, chunkId) {
+    return this.inner.chunkExistsOnBranch(branch, chunkId);
+  }
+  getAllBranches() {
+    return this.inner.getAllBranches();
+  }
+  getMetadata(key) {
+    return this.inner.getMetadata(key) ?? null;
+  }
+  setMetadata(key, value) {
+    this.inner.setMetadata(key, value);
+  }
+  deleteMetadata(key) {
+    return this.inner.deleteMetadata(key);
+  }
+  gcOrphanEmbeddings() {
+    return this.inner.gcOrphanEmbeddings();
+  }
+  gcOrphanChunks() {
+    return this.inner.gcOrphanChunks();
+  }
+  getStats() {
+    return this.inner.getStats();
   }
 };
 
+// src/git/index.ts
+var import_fs3 = require("fs");
+var path4 = __toESM(require("path"), 1);
+var import_child_process = require("child_process");
+function isGitRepo(dir) {
+  return (0, import_fs3.existsSync)(path4.join(dir, ".git"));
+}
+function getCurrentBranch(repoRoot) {
+  const headPath = path4.join(repoRoot, ".git", "HEAD");
+  if (!(0, import_fs3.existsSync)(headPath)) {
+    return null;
+  }
+  try {
+    const headContent = (0, import_fs3.readFileSync)(headPath, "utf-8").trim();
+    const match = headContent.match(/^ref: refs\/heads\/(.+)$/);
+    if (match) {
+      return match[1];
+    }
+    if (/^[0-9a-f]{40}$/i.test(headContent)) {
+      return headContent.slice(0, 7);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getBaseBranch(repoRoot) {
+  const candidates = ["main", "master", "develop", "trunk"];
+  for (const candidate of candidates) {
+    const refPath = path4.join(repoRoot, ".git", "refs", "heads", candidate);
+    if ((0, import_fs3.existsSync)(refPath)) {
+      return candidate;
+    }
+    const packedRefsPath = path4.join(repoRoot, ".git", "packed-refs");
+    if ((0, import_fs3.existsSync)(packedRefsPath)) {
+      try {
+        const content = (0, import_fs3.readFileSync)(packedRefsPath, "utf-8");
+        if (content.includes(`refs/heads/${candidate}`)) {
+          return candidate;
+        }
+      } catch {
+      }
+    }
+  }
+  try {
+    const result = (0, import_child_process.execSync)("git remote show origin", {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const match = result.match(/HEAD branch: (.+)/);
+    if (match) {
+      return match[1].trim();
+    }
+  } catch {
+  }
+  return getCurrentBranch(repoRoot) ?? "main";
+}
+function getBranchOrDefault(repoRoot) {
+  if (!isGitRepo(repoRoot)) {
+    return "default";
+  }
+  return getCurrentBranch(repoRoot) ?? "default";
+}
+function getHeadPath(repoRoot) {
+  return path4.join(repoRoot, ".git", "HEAD");
+}
+
 // src/indexer/index.ts
+function float32ArrayToBuffer(arr) {
+  const float32 = new Float32Array(arr);
+  return Buffer.from(float32.buffer);
+}
+function bufferToFloat32Array(buf) {
+  return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+}
 var Indexer = class {
   config;
   projectRoot;
   indexPath;
   store = null;
   invertedIndex = null;
+  database = null;
   provider = null;
   detectedProvider = null;
   fileHashCache = /* @__PURE__ */ new Map();
   fileHashCachePath = "";
+  failedBatchesPath = "";
+  currentBranch = "default";
+  baseBranch = "main";
   constructor(projectRoot, config) {
     this.projectRoot = projectRoot;
     this.config = config;
     this.indexPath = this.getIndexPath();
     this.fileHashCachePath = path5.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path5.join(this.indexPath, "failed-batches.json");
   }
   getIndexPath() {
     if (this.config.scope === "global") {
@@ -2804,6 +2857,37 @@ var Indexer = class {
     }
     (0, import_fs4.writeFileSync)(this.fileHashCachePath, JSON.stringify(obj));
   }
+  loadFailedBatches() {
+    try {
+      if ((0, import_fs4.existsSync)(this.failedBatchesPath)) {
+        const data = (0, import_fs4.readFileSync)(this.failedBatchesPath, "utf-8");
+        return JSON.parse(data);
+      }
+    } catch {
+      return [];
+    }
+    return [];
+  }
+  saveFailedBatches(batches) {
+    if (batches.length === 0) {
+      if ((0, import_fs4.existsSync)(this.failedBatchesPath)) {
+        import_fs4.promises.unlink(this.failedBatchesPath).catch(() => {
+        });
+      }
+      return;
+    }
+    (0, import_fs4.writeFileSync)(this.failedBatchesPath, JSON.stringify(batches, null, 2));
+  }
+  addFailedBatch(batch, error) {
+    const existing = this.loadFailedBatches();
+    existing.push({
+      chunks: batch,
+      error,
+      attemptCount: 1,
+      lastAttempt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.saveFailedBatches(existing);
+  }
   async initialize() {
     this.detectedProvider = await detectEmbeddingProvider(this.config.embeddingProvider);
     if (!this.detectedProvider) {
@@ -2823,18 +2907,60 @@ var Indexer = class {
     if ((0, import_fs4.existsSync)(indexFilePath)) {
       this.store.load();
     }
-    this.invertedIndex = new InvertedIndex(this.indexPath);
-    this.invertedIndex.load();
+    const invertedIndexPath = path5.join(this.indexPath, "inverted-index.json");
+    this.invertedIndex = new InvertedIndex(invertedIndexPath);
+    try {
+      this.invertedIndex.load();
+    } catch {
+      if ((0, import_fs4.existsSync)(invertedIndexPath)) {
+        await import_fs4.promises.unlink(invertedIndexPath);
+      }
+      this.invertedIndex = new InvertedIndex(invertedIndexPath);
+    }
+    const dbPath = path5.join(this.indexPath, "codebase.db");
+    const dbIsNew = !(0, import_fs4.existsSync)(dbPath);
+    this.database = new Database(dbPath);
+    if (dbIsNew && this.store.count() > 0) {
+      this.migrateFromLegacyIndex();
+    }
+    if (isGitRepo(this.projectRoot)) {
+      this.currentBranch = getBranchOrDefault(this.projectRoot);
+      this.baseBranch = getBaseBranch(this.projectRoot);
+    } else {
+      this.currentBranch = "default";
+      this.baseBranch = "default";
+    }
+  }
+  migrateFromLegacyIndex() {
+    if (!this.store || !this.database) return;
+    const allMetadata = this.store.getAllMetadata();
+    const chunkIds = [];
+    for (const { key, metadata } of allMetadata) {
+      const chunkData = {
+        chunkId: key,
+        contentHash: metadata.hash,
+        filePath: metadata.filePath,
+        startLine: metadata.startLine,
+        endLine: metadata.endLine,
+        nodeType: metadata.chunkType,
+        name: metadata.name,
+        language: metadata.language
+      };
+      this.database.upsertChunk(chunkData);
+      chunkIds.push(key);
+    }
+    this.database.addChunksToBranch(this.currentBranch || "default", chunkIds);
   }
   async ensureInitialized() {
-    if (!this.store || !this.provider || !this.invertedIndex || !this.detectedProvider) {
+    if (!this.store || !this.provider || !this.invertedIndex || !this.detectedProvider || !this.database) {
       await this.initialize();
     }
     return {
       store: this.store,
       provider: this.provider,
       invertedIndex: this.invertedIndex,
-      detectedProvider: this.detectedProvider
+      detectedProvider: this.detectedProvider,
+      database: this.database
     };
   }
   async estimateCost() {
@@ -2848,7 +2974,7 @@ var Indexer = class {
     return createCostEstimate(files, detectedProvider);
   }
   async index(onProgress) {
-    const { store, provider, invertedIndex } = await this.ensureInitialized();
+    const { store, provider, invertedIndex, database, detectedProvider } = await this.ensureInitialized();
     const startTime = Date.now();
     const stats = {
       totalFiles: 0,
@@ -2925,11 +3051,30 @@ var Indexer = class {
         const relativePath = path5.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
+      let fileChunkCount = 0;
       for (const chunk of parsed.chunks) {
+        if (fileChunkCount >= this.config.indexing.maxChunksPerFile) {
+          break;
+        }
+        if (this.config.indexing.semanticOnly && chunk.chunkType === "other") {
+          continue;
+        }
         const id = generateChunkId(parsed.path, chunk);
         const contentHash = generateChunkHash(chunk);
         currentChunkIds.add(id);
+        const chunkData = {
+          chunkId: id,
+          contentHash,
+          filePath: parsed.path,
+          startLine: chunk.startLine,
+          endLine: chunk.endLine,
+          nodeType: chunk.chunkType,
+          name: chunk.name,
+          language: chunk.language
+        };
+        database.upsertChunk(chunkData);
         if (existingChunks.get(id) === contentHash) {
+          fileChunkCount++;
           continue;
         }
         const text = createEmbeddingText(chunk, parsed.path);
@@ -2942,7 +3087,8 @@ var Indexer = class {
           language: chunk.language,
           hash: contentHash
         };
-        pendingChunks.push({ id, text, content: chunk.content, metadata });
+        pendingChunks.push({ id, text, content: chunk.content, contentHash, metadata });
+        fileChunkCount++;
       }
     }
     let removedCount = 0;
@@ -2957,6 +3103,8 @@ var Indexer = class {
     stats.existingChunks = currentChunkIds.size - pendingChunks.length;
     stats.removedChunks = removedCount;
     if (pendingChunks.length === 0 && removedCount === 0) {
+      database.clearBranch(this.currentBranch);
+      database.addChunksToBranch(this.currentBranch, Array.from(currentChunkIds));
       this.fileHashCache = currentFileHashes;
       this.saveFileHashCache();
       stats.durationMs = Date.now() - startTime;
@@ -2970,6 +3118,8 @@ var Indexer = class {
       return stats;
     }
     if (pendingChunks.length === 0) {
+      database.clearBranch(this.currentBranch);
+      database.addChunksToBranch(this.currentBranch, Array.from(currentChunkIds));
       store.save();
       invertedIndex.save();
       this.fileHashCache = currentFileHashes;
@@ -2991,8 +3141,22 @@ var Indexer = class {
       chunksProcessed: 0,
       totalChunks: pendingChunks.length
     });
+    const allContentHashes = pendingChunks.map((c) => c.contentHash);
+    const missingHashes = new Set(database.getMissingEmbeddings(allContentHashes));
+    const chunksNeedingEmbedding = pendingChunks.filter((c) => missingHashes.has(c.contentHash));
+    const chunksWithExistingEmbedding = pendingChunks.filter((c) => !missingHashes.has(c.contentHash));
+    for (const chunk of chunksWithExistingEmbedding) {
+      const embeddingBuffer = database.getEmbedding(chunk.contentHash);
+      if (embeddingBuffer) {
+        const vector = bufferToFloat32Array(embeddingBuffer);
+        store.add(chunk.id, Array.from(vector), chunk.metadata);
+        invertedIndex.removeChunk(chunk.id);
+        invertedIndex.addChunk(chunk.id, chunk.content);
+        stats.indexedChunks++;
+      }
+    }
     const queue = new PQueue({ concurrency: 3 });
-    const dynamicBatches = createDynamicBatches(pendingChunks);
+    const dynamicBatches = createDynamicBatches(chunksNeedingEmbedding);
     for (const batch of dynamicBatches) {
       queue.add(async () => {
         try {
@@ -3017,7 +3181,15 @@ var Indexer = class {
             metadata: chunk.metadata
           }));
           store.addBatch(items);
-          for (const chunk of batch) {
+          for (let i = 0; i < batch.length; i++) {
+            const chunk = batch[i];
+            const embedding = result.embeddings[i];
+            database.upsertEmbedding(
+              chunk.contentHash,
+              float32ArrayToBuffer(embedding),
+              chunk.text,
+              detectedProvider.modelInfo.model
+            );
             invertedIndex.removeChunk(chunk.id);
             invertedIndex.addChunk(chunk.id, chunk.content);
           }
@@ -3032,6 +3204,7 @@ var Indexer = class {
           });
         } catch (error) {
           stats.failedChunks += batch.length;
+          this.addFailedBatch(batch, String(error));
           console.error(`Failed to embed batch after retries: ${error}`);
         }
       });
@@ -3044,11 +3217,16 @@ var Indexer = class {
       chunksProcessed: stats.indexedChunks,
       totalChunks: pendingChunks.length
     });
+    database.clearBranch(this.currentBranch);
+    database.addChunksToBranch(this.currentBranch, Array.from(currentChunkIds));
     store.save();
     invertedIndex.save();
     this.fileHashCache = currentFileHashes;
     this.saveFileHashCache();
     stats.durationMs = Date.now() - startTime;
+    if (stats.failedChunks > 0) {
+      stats.failedBatchesPath = this.failedBatchesPath;
+    }
     onProgress?.({
       phase: "complete",
       filesProcessed: files.length,
@@ -3059,18 +3237,24 @@ var Indexer = class {
     return stats;
   }
   async search(query, limit, options) {
-    const { store, provider } = await this.ensureInitialized();
+    const { store, provider, database } = await this.ensureInitialized();
     if (store.count() === 0) {
       return [];
     }
     const maxResults = limit ?? this.config.search.maxResults;
     const hybridWeight = options?.hybridWeight ?? this.config.search.hybridWeight;
+    const filterByBranch = options?.filterByBranch ?? true;
     const { embedding } = await provider.embed(query);
     const semanticResults = store.search(embedding, maxResults * 4);
     const keywordResults = await this.keywordSearch(query, maxResults * 4);
     const combined = this.fuseResults(semanticResults, keywordResults, hybridWeight, maxResults * 4);
+    let branchChunkIds = null;
+    if (filterByBranch && this.currentBranch !== "default") {
+      branchChunkIds = new Set(database.getBranchChunkIds(this.currentBranch));
+    }
     const filtered = combined.filter((r) => {
       if (r.score < this.config.search.minScore) return false;
+      if (branchChunkIds && !branchChunkIds.has(r.id)) return false;
       if (options?.fileType) {
         const ext = r.metadata.filePath.split(".").pop()?.toLowerCase();
         if (ext !== options.fileType.toLowerCase().replace(/^\./, "")) return false;
@@ -3172,7 +3356,9 @@ var Indexer = class {
       vectorCount: store.count(),
       provider: detectedProvider.provider,
       model: detectedProvider.modelInfo.model,
-      indexPath: this.indexPath
+      indexPath: this.indexPath,
+      currentBranch: this.currentBranch,
+      baseBranch: this.baseBranch
     };
   }
   async clearIndex() {
@@ -3183,7 +3369,7 @@ var Indexer = class {
     invertedIndex.save();
   }
   async healthCheck() {
-    const { store, invertedIndex } = await this.ensureInitialized();
+    const { store, invertedIndex, database } = await this.ensureInitialized();
     const allMetadata = store.getAllMetadata();
     const filePathsToChunkKeys = /* @__PURE__ */ new Map();
     for (const { key, metadata } of allMetadata) {
@@ -3200,6 +3386,7 @@ var Indexer = class {
           invertedIndex.removeChunk(key);
           removedCount++;
         }
+        database.deleteChunksByFile(filePath);
         removedFilePaths.push(filePath);
       }
     }
@@ -3207,7 +3394,77 @@ var Indexer = class {
       store.save();
       invertedIndex.save();
     }
-    return { removed: removedCount, filePaths: removedFilePaths };
+    const gcOrphanEmbeddings = database.gcOrphanEmbeddings();
+    const gcOrphanChunks = database.gcOrphanChunks();
+    return { removed: removedCount, filePaths: removedFilePaths, gcOrphanEmbeddings, gcOrphanChunks };
+  }
+  async retryFailedBatches() {
+    const { store, provider, invertedIndex } = await this.ensureInitialized();
+    const failedBatches = this.loadFailedBatches();
+    if (failedBatches.length === 0) {
+      return { succeeded: 0, failed: 0, remaining: 0 };
+    }
+    let succeeded = 0;
+    let failed = 0;
+    const stillFailing = [];
+    for (const batch of failedBatches) {
+      try {
+        const result = await pRetry(
+          async () => {
+            const texts = batch.chunks.map((c) => c.text);
+            return provider.embedBatch(texts);
+          },
+          {
+            retries: this.config.indexing.retries,
+            minTimeout: this.config.indexing.retryDelayMs
+          }
+        );
+        const items = batch.chunks.map((chunk, idx) => ({
+          id: chunk.id,
+          vector: result.embeddings[idx],
+          metadata: chunk.metadata
+        }));
+        store.addBatch(items);
+        for (const chunk of batch.chunks) {
+          invertedIndex.removeChunk(chunk.id);
+          invertedIndex.addChunk(chunk.id, chunk.content);
+        }
+        succeeded += batch.chunks.length;
+      } catch (error) {
+        failed += batch.chunks.length;
+        stillFailing.push({
+          ...batch,
+          attemptCount: batch.attemptCount + 1,
+          lastAttempt: (/* @__PURE__ */ new Date()).toISOString(),
+          error: String(error)
+        });
+      }
+    }
+    this.saveFailedBatches(stillFailing);
+    if (succeeded > 0) {
+      store.save();
+      invertedIndex.save();
+    }
+    return { succeeded, failed, remaining: stillFailing.length };
+  }
+  getFailedBatchesCount() {
+    return this.loadFailedBatches().length;
+  }
+  getCurrentBranch() {
+    return this.currentBranch;
+  }
+  getBaseBranch() {
+    return this.baseBranch;
+  }
+  refreshBranchInfo() {
+    if (isGitRepo(this.projectRoot)) {
+      this.currentBranch = getBranchOrDefault(this.projectRoot);
+      this.baseBranch = getBaseBranch(this.projectRoot);
+    }
+  }
+  async getDatabaseStats() {
+    const { database } = await this.ensureInitialized();
+    return database.getStats();
   }
 };
 
@@ -5034,9 +5291,82 @@ var FileWatcher = class {
     return this.watcher !== null;
   }
 };
+var GitHeadWatcher = class {
+  watcher = null;
+  projectRoot;
+  currentBranch = null;
+  onBranchChange = null;
+  debounceTimer = null;
+  debounceMs = 100;
+  // Short debounce for git operations
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  start(handler) {
+    if (this.watcher) {
+      return;
+    }
+    if (!isGitRepo(this.projectRoot)) {
+      return;
+    }
+    this.onBranchChange = handler;
+    this.currentBranch = getCurrentBranch(this.projectRoot);
+    const headPath = getHeadPath(this.projectRoot);
+    const refsPath = path6.join(this.projectRoot, ".git", "refs", "heads");
+    this.watcher = chokidar_default.watch([headPath, refsPath], {
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 50,
+        pollInterval: 10
+      }
+    });
+    this.watcher.on("change", () => this.handleHeadChange());
+    this.watcher.on("add", () => this.handleHeadChange());
+  }
+  handleHeadChange() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.checkBranchChange();
+    }, this.debounceMs);
+  }
+  async checkBranchChange() {
+    const newBranch = getCurrentBranch(this.projectRoot);
+    if (newBranch && newBranch !== this.currentBranch && this.onBranchChange) {
+      const oldBranch = this.currentBranch;
+      this.currentBranch = newBranch;
+      try {
+        await this.onBranchChange(oldBranch, newBranch);
+      } catch (error) {
+        console.error("Error handling branch change:", error);
+      }
+    } else if (newBranch) {
+      this.currentBranch = newBranch;
+    }
+  }
+  getCurrentBranch() {
+    return this.currentBranch;
+  }
+  stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    this.onBranchChange = null;
+  }
+  isRunning() {
+    return this.watcher !== null;
+  }
+};
 function createWatcherWithIndexer(indexer, projectRoot, config) {
-  const watcher = new FileWatcher(projectRoot, config);
-  watcher.start(async (changes) => {
+  const fileWatcher = new FileWatcher(projectRoot, config);
+  fileWatcher.start(async (changes) => {
     const hasAddOrChange = changes.some(
       (c) => c.type === "add" || c.type === "change"
     );
@@ -5045,7 +5375,22 @@ function createWatcherWithIndexer(indexer, projectRoot, config) {
       await indexer.index();
     }
   });
-  return watcher;
+  let gitWatcher = null;
+  if (isGitRepo(projectRoot)) {
+    gitWatcher = new GitHeadWatcher(projectRoot);
+    gitWatcher.start(async (oldBranch, newBranch) => {
+      console.log(`Branch changed: ${oldBranch ?? "(none)"} -> ${newBranch}`);
+      await indexer.index();
+    });
+  }
+  return {
+    fileWatcher,
+    gitWatcher,
+    stop() {
+      fileWatcher.stop();
+      gitWatcher?.stop();
+    }
+  };
 }
 
 // src/tools/index.ts
@@ -5129,13 +5474,19 @@ var index_health_check = (0, import_plugin.tool)({
   async execute() {
     const indexer = getIndexer();
     const result = await indexer.healthCheck();
-    if (result.removed === 0) {
+    if (result.removed === 0 && result.gcOrphanEmbeddings === 0 && result.gcOrphanChunks === 0) {
       return "Index is healthy. No stale entries found.";
     }
-    const lines = [
-      `Health check complete:`,
-      `  Removed stale entries: ${result.removed}`
-    ];
+    const lines = [`Health check complete:`];
+    if (result.removed > 0) {
+      lines.push(`  Removed stale entries: ${result.removed}`);
+    }
+    if (result.gcOrphanEmbeddings > 0) {
+      lines.push(`  Garbage collected orphan embeddings: ${result.gcOrphanEmbeddings}`);
+    }
+    if (result.gcOrphanChunks > 0) {
+      lines.push(`  Garbage collected orphan chunks: ${result.gcOrphanChunks}`);
+    }
     if (result.filePaths.length > 0) {
       lines.push(`  Cleaned paths: ${result.filePaths.join(", ")}`);
     }
@@ -5190,13 +5541,18 @@ function formatStatus(status) {
   if (!status.indexed) {
     return "Codebase is not indexed. Run index_codebase to create an index.";
   }
-  return [
+  const lines = [
     `Index status:`,
     `  Indexed chunks: ${status.vectorCount.toLocaleString()}`,
     `  Provider: ${status.provider}`,
     `  Model: ${status.model}`,
     `  Location: ${status.indexPath}`
-  ].join("\n");
+  ];
+  if (status.currentBranch !== "default") {
+    lines.push(`  Current branch: ${status.currentBranch}`);
+    lines.push(`  Base branch: ${status.baseBranch}`);
+  }
+  return lines.join("\n");
 }
 
 // src/index.ts
@@ -5233,6 +5589,39 @@ var plugin = async ({ directory }) => {
       index_codebase,
       index_status,
       index_health_check
+    },
+    async config(cfg) {
+      cfg.command = cfg.command ?? {};
+      cfg.command["search"] = {
+        description: "Search codebase by meaning using semantic search",
+        template: `Use the \`codebase_search\` tool to find code related to: $ARGUMENTS
+
+If the index doesn't exist yet, run \`index_codebase\` first.
+
+Return the most relevant results with file paths and line numbers.`
+      };
+      cfg.command["find"] = {
+        description: "Find code using hybrid approach (semantic + grep)",
+        template: `Find code related to: $ARGUMENTS
+
+Strategy:
+1. First use \`codebase_search\` to find semantically related code
+2. From the results, identify specific function/class names
+3. Use grep to find all occurrences of those identifiers
+4. Combine findings into a comprehensive answer
+
+If the semantic index doesn't exist, run \`index_codebase\` first.`
+      };
+      cfg.command["index"] = {
+        description: "Index the codebase for semantic search",
+        template: `Run the \`index_codebase\` tool to create or update the semantic search index.
+
+Show progress and final statistics including:
+- Number of files processed
+- Number of chunks indexed
+- Tokens used
+- Duration`
+      };
     }
   };
 };