opencode-codebase-index 0.1.11 → 0.2.1

package/dist/index.js

@@ -491,7 +491,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path7, checkUnignored, mode) {
+      test(path8, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -500,7 +500,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path7);
+          const matched = rule[mode].test(path8);
           if (!matched) {
             return;
           }
@@ -521,17 +521,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path7, originalPath, doThrow) => {
-      if (!isString(path7)) {
+    var checkPath = (path8, originalPath, doThrow) => {
+      if (!isString(path8)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path7) {
+      if (!path8) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path7)) {
+      if (checkPath.isNotRelative(path8)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -540,7 +540,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
+    var isNotRelative = (path8) => REGEX_TEST_INVALID_PATH.test(path8);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -570,19 +570,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path7 = originalPath && checkPath.convert(originalPath);
+        const path8 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path7,
+          path8,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path7, cache, checkUnignored, slices);
+        return this._t(path8, cache, checkUnignored, slices);
       }
-      checkIgnore(path7) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path7)) {
-          return this.test(path7);
+      checkIgnore(path8) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path8)) {
+          return this.test(path8);
         }
-        const slices = path7.split(SLASH2).filter(Boolean);
+        const slices = path8.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -595,18 +595,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path7, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path8, false, MODE_CHECK_IGNORE);
       }
-      _t(path7, cache, checkUnignored, slices) {
-        if (path7 in cache) {
-          return cache[path7];
+      _t(path8, cache, checkUnignored, slices) {
+        if (path8 in cache) {
+          return cache[path8];
         }
         if (!slices) {
-          slices = path7.split(SLASH2).filter(Boolean);
+          slices = path8.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path7] = this._rules.test(path7, checkUnignored, MODE_IGNORE);
+          return cache[path8] = this._rules.test(path8, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -614,29 +614,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path7] = parent.ignored ? parent : this._rules.test(path7, checkUnignored, MODE_IGNORE);
+        return cache[path8] = parent.ignored ? parent : this._rules.test(path8, checkUnignored, MODE_IGNORE);
       }
-      ignores(path7) {
-        return this._test(path7, this._ignoreCache, false).ignored;
+      ignores(path8) {
+        return this._test(path8, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path7) => !this.ignores(path7);
+        return (path8) => !this.ignores(path8);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path7) {
-        return this._test(path7, this._testCache, true);
+      test(path8) {
+        return this._test(path8, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
+    var isPathValid = (path8) => checkPath(path8 && checkPath.convert(path8), path8, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path7) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
+      checkPath.isNotRelative = (path8) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -652,8 +652,8 @@ var require_ignore = __commonJS({
 });
 
 // src/index.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import * as path6 from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import * as path7 from "path";
 
 // src/config/schema.ts
 var DEFAULT_INCLUDE = [
@@ -806,8 +806,8 @@ function getDefaultModelForProvider(provider) {
 }
 
 // src/indexer/index.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync, promises as fsPromises2 } from "fs";
-import * as path4 from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync, promises as fsPromises2 } from "fs";
+import * as path5 from "path";
 
 // node_modules/eventemitter3/index.mjs
 var import_index = __toESM(require_eventemitter3(), 1);
@@ -2188,7 +2188,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);
 }
@@ -2659,37 +2662,181 @@ var InvertedIndex = class {
     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;
+  }
+  getChunksByFile(filePath) {
+    return this.inner.getChunksByFile(filePath);
+  }
+  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
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync, statSync } from "fs";
+import * as path4 from "path";
+import { execSync } from "child_process";
+function isGitRepo(dir) {
+  return existsSync3(path4.join(dir, ".git"));
+}
+function getCurrentBranch(repoRoot) {
+  const headPath = path4.join(repoRoot, ".git", "HEAD");
+  if (!existsSync3(headPath)) {
+    return null;
+  }
+  try {
+    const headContent = readFileSync3(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 (existsSync3(refPath)) {
+      return candidate;
+    }
+    const packedRefsPath = path4.join(repoRoot, ".git", "packed-refs");
+    if (existsSync3(packedRefsPath)) {
+      try {
+        const content = readFileSync3(packedRefsPath, "utf-8");
+        if (content.includes(`refs/heads/${candidate}`)) {
+          return candidate;
+        }
+      } catch {
+      }
+    }
+  }
+  try {
+    const result = 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 = path4.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path4.join(this.indexPath, "failed-batches.json");
+    this.fileHashCachePath = path5.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path5.join(this.indexPath, "failed-batches.json");
   }
   getIndexPath() {
     if (this.config.scope === "global") {
       const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-      return path4.join(homeDir, ".opencode", "global-index");
+      return path5.join(homeDir, ".opencode", "global-index");
     }
-    return path4.join(this.projectRoot, ".opencode", "index");
+    return path5.join(this.projectRoot, ".opencode", "index");
   }
   loadFileHashCache() {
     try {
-      if (existsSync3(this.fileHashCachePath)) {
-        const data = readFileSync3(this.fileHashCachePath, "utf-8");
+      if (existsSync4(this.fileHashCachePath)) {
+        const data = readFileSync4(this.fileHashCachePath, "utf-8");
         const parsed = JSON.parse(data);
         this.fileHashCache = new Map(Object.entries(parsed));
       }
@@ -2706,8 +2853,8 @@ var Indexer = class {
   }
   loadFailedBatches() {
     try {
-      if (existsSync3(this.failedBatchesPath)) {
-        const data = readFileSync3(this.failedBatchesPath, "utf-8");
+      if (existsSync4(this.failedBatchesPath)) {
+        const data = readFileSync4(this.failedBatchesPath, "utf-8");
         return JSON.parse(data);
       }
     } catch {
@@ -2717,7 +2864,7 @@ var Indexer = class {
   }
   saveFailedBatches(batches) {
     if (batches.length === 0) {
-      if (existsSync3(this.failedBatchesPath)) {
+      if (existsSync4(this.failedBatchesPath)) {
         fsPromises2.unlink(this.failedBatchesPath).catch(() => {
         });
       }
@@ -2748,25 +2895,66 @@ var Indexer = class {
     );
     await fsPromises2.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.detectedProvider.modelInfo.dimensions;
-    const storePath = path4.join(this.indexPath, "vectors");
+    const storePath = path5.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path4.join(this.indexPath, "vectors.usearch");
-    if (existsSync3(indexFilePath)) {
+    const indexFilePath = path5.join(this.indexPath, "vectors.usearch");
+    if (existsSync4(indexFilePath)) {
       this.store.load();
     }
-    const invertedIndexPath = path4.join(this.indexPath, "inverted-index.json");
+    const invertedIndexPath = path5.join(this.indexPath, "inverted-index.json");
     this.invertedIndex = new InvertedIndex(invertedIndexPath);
-    this.invertedIndex.load();
+    try {
+      this.invertedIndex.load();
+    } catch {
+      if (existsSync4(invertedIndexPath)) {
+        await fsPromises2.unlink(invertedIndexPath);
+      }
+      this.invertedIndex = new InvertedIndex(invertedIndexPath);
+    }
+    const dbPath = path5.join(this.indexPath, "codebase.db");
+    const dbIsNew = !existsSync4(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() {
@@ -2780,7 +2968,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,
@@ -2854,7 +3042,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path4.relative(this.projectRoot, parsed.path);
+        const relativePath = path5.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -2868,6 +3056,17 @@ var Indexer = class {
         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;
@@ -2882,7 +3081,7 @@ 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++;
       }
     }
@@ -2898,6 +3097,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;
@@ -2911,6 +3112,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;
@@ -2932,8 +3135,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 {
@@ -2958,7 +3175,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);
           }
@@ -2986,6 +3211,8 @@ 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;
@@ -3004,18 +3231,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;
@@ -3117,7 +3350,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() {
@@ -3128,7 +3363,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) {
@@ -3139,12 +3374,13 @@ var Indexer = class {
     const removedFilePaths = [];
     let removedCount = 0;
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!existsSync3(filePath)) {
+      if (!existsSync4(filePath)) {
         for (const key of chunkKeys) {
           store.remove(key);
           invertedIndex.removeChunk(key);
           removedCount++;
         }
+        database.deleteChunksByFile(filePath);
         removedFilePaths.push(filePath);
       }
     }
@@ -3152,7 +3388,9 @@ 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();
@@ -3206,6 +3444,22 @@ var Indexer = class {
   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();
+  }
 };
 
 // node_modules/chokidar/index.js
@@ -3298,7 +3552,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path7) => statMethod(path7, { bigint: true });
+      this._stat = (path8) => statMethod(path8, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -3323,8 +3577,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path7, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path7));
+          const { path: path8, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path8));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -3364,20 +3618,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path7, depth) {
+  async _exploreDir(path8, depth) {
     let files;
     try {
-      files = await readdir(path7, this._rdOptions);
+      files = await readdir(path8, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path7 };
+    return { files, depth, path: path8 };
   }
-  async _formatEntry(dirent, path7) {
+  async _formatEntry(dirent, path8) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path7, basename3));
+      const fullPath = presolve(pjoin(path8, basename3));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -3777,16 +4031,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path7, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path8, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path7);
-    emitRaw(rawEvent, evPath, { watchedPath: path7 });
-    if (evPath && path7 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path7, evPath), KEY_LISTENERS, sp.join(path7, evPath));
+    listener(path8);
+    emitRaw(rawEvent, evPath, { watchedPath: path8 });
+    if (evPath && path8 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path8, evPath), KEY_LISTENERS, sp.join(path8, evPath));
     }
   };
   try {
-    return fs_watch(path7, {
+    return fs_watch(path8, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -3802,12 +4056,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path7, fullPath, options, handlers) => {
+var setFsWatchListener = (path8, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path7, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path8, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -3818,7 +4072,7 @@ var setFsWatchListener = (path7, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path7,
+      path8,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -3833,7 +4087,7 @@ var setFsWatchListener = (path7, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path7, "r");
+          const fd = await open(path8, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -3864,7 +4118,7 @@ var setFsWatchListener = (path7, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path7, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -3886,7 +4140,7 @@ var setFsWatchFileListener = (path7, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path7, curr));
+          foreach(cont.listeners, (listener2) => listener2(path8, curr));
         }
       })
     };
@@ -3916,13 +4170,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path7, listener) {
+  _watchWithNodeFs(path8, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path7);
-    const basename3 = sp.basename(path7);
+    const directory = sp.dirname(path8);
+    const basename3 = sp.basename(path8);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path7);
+    const absolutePath = sp.resolve(path8);
     const options = {
       persistent: opts.persistent
     };
@@ -3932,12 +4186,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path7, absolutePath, options, {
+      closer = setFsWatchFileListener(path8, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path7, absolutePath, options, {
+      closer = setFsWatchListener(path8, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -3959,7 +4213,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path7, newStats) => {
+    const listener = async (path8, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -3973,11 +4227,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path7);
+            this.fsw._closeFile(path8);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path7, closer2);
+              this.fsw._addPathCloser(path8, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -4009,7 +4263,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path7, item) {
+  async _handleSymlink(entry, directory, path8, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -4019,7 +4273,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path7);
+        linkPath = await fsrealpath(path8);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -4029,12 +4283,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path7, entry.stats);
+          this.fsw._emit(EV.CHANGE, path8, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path7, entry.stats);
+        this.fsw._emit(EV.ADD, path8, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -4064,9 +4318,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path7 = sp.join(directory, item);
+      let path8 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path7, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path8, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -4075,8 +4329,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path7 = sp.join(dir, sp.relative(dir, path7));
-        this._addToNodeFs(path7, initialAdd, wh, depth + 1);
+        path8 = sp.join(dir, sp.relative(dir, path8));
+        this._addToNodeFs(path8, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve4, reject) => {
@@ -4145,13 +4399,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path7, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path8, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path7) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path8) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path7);
+    const wh = this.fsw._getWatchHelpers(path8);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -4167,8 +4421,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path7);
-        const targetPath = follow ? await fsrealpath(path7) : path7;
+        const absPath = sp.resolve(path8);
+        const targetPath = follow ? await fsrealpath(path8) : path8;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -4178,29 +4432,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path7) : path7;
+        const targetPath = follow ? await fsrealpath(path8) : path8;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path7, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path8, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path7), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path8), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path7, closer);
+        this.fsw._addPathCloser(path8, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path7;
+        return path8;
       }
     }
   }
@@ -4243,24 +4497,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path7) {
-  if (typeof path7 !== "string")
+function normalizePath(path8) {
+  if (typeof path8 !== "string")
     throw new Error("string expected");
-  path7 = sp2.normalize(path7);
-  path7 = path7.replace(/\\/g, "/");
+  path8 = sp2.normalize(path8);
+  path8 = path8.replace(/\\/g, "/");
   let prepend = false;
-  if (path7.startsWith("//"))
+  if (path8.startsWith("//"))
     prepend = true;
-  path7 = path7.replace(DOUBLE_SLASH_RE, "/");
+  path8 = path8.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path7 = "/" + path7;
-  return path7;
+    path8 = "/" + path8;
+  return path8;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path7 = normalizePath(testString);
+  const path8 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path7, stats)) {
+    if (pattern(path8, stats)) {
       return true;
     }
   }
@@ -4298,19 +4552,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path7) => toUnix(sp2.normalize(toUnix(path7)));
-var normalizeIgnored = (cwd = "") => (path7) => {
-  if (typeof path7 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path7) ? path7 : sp2.join(cwd, path7));
+var normalizePathToUnix = (path8) => toUnix(sp2.normalize(toUnix(path8)));
+var normalizeIgnored = (cwd = "") => (path8) => {
+  if (typeof path8 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path8) ? path8 : sp2.join(cwd, path8));
   } else {
-    return path7;
+    return path8;
   }
 };
-var getAbsolutePath = (path7, cwd) => {
-  if (sp2.isAbsolute(path7)) {
-    return path7;
+var getAbsolutePath = (path8, cwd) => {
+  if (sp2.isAbsolute(path8)) {
+    return path8;
   }
-  return sp2.join(cwd, path7);
+  return sp2.join(cwd, path8);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -4375,10 +4629,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path7, follow, fsw) {
+  constructor(path8, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path7;
-    this.path = path7 = path7.replace(REPLACER_RE, "");
+    const watchPath = path8;
+    this.path = path8 = path8.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -4518,20 +4772,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path7) => {
-        const absPath = getAbsolutePath(path7, cwd);
+      paths = paths.map((path8) => {
+        const absPath = getAbsolutePath(path8, cwd);
         return absPath;
       });
     }
-    paths.forEach((path7) => {
-      this._removeIgnoredPath(path7);
+    paths.forEach((path8) => {
+      this._removeIgnoredPath(path8);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path7) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path7, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path8) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path8, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -4553,17 +4807,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path7) => {
-      if (!sp2.isAbsolute(path7) && !this._closers.has(path7)) {
+    paths.forEach((path8) => {
+      if (!sp2.isAbsolute(path8) && !this._closers.has(path8)) {
         if (cwd)
-          path7 = sp2.join(cwd, path7);
-        path7 = sp2.resolve(path7);
+          path8 = sp2.join(cwd, path8);
+        path8 = sp2.resolve(path8);
       }
-      this._closePath(path7);
-      this._addIgnoredPath(path7);
-      if (this._watched.has(path7)) {
+      this._closePath(path8);
+      this._addIgnoredPath(path8);
+      if (this._watched.has(path8)) {
         this._addIgnoredPath({
-          path: path7,
+          path: path8,
           recursive: true
         });
       }
@@ -4627,38 +4881,38 @@ var FSWatcher = class extends EventEmitter2 {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path7, stats) {
+  async _emit(event, path8, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path7 = sp2.normalize(path7);
+      path8 = sp2.normalize(path8);
     if (opts.cwd)
-      path7 = sp2.relative(opts.cwd, path7);
-    const args = [path7];
+      path8 = sp2.relative(opts.cwd, path8);
+    const args = [path8];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path7))) {
+    if (awf && (pw = this._pendingWrites.get(path8))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path7, [event, ...args]);
+        this._pendingUnlinks.set(path8, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path8) => {
+          this._pendingUnlinks.forEach((entry, path9) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path8);
+            this._pendingUnlinks.delete(path9);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path7)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path8)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path7);
+        this._pendingUnlinks.delete(path8);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -4676,16 +4930,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path7, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path8, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path7, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path8, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path7) : path7;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path8) : path8;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -4716,23 +4970,23 @@ var FSWatcher = class extends EventEmitter2 {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path7, timeout) {
+  _throttle(actionType, path8, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path7);
+    const actionPath = action.get(path8);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path7);
+      const item = action.get(path8);
       const count = item ? item.count : 0;
-      action.delete(path7);
+      action.delete(path8);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -4740,7 +4994,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path7, thr);
+    action.set(path8, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -4754,44 +5008,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path7, threshold, event, awfEmit) {
+  _awaitWriteFinish(path8, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path7;
-    if (this.options.cwd && !sp2.isAbsolute(path7)) {
-      fullPath = sp2.join(this.options.cwd, path7);
+    let fullPath = path8;
+    if (this.options.cwd && !sp2.isAbsolute(path8)) {
+      fullPath = sp2.join(this.options.cwd, path8);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path7)) {
+        if (err || !writes.has(path8)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path7).lastChange = now2;
+          writes.get(path8).lastChange = now2;
         }
-        const pw = writes.get(path7);
+        const pw = writes.get(path8);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path7);
+          writes.delete(path8);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path7)) {
-      writes.set(path7, {
+    if (!writes.has(path8)) {
+      writes.set(path8, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path7);
+          writes.delete(path8);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -4802,8 +5056,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path7, stats) {
-    if (this.options.atomic && DOT_RE.test(path7))
+  _isIgnored(path8, stats) {
+    if (this.options.atomic && DOT_RE.test(path8))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -4813,17 +5067,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path7, stats);
+    return this._userIgnored(path8, stats);
   }
-  _isntIgnored(path7, stat4) {
-    return !this._isIgnored(path7, stat4);
+  _isntIgnored(path8, stat4) {
+    return !this._isIgnored(path8, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path7) {
-    return new WatchHelper(path7, this.options.followSymlinks, this);
+  _getWatchHelpers(path8) {
+    return new WatchHelper(path8, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -4855,63 +5109,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path7 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path7);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path7) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path7, 100))
+    const path8 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path8);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path8) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path8, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path7);
+    const wp = this._getWatchedDir(path8);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path7, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path8, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path7;
+    let relPath = path8;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path7);
+      relPath = sp2.relative(this.options.cwd, path8);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path7);
+    this._watched.delete(path8);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path7))
-      this._emit(eventName, path7);
-    this._closePath(path7);
+    if (wasTracked && !this._isIgnored(path8))
+      this._emit(eventName, path8);
+    this._closePath(path8);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path7) {
-    this._closeFile(path7);
-    const dir = sp2.dirname(path7);
-    this._getWatchedDir(dir).remove(sp2.basename(path7));
+  _closePath(path8) {
+    this._closeFile(path8);
+    const dir = sp2.dirname(path8);
+    this._getWatchedDir(dir).remove(sp2.basename(path8));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path7) {
-    const closers = this._closers.get(path7);
+  _closeFile(path8) {
+    const closers = this._closers.get(path8);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path7);
+    this._closers.delete(path8);
   }
-  _addPathCloser(path7, closer) {
+  _addPathCloser(path8, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path7);
+    let list = this._closers.get(path8);
     if (!list) {
       list = [];
-      this._closers.set(path7, list);
+      this._closers.set(path8, list);
     }
     list.push(closer);
   }
@@ -4941,7 +5195,7 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/index.ts
-import * as path5 from "path";
+import * as path6 from "path";
 var FileWatcher = class {
   watcher = null;
   projectRoot;
@@ -4962,7 +5216,7 @@ var FileWatcher = class {
     const ignoreFilter = createIgnoreFilter(this.projectRoot);
     this.watcher = chokidar_default.watch(this.projectRoot, {
       ignored: (filePath) => {
-        const relativePath = path5.relative(this.projectRoot, filePath);
+        const relativePath = path6.relative(this.projectRoot, filePath);
         if (!relativePath) return false;
         if (ignoreFilter.ignores(relativePath)) {
           return true;
@@ -5006,7 +5260,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path7, type]) => ({ path: path7, type })
+      ([path8, type]) => ({ path: path8, type })
     );
     this.pendingChanges.clear();
     try {
@@ -5031,9 +5285,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"
     );
@@ -5042,7 +5369,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
@@ -5126,13 +5468,19 @@ var index_health_check = 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(", ")}`);
     }
@@ -5187,21 +5535,26 @@ 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
 function loadPluginConfig(projectRoot) {
-  const configPath = path6.join(projectRoot, ".opencode", "codebase-index.json");
+  const configPath = path7.join(projectRoot, ".opencode", "codebase-index.json");
   try {
-    if (existsSync4(configPath)) {
-      const content = readFileSync4(configPath, "utf-8");
+    if (existsSync5(configPath)) {
+      const content = readFileSync5(configPath, "utf-8");
       return JSON.parse(content);
     }
   } catch {