bluera-knowledge 0.17.1 → 0.18.0

package/dist/{chunk-VKTVMW45.js → chunk-RDDGZIDL.js}

@@ -1,3 +1,11 @@
+import {
+  createDocumentId,
+  createStoreId
+} from "./chunk-CLIMKLTW.js";
+import {
+  parseIgnorePatternsForScanning
+} from "./chunk-HXBIIMYL.js";
+
 // src/analysis/adapter-registry.ts
 var AdapterRegistry = class _AdapterRegistry {
   static instance;
@@ -109,18 +117,94 @@ var AdapterRegistry = class _AdapterRegistry {
 };
 
 // src/logging/logger.ts
-import { mkdirSync, existsSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
+import { mkdirSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 import pino from "pino";
+
+// src/services/project-root.service.ts
+import { existsSync, statSync, realpathSync } from "fs";
+import { dirname, join, normalize, sep } from "path";
+var ProjectRootService = class {
+  /**
+   * Resolve project root directory using hierarchical detection.
+   */
+  static resolve(options) {
+    if (options?.projectRoot !== void 0 && options.projectRoot !== "") {
+      return this.normalize(options.projectRoot);
+    }
+    const projectRootEnv = process.env["PROJECT_ROOT"];
+    if (projectRootEnv !== void 0 && projectRootEnv !== "") {
+      return this.normalize(projectRootEnv);
+    }
+    const gitRoot = this.findGitRoot(process.cwd());
+    if (gitRoot !== null) {
+      return gitRoot;
+    }
+    const pwdEnv = process.env["PWD"];
+    if (pwdEnv !== void 0 && pwdEnv !== "") {
+      return this.normalize(pwdEnv);
+    }
+    return process.cwd();
+  }
+  /**
+   * Find git repository root by walking up the directory tree looking for .git
+   */
+  static findGitRoot(startPath) {
+    let currentPath = normalize(startPath);
+    const root = normalize(sep);
+    while (currentPath !== root) {
+      const gitPath = join(currentPath, ".git");
+      if (existsSync(gitPath)) {
+        try {
+          const stats = statSync(gitPath);
+          if (stats.isDirectory() || stats.isFile()) {
+            return currentPath;
+          }
+        } catch {
+        }
+      }
+      const parentPath = dirname(currentPath);
+      if (parentPath === currentPath) {
+        break;
+      }
+      currentPath = parentPath;
+    }
+    return null;
+  }
+  /**
+   * Normalize path by resolving symlinks and normalizing separators
+   */
+  static normalize(path4) {
+    try {
+      const realPath = realpathSync(path4);
+      return normalize(realPath);
+    } catch {
+      return normalize(path4);
+    }
+  }
+  /**
+   * Validate that a path exists and is a directory
+   */
+  static validate(path4) {
+    try {
+      const stats = statSync(path4);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/logging/logger.ts
 var VALID_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
 var VALID_LEVELS_SET = new Set(VALID_LEVELS);
 function getLogDir() {
-  return join(homedir(), ".bluera", "bluera-knowledge", "logs");
+  const projectRoot = ProjectRootService.resolve();
+  return join2(projectRoot, ".bluera", "bluera-knowledge", "logs");
 }
 function ensureLogDir() {
   const logDir = getLogDir();
-  if (!existsSync(logDir)) {
+  if (!existsSync2(logDir)) {
     mkdirSync(logDir, { recursive: true });
   }
   return logDir;
@@ -144,7 +228,7 @@ function initializeLogger() {
     return rootLogger;
   }
   const logDir = ensureLogDir();
-  const logFile = join(logDir, "app.log");
+  const logFile = join2(logDir, "app.log");
   const level = getLogLevel();
   const options = {
     level,
@@ -196,13 +280,13 @@ function shutdownLogger() {
 
 // src/logging/payload.ts
 import { createHash } from "crypto";
-import { writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
 var MAX_PREVIEW_LENGTH = 500;
 var PAYLOAD_DUMP_THRESHOLD = 1e4;
 function getPayloadDir() {
-  const dir = join2(getLogDirectory(), "payload");
-  if (!existsSync2(dir)) {
+  const dir = join3(getLogDirectory(), "payload");
+  if (!existsSync3(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   return dir;
@@ -219,7 +303,7 @@ function summarizePayload(content, type, identifier, dumpFull = isLevelEnabled("
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const safeId = safeFilename(identifier);
     const filename = `${timestamp}-${type}-${safeId}-${hash}.json`;
-    const filepath = join2(getPayloadDir(), filename);
+    const filepath = join3(getPayloadDir(), filename);
     writeFileSync(
       filepath,
       JSON.stringify(
@@ -292,6 +376,23 @@ function err(error) {
   return { success: false, error };
 }
 
+// src/utils/atomic-write.ts
+import { writeFileSync as writeFileSync2, renameSync, mkdirSync as mkdirSync3 } from "fs";
+import { writeFile, rename, mkdir } from "fs/promises";
+import { dirname as dirname2 } from "path";
+async function atomicWriteFile(filePath, content) {
+  await mkdir(dirname2(filePath), { recursive: true });
+  const tempPath = `${filePath}.tmp.${String(Date.now())}.${String(process.pid)}`;
+  await writeFile(tempPath, content, "utf-8");
+  await rename(tempPath, filePath);
+}
+function atomicWriteFileSync(filePath, content) {
+  mkdirSync3(dirname2(filePath), { recursive: true });
+  const tempPath = `${filePath}.tmp.${String(Date.now())}.${String(process.pid)}`;
+  writeFileSync2(tempPath, content, "utf-8");
+  renameSync(tempPath, filePath);
+}
+
 // src/services/job.service.ts
 var JobService = class {
   jobsDir;
@@ -520,13 +621,13 @@ var JobService = class {
    */
   writeJob(job) {
     const jobFile = path.join(this.jobsDir, `${job.id}.json`);
-    fs.writeFileSync(jobFile, JSON.stringify(job, null, 2), "utf-8");
+    atomicWriteFileSync(jobFile, JSON.stringify(job, null, 2));
   }
 };
 
 // src/services/code-graph.service.ts
-import { readFile, writeFile, mkdir, rm } from "fs/promises";
-import { join as join3, dirname } from "path";
+import { readFile, writeFile as writeFile2, mkdir as mkdir2, rm } from "fs/promises";
+import { join as join4, dirname as dirname3 } from "path";
 
 // src/analysis/ast-parser.ts
 import { parse } from "@babel/parser";
@@ -1683,11 +1784,31 @@ var CodeGraphService = class {
   parser;
   parserFactory;
   graphCache;
+  cacheListeners;
   constructor(dataDir, pythonBridge) {
     this.dataDir = dataDir;
     this.parser = new ASTParser();
     this.parserFactory = new ParserFactory(pythonBridge);
     this.graphCache = /* @__PURE__ */ new Map();
+    this.cacheListeners = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Subscribe to cache invalidation events.
+   * Returns an unsubscribe function.
+   */
+  onCacheInvalidation(listener) {
+    this.cacheListeners.add(listener);
+    return () => {
+      this.cacheListeners.delete(listener);
+    };
+  }
+  /**
+   * Emit a cache invalidation event to all listeners.
+   */
+  emitCacheInvalidation(event) {
+    for (const listener of this.cacheListeners) {
+      listener(event);
+    }
   }
   /**
    * Build a code graph from source files.
@@ -1743,9 +1864,10 @@ var CodeGraphService = class {
    */
   async saveGraph(storeId, graph) {
     const graphPath = this.getGraphPath(storeId);
-    await mkdir(dirname(graphPath), { recursive: true });
+    await mkdir2(dirname3(graphPath), { recursive: true });
     const serialized = graph.toJSON();
-    await writeFile(graphPath, JSON.stringify(serialized, null, 2));
+    await writeFile2(graphPath, JSON.stringify(serialized, null, 2));
+    this.emitCacheInvalidation({ type: "graph-updated", storeId });
   }
   /**
    * Delete the code graph file for a store.
@@ -1755,6 +1877,7 @@ var CodeGraphService = class {
     const graphPath = this.getGraphPath(storeId);
     await rm(graphPath, { force: true });
     this.graphCache.delete(storeId);
+    this.emitCacheInvalidation({ type: "graph-deleted", storeId });
   }
   /**
    * Load a code graph for a store.
@@ -1856,7 +1979,7 @@ var CodeGraphService = class {
     this.graphCache.clear();
   }
   getGraphPath(storeId) {
-    return join3(this.dataDir, "graphs", `${storeId}.json`);
+    return join4(this.dataDir, "graphs", `${storeId}.json`);
   }
   /**
    * Type guard for SerializedGraph structure.
@@ -1900,83 +2023,9 @@ var CodeGraphService = class {
 };
 
 // src/services/config.service.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join5, resolve } from "path";
-
-// src/services/project-root.service.ts
-import { existsSync as existsSync3, statSync, realpathSync } from "fs";
-import { dirname as dirname2, join as join4, normalize, sep } from "path";
-var ProjectRootService = class {
-  /**
-   * Resolve project root directory using hierarchical detection.
-   */
-  static resolve(options) {
-    if (options?.projectRoot !== void 0 && options.projectRoot !== "") {
-      return this.normalize(options.projectRoot);
-    }
-    const projectRootEnv = process.env["PROJECT_ROOT"];
-    if (projectRootEnv !== void 0 && projectRootEnv !== "") {
-      return this.normalize(projectRootEnv);
-    }
-    const pwdEnv = process.env["PWD"];
-    if (pwdEnv !== void 0 && pwdEnv !== "") {
-      return this.normalize(pwdEnv);
-    }
-    const gitRoot = this.findGitRoot(process.cwd());
-    if (gitRoot !== null) {
-      return gitRoot;
-    }
-    return process.cwd();
-  }
-  /**
-   * Find git repository root by walking up the directory tree looking for .git
-   */
-  static findGitRoot(startPath) {
-    let currentPath = normalize(startPath);
-    const root = normalize(sep);
-    while (currentPath !== root) {
-      const gitPath = join4(currentPath, ".git");
-      if (existsSync3(gitPath)) {
-        try {
-          const stats = statSync(gitPath);
-          if (stats.isDirectory() || stats.isFile()) {
-            return currentPath;
-          }
-        } catch {
-        }
-      }
-      const parentPath = dirname2(currentPath);
-      if (parentPath === currentPath) {
-        break;
-      }
-      currentPath = parentPath;
-    }
-    return null;
-  }
-  /**
-   * Normalize path by resolving symlinks and normalizing separators
-   */
-  static normalize(path4) {
-    try {
-      const realPath = realpathSync(path4);
-      return normalize(realPath);
-    } catch {
-      return normalize(path4);
-    }
-  }
-  /**
-   * Validate that a path exists and is a directory
-   */
-  static validate(path4) {
-    try {
-      const stats = statSync(path4);
-      return stats.isDirectory();
-    } catch {
-      return false;
-    }
-  }
-};
+import { readFile as readFile2, access } from "fs/promises";
+import { homedir } from "os";
+import { isAbsolute, join as join5, resolve } from "path";
 
 // src/types/config.ts
 var DEFAULT_CONFIG = {
@@ -1984,8 +2033,7 @@ var DEFAULT_CONFIG = {
   dataDir: ".bluera/bluera-knowledge/data",
   embedding: {
     model: "Xenova/all-MiniLM-L6-v2",
-    batchSize: 32,
-    dimensions: 384
+    batchSize: 32
   },
   indexing: {
     concurrency: 4,
@@ -1995,13 +2043,7 @@ var DEFAULT_CONFIG = {
   },
   search: {
     defaultMode: "hybrid",
-    defaultLimit: 10,
-    minScore: 0.5,
-    rrf: {
-      k: 40,
-      vectorWeight: 0.7,
-      ftsWeight: 0.3
-    }
+    defaultLimit: 10
   },
   crawl: {
     userAgent: "BlueraKnowledge/1.0",
@@ -2014,6 +2056,34 @@ var DEFAULT_CONFIG = {
   }
 };
 
+// src/utils/deep-merge.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function deepMerge(defaults, overrides) {
+  if (!isPlainObject(overrides)) {
+    return { ...defaults };
+  }
+  const defaultsRecord = defaults;
+  return deepMergeRecords(defaultsRecord, overrides);
+}
+function deepMergeRecords(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const defaultValue = defaults[key];
+    const overrideValue = overrides[key];
+    if (overrideValue === void 0) {
+      continue;
+    }
+    if (isPlainObject(defaultValue) && isPlainObject(overrideValue)) {
+      result[key] = deepMergeRecords(defaultValue, overrideValue);
+    } else {
+      result[key] = overrideValue;
+    }
+  }
+  return result;
+}
+
 // src/services/config.service.ts
 var DEFAULT_CONFIG_PATH = ".bluera/bluera-knowledge/config.json";
 async function fileExists(path4) {
@@ -2027,20 +2097,27 @@ async function fileExists(path4) {
 var ConfigService = class {
   configPath;
   dataDir;
+  projectRoot;
   config = null;
   constructor(configPath, dataDir, projectRoot) {
-    const root = projectRoot ?? ProjectRootService.resolve();
+    this.projectRoot = projectRoot ?? ProjectRootService.resolve();
     if (configPath !== void 0 && configPath !== "") {
-      this.configPath = configPath;
+      this.configPath = this.expandPath(configPath, this.projectRoot);
     } else {
-      this.configPath = join5(root, DEFAULT_CONFIG_PATH);
+      this.configPath = join5(this.projectRoot, DEFAULT_CONFIG_PATH);
     }
     if (dataDir !== void 0 && dataDir !== "") {
-      this.dataDir = dataDir;
+      this.dataDir = this.expandPath(dataDir, this.projectRoot);
     } else {
-      this.dataDir = this.expandPath(DEFAULT_CONFIG.dataDir, root);
+      this.dataDir = this.expandPath(DEFAULT_CONFIG.dataDir, this.projectRoot);
     }
   }
+  /**
+   * Get the resolved project root directory.
+   */
+  resolveProjectRoot() {
+    return this.projectRoot;
+  }
   async load() {
     if (this.config !== null) {
       return this.config;
@@ -2053,7 +2130,7 @@ var ConfigService = class {
     }
     const content = await readFile2(this.configPath, "utf-8");
     try {
-      this.config = { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+      this.config = deepMerge(DEFAULT_CONFIG, JSON.parse(content));
     } catch (error) {
       throw new Error(
         `Failed to parse config file at ${this.configPath}: ${error instanceof Error ? error.message : String(error)}`
@@ -2062,8 +2139,7 @@ var ConfigService = class {
     return this.config;
   }
   async save(config) {
-    await mkdir2(dirname3(this.configPath), { recursive: true });
-    await writeFile2(this.configPath, JSON.stringify(config, null, 2));
+    await atomicWriteFile(this.configPath, JSON.stringify(config, null, 2));
     this.config = config;
   }
   resolveDataDir() {
@@ -2074,9 +2150,9 @@ var ConfigService = class {
   }
   expandPath(path4, baseDir) {
     if (path4.startsWith("~")) {
-      return path4.replace("~", homedir2());
+      return path4.replace("~", homedir());
     }
-    if (!path4.startsWith("/")) {
+    if (!isAbsolute(path4)) {
       return resolve(baseDir, path4);
     }
     return path4;
@@ -2182,9 +2258,9 @@ ${REQUIRED_PATTERNS.join("\n")}
 };
 
 // src/services/index.service.ts
-import { createHash as createHash2 } from "crypto";
-import { readFile as readFile4, readdir } from "fs/promises";
-import { join as join7, extname, basename } from "path";
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile5, readdir } from "fs/promises";
+import { join as join7, extname, basename, relative } from "path";
 
 // src/services/chunking.service.ts
 var CHUNK_PRESETS = {
@@ -2196,6 +2272,11 @@ var ChunkingService = class _ChunkingService {
   chunkSize;
   chunkOverlap;
   constructor(config) {
+    if (config.chunkOverlap >= config.chunkSize) {
+      throw new Error(
+        `chunkOverlap (${String(config.chunkOverlap)}) must be less than chunkSize (${String(config.chunkSize)})`
+      );
+    }
     this.chunkSize = config.chunkSize;
     this.chunkOverlap = config.chunkOverlap;
   }
@@ -2290,7 +2371,7 @@ var ChunkingService = class _ChunkingService {
    * Splits on top-level declarations to keep functions/classes together.
    */
   chunkCode(text) {
-    const declarationRegex = /^(?:\/\*\*[\s\S]*?\*\/\s*)?(?:export\s+)?(?:async\s+)?(?:function|class|interface|type|const|let|var|enum)\s+(\w+)/gm;
+    const declarationRegex = /^(?:\/\*\*[\s\S]*?\*\/\s*)?(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:function|class|interface|type|const|let|var|enum)\s+(\w+)/gm;
     const declarations = [];
     let match;
     while ((match = declarationRegex.exec(text)) !== null) {
@@ -2465,73 +2546,236 @@ var ChunkingService = class _ChunkingService {
   }
 };
 
-// src/types/brands.ts
-var ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
-function isStoreId(value) {
-  return value.length > 0 && ID_PATTERN.test(value);
-}
-function isDocumentId(value) {
-  return value.length > 0 && ID_PATTERN.test(value);
-}
-function createStoreId(value) {
-  if (!isStoreId(value)) {
-    throw new Error(`Invalid store ID: ${value}`);
+// src/services/drift.service.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile4, stat } from "fs/promises";
+var DriftService = class {
+  /**
+   * Detect changes between current files and manifest.
+   *
+   * @param manifest - The stored manifest from last index
+   * @param currentFiles - Current files on disk with mtime/size
+   * @returns Classification of files into added, modified, deleted, unchanged
+   */
+  async detectChanges(manifest, currentFiles) {
+    const result = {
+      added: [],
+      modified: [],
+      deleted: [],
+      unchanged: []
+    };
+    const currentPathSet = new Set(currentFiles.map((f) => f.path));
+    const manifestPaths = new Set(Object.keys(manifest.files));
+    for (const path4 of manifestPaths) {
+      if (!currentPathSet.has(path4)) {
+        result.deleted.push(path4);
+      }
+    }
+    const potentiallyModified = [];
+    for (const file of currentFiles) {
+      const manifestState = manifest.files[file.path];
+      if (manifestState === void 0) {
+        result.added.push(file.path);
+      } else {
+        if (file.mtime === manifestState.mtime && file.size === manifestState.size) {
+          result.unchanged.push(file.path);
+        } else {
+          potentiallyModified.push(file);
+        }
+      }
+    }
+    for (const file of potentiallyModified) {
+      const manifestState = manifest.files[file.path];
+      if (manifestState === void 0) {
+        result.added.push(file.path);
+        continue;
+      }
+      const currentHash = await this.computeFileHash(file.path);
+      if (currentHash === manifestState.hash) {
+        result.unchanged.push(file.path);
+      } else {
+        result.modified.push(file.path);
+      }
+    }
+    return result;
   }
-  return value;
-}
-function createDocumentId(value) {
-  if (!isDocumentId(value)) {
-    throw new Error(`Invalid document ID: ${value}`);
+  /**
+   * Get the current state of a file on disk.
+   */
+  async getFileState(path4) {
+    const stats = await stat(path4);
+    return {
+      path: path4,
+      mtime: stats.mtimeMs,
+      size: stats.size
+    };
   }
-  return value;
-}
+  /**
+   * Compute MD5 hash of a file.
+   */
+  async computeFileHash(path4) {
+    const content = await readFile4(path4);
+    return createHash2("md5").update(content).digest("hex");
+  }
+  /**
+   * Create a file state entry for the manifest after indexing.
+   *
+   * @param path - File path
+   * @param documentIds - Document IDs created from this file
+   * @returns File state for manifest
+   */
+  async createFileState(path4, documentIds) {
+    const stats = await stat(path4);
+    const content = await readFile4(path4);
+    const hash = createHash2("md5").update(content).digest("hex");
+    const { createDocumentId: createDocumentId2 } = await import("./brands-3EYIYV6T.js");
+    return {
+      state: {
+        mtime: stats.mtimeMs,
+        size: stats.size,
+        hash,
+        documentIds: documentIds.map((id) => createDocumentId2(id))
+      },
+      hash
+    };
+  }
+};
 
 // src/services/index.service.ts
 var logger = createLogger("index-service");
 var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  // Text/docs
   ".txt",
   ".md",
+  ".rst",
+  ".adoc",
+  // JavaScript/TypeScript
   ".js",
   ".ts",
   ".jsx",
   ".tsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  // Config/data
   ".json",
   ".yaml",
   ".yml",
+  ".toml",
+  ".ini",
+  ".env",
+  // Web
   ".html",
+  ".htm",
   ".css",
   ".scss",
+  ".sass",
   ".less",
+  ".vue",
+  ".svelte",
+  // Python
   ".py",
+  ".pyi",
+  ".pyx",
+  // Ruby
   ".rb",
+  ".erb",
+  ".rake",
+  // Go
   ".go",
+  // Rust
   ".rs",
+  // Java/JVM
   ".java",
+  ".kt",
+  ".kts",
+  ".scala",
+  ".groovy",
+  ".gradle",
+  // C/C++
   ".c",
   ".cpp",
+  ".cc",
+  ".cxx",
   ".h",
   ".hpp",
+  ".hxx",
+  // C#/.NET
+  ".cs",
+  ".fs",
+  ".vb",
+  // Swift/Objective-C
+  ".swift",
+  ".m",
+  ".mm",
+  // PHP
+  ".php",
+  // Shell
   ".sh",
   ".bash",
   ".zsh",
+  ".fish",
+  ".ps1",
+  ".psm1",
+  // SQL
   ".sql",
-  ".xml"
+  // Other
+  ".xml",
+  ".graphql",
+  ".gql",
+  ".proto",
+  ".lua",
+  ".r",
+  ".R",
+  ".jl",
+  ".ex",
+  ".exs",
+  ".erl",
+  ".hrl",
+  ".clj",
+  ".cljs",
+  ".cljc",
+  ".hs",
+  ".elm",
+  ".dart",
+  ".pl",
+  ".pm",
+  ".tcl",
+  ".vim",
+  ".zig",
+  ".nim",
+  ".v",
+  ".tf",
+  ".hcl",
+  ".dockerfile",
+  ".makefile",
+  ".cmake"
 ]);
 var IndexService = class {
   lanceStore;
   embeddingEngine;
   chunker;
   codeGraphService;
+  manifestService;
+  driftService;
   concurrency;
+  ignoreDirs;
+  ignoreFilePatterns;
   constructor(lanceStore, embeddingEngine, options = {}) {
     this.lanceStore = lanceStore;
     this.embeddingEngine = embeddingEngine;
     this.chunker = new ChunkingService({
-      chunkSize: options.chunkSize ?? 768,
-      chunkOverlap: options.chunkOverlap ?? 100
+      chunkSize: options.chunkSize ?? 1e3,
+      chunkOverlap: options.chunkOverlap ?? 150
     });
     this.codeGraphService = options.codeGraphService;
+    this.manifestService = options.manifestService;
+    this.driftService = new DriftService();
     this.concurrency = options.concurrency ?? 4;
+    const parsed = parseIgnorePatternsForScanning(options.ignorePatterns ?? []);
+    this.ignoreDirs = parsed.dirs;
+    this.ignoreFilePatterns = parsed.fileMatchers;
   }
   async indexStore(store, onProgress) {
     logger.info(
@@ -2562,8 +2806,205 @@ var IndexService = class {
       return err(error instanceof Error ? error : new Error(String(error)));
     }
   }
+  /**
+   * Incrementally index a store, only processing changed files.
+   * Requires manifestService to be configured.
+   *
+   * @param store - The store to index
+   * @param onProgress - Optional progress callback
+   * @returns Result with incremental index statistics
+   */
+  async indexStoreIncremental(store, onProgress) {
+    if (this.manifestService === void 0) {
+      return err(new Error("ManifestService required for incremental indexing"));
+    }
+    if (store.type !== "file" && store.type !== "repo") {
+      return err(new Error(`Incremental indexing not supported for store type: ${store.type}`));
+    }
+    logger.info(
+      {
+        storeId: store.id,
+        storeName: store.name,
+        storeType: store.type
+      },
+      "Starting incremental store indexing"
+    );
+    const startTime = Date.now();
+    try {
+      const manifest = await this.manifestService.load(store.id);
+      const filePaths = await this.scanDirectory(store.path);
+      const currentFiles = await Promise.all(
+        filePaths.map((path4) => this.driftService.getFileState(path4))
+      );
+      const drift = await this.driftService.detectChanges(manifest, currentFiles);
+      logger.debug(
+        {
+          storeId: store.id,
+          added: drift.added.length,
+          modified: drift.modified.length,
+          deleted: drift.deleted.length,
+          unchanged: drift.unchanged.length
+        },
+        "Drift detection complete"
+      );
+      const documentIdsToDelete = [];
+      for (const path4 of [...drift.modified, ...drift.deleted]) {
+        const fileState = manifest.files[path4];
+        if (fileState !== void 0) {
+          documentIdsToDelete.push(...fileState.documentIds);
+        }
+      }
+      if (documentIdsToDelete.length > 0) {
+        await this.lanceStore.deleteDocuments(store.id, documentIdsToDelete);
+        logger.debug(
+          { storeId: store.id, count: documentIdsToDelete.length },
+          "Deleted old documents"
+        );
+      }
+      const filesToProcess = [...drift.added, ...drift.modified];
+      const totalFiles = filesToProcess.length;
+      onProgress?.({
+        type: "start",
+        current: 0,
+        total: totalFiles,
+        message: `Processing ${String(totalFiles)} changed files`
+      });
+      const documents = [];
+      const newManifestFiles = {};
+      let filesProcessed = 0;
+      for (const path4 of drift.unchanged) {
+        const existingState = manifest.files[path4];
+        if (existingState !== void 0) {
+          newManifestFiles[path4] = existingState;
+        }
+      }
+      for (let i = 0; i < filesToProcess.length; i += this.concurrency) {
+        const batch = filesToProcess.slice(i, i + this.concurrency);
+        const batchResults = await Promise.all(
+          batch.map(async (filePath) => {
+            try {
+              const result = await this.processFile(filePath, store);
+              const documentIds = result.documents.map((d) => d.id);
+              const { state } = await this.driftService.createFileState(filePath, documentIds);
+              return {
+                filePath,
+                documents: result.documents,
+                fileState: state
+              };
+            } catch (error) {
+              logger.warn(
+                { filePath, error: error instanceof Error ? error.message : String(error) },
+                "Failed to process file during incremental indexing, skipping"
+              );
+              return null;
+            }
+          })
+        );
+        for (const result of batchResults) {
+          if (result !== null) {
+            documents.push(...result.documents);
+            newManifestFiles[result.filePath] = result.fileState;
+          }
+        }
+        filesProcessed += batch.length;
+        onProgress?.({
+          type: "progress",
+          current: filesProcessed,
+          total: totalFiles,
+          message: `Processed ${String(filesProcessed)}/${String(totalFiles)} files`
+        });
+      }
+      if (documents.length > 0) {
+        await this.lanceStore.addDocuments(store.id, documents);
+      }
+      if (documentIdsToDelete.length > 0 || documents.length > 0) {
+        await this.lanceStore.createFtsIndex(store.id);
+      }
+      if (this.codeGraphService) {
+        const sourceExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".rs", ".go"];
+        const hasSourceChanges = filesToProcess.some((p) => sourceExtensions.includes(extname(p).toLowerCase())) || drift.deleted.some((p) => sourceExtensions.includes(extname(p).toLowerCase()));
+        if (hasSourceChanges) {
+          const allSourceFiles = [];
+          const allPaths = [...drift.unchanged, ...filesToProcess];
+          for (const filePath of allPaths) {
+            const ext = extname(filePath).toLowerCase();
+            if (sourceExtensions.includes(ext)) {
+              try {
+                const content = await readFile5(filePath, "utf-8");
+                allSourceFiles.push({ path: filePath, content });
+              } catch {
+              }
+            }
+          }
+          if (allSourceFiles.length > 0) {
+            const graph = await this.codeGraphService.buildGraph(allSourceFiles);
+            await this.codeGraphService.saveGraph(store.id, graph);
+            logger.debug(
+              { storeId: store.id, sourceFiles: allSourceFiles.length },
+              "Rebuilt code graph during incremental indexing"
+            );
+          } else {
+            await this.codeGraphService.deleteGraph(store.id);
+            logger.debug(
+              { storeId: store.id },
+              "Deleted stale code graph (no source files remain)"
+            );
+          }
+        }
+      }
+      const updatedManifest = {
+        version: 1,
+        storeId: store.id,
+        indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        files: newManifestFiles
+      };
+      await this.manifestService.save(updatedManifest);
+      onProgress?.({
+        type: "complete",
+        current: totalFiles,
+        total: totalFiles,
+        message: "Incremental indexing complete"
+      });
+      const timeMs = Date.now() - startTime;
+      logger.info(
+        {
+          storeId: store.id,
+          storeName: store.name,
+          filesAdded: drift.added.length,
+          filesModified: drift.modified.length,
+          filesDeleted: drift.deleted.length,
+          filesUnchanged: drift.unchanged.length,
+          chunksCreated: documents.length,
+          timeMs
+        },
+        "Incremental indexing complete"
+      );
+      return ok({
+        filesIndexed: filesToProcess.length,
+        chunksCreated: documents.length,
+        timeMs,
+        filesAdded: drift.added.length,
+        filesModified: drift.modified.length,
+        filesDeleted: drift.deleted.length,
+        filesUnchanged: drift.unchanged.length
+      });
+    } catch (error) {
+      logger.error(
+        {
+          storeId: store.id,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Incremental indexing failed"
+      );
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
   async indexFileStore(store, onProgress) {
     const startTime = Date.now();
+    await this.lanceStore.clearAllDocuments(store.id);
+    if (this.manifestService) {
+      await this.manifestService.delete(store.id);
+    }
     const files = await this.scanDirectory(store.path);
     const documents = [];
     let filesProcessed = 0;
@@ -2586,7 +3027,17 @@ var IndexService = class {
     for (let i = 0; i < files.length; i += this.concurrency) {
       const batch = files.slice(i, i + this.concurrency);
       const batchResults = await Promise.all(
-        batch.map((filePath) => this.processFile(filePath, store))
+        batch.map(async (filePath) => {
+          try {
+            return await this.processFile(filePath, store);
+          } catch (error) {
+            logger.warn(
+              { filePath, error: error instanceof Error ? error.message : String(error) },
+              "Failed to process file, skipping"
+            );
+            return { documents: [], sourceFile: void 0 };
+          }
+        })
       );
       for (const result of batchResults) {
         documents.push(...result.documents);
@@ -2609,6 +3060,8 @@ var IndexService = class {
     if (this.codeGraphService && sourceFiles.length > 0) {
       const graph = await this.codeGraphService.buildGraph(sourceFiles);
       await this.codeGraphService.saveGraph(store.id, graph);
+    } else if (this.codeGraphService) {
+      await this.codeGraphService.deleteGraph(store.id);
     }
     onProgress?.({
       type: "complete",
@@ -2621,7 +3074,7 @@ var IndexService = class {
       {
         storeId: store.id,
         storeName: store.name,
-        documentsIndexed: filesProcessed,
+        filesIndexed: filesProcessed,
         chunksCreated: documents.length,
         sourceFilesForGraph: sourceFiles.length,
         timeMs
@@ -2629,7 +3082,7 @@ var IndexService = class {
       "Store indexing complete"
     );
     return ok({
-      documentsIndexed: filesProcessed,
+      filesIndexed: filesProcessed,
       chunksCreated: documents.length,
       timeMs
     });
@@ -2639,13 +3092,15 @@ var IndexService = class {
    * Extracted for parallel processing.
    */
   async processFile(filePath, store) {
-    const content = await readFile4(filePath, "utf-8");
-    const fileHash = createHash2("md5").update(content).digest("hex");
+    const content = await readFile5(filePath, "utf-8");
+    const fileHash = createHash3("md5").update(content).digest("hex");
     const chunks = this.chunker.chunk(content, filePath);
+    const relativePath = relative(store.path, filePath);
+    const pathHash = createHash3("md5").update(relativePath).digest("hex").slice(0, 8);
     const ext = extname(filePath).toLowerCase();
     const fileName = basename(filePath).toLowerCase();
     const fileType = this.classifyFileType(ext, fileName, filePath);
-    const sourceFile = [".ts", ".tsx", ".js", ".jsx"].includes(ext) ? { path: filePath, content } : void 0;
+    const sourceFile = [".ts", ".tsx", ".js", ".jsx", ".py", ".rs", ".go"].includes(ext) ? { path: filePath, content } : void 0;
     if (chunks.length === 0) {
       return { documents: [], sourceFile };
     }
@@ -2660,7 +3115,7 @@ var IndexService = class {
           `Chunk/vector mismatch at index ${String(i)}: chunk=${String(chunk !== void 0)}, vector=${String(vector !== void 0)}`
         );
       }
-      const chunkId = chunks.length > 1 ? `${store.id}-${fileHash}-${String(chunk.chunkIndex)}` : `${store.id}-${fileHash}`;
+      const chunkId = chunks.length > 1 ? `${store.id}-${pathHash}-${fileHash}-${String(chunk.chunkIndex)}` : `${store.id}-${pathHash}-${fileHash}`;
       documents.push({
         id: createDocumentId(chunkId),
         content: chunk.content,
@@ -2669,7 +3124,7 @@ var IndexService = class {
           type: chunks.length > 1 ? "chunk" : "file",
           storeId: store.id,
           path: filePath,
-          indexedAt: /* @__PURE__ */ new Date(),
+          indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
           fileHash,
           chunkIndex: chunk.chunkIndex,
           totalChunks: chunk.totalChunks,
@@ -2689,10 +3144,14 @@ var IndexService = class {
     for (const entry of entries) {
       const fullPath = join7(dir, entry.name);
       if (entry.isDirectory()) {
-        if (!["node_modules", ".git", "dist", "build"].includes(entry.name)) {
+        if (!this.ignoreDirs.has(entry.name)) {
           files.push(...await this.scanDirectory(fullPath));
         }
       } else if (entry.isFile()) {
+        const shouldIgnore = this.ignoreFilePatterns.some((matcher) => matcher(entry.name));
+        if (shouldIgnore) {
+          continue;
+        }
         const ext = extname(entry.name).toLowerCase();
         if (TEXT_EXTENSIONS.has(ext)) {
           files.push(fullPath);
@@ -2782,6 +3241,141 @@ function classifyWebContentType(url, title) {
   return "documentation";
 }
 
+// src/services/manifest.service.ts
+import { readFile as readFile6, access as access3, mkdir as mkdir3 } from "fs/promises";
+import { join as join8 } from "path";
+
+// src/types/manifest.ts
+import { z as z2 } from "zod";
+var FileStateSchema = z2.object({
+  /** File modification time in milliseconds since epoch */
+  mtime: z2.number(),
+  /** File size in bytes */
+  size: z2.number(),
+  /** MD5 hash of file content */
+  hash: z2.string(),
+  /** Document IDs created from this file (for cleanup) */
+  documentIds: z2.array(z2.string())
+});
+var StoreManifestSchema = z2.object({
+  /** Schema version for future migrations */
+  version: z2.literal(1),
+  /** Store ID this manifest belongs to */
+  storeId: z2.string(),
+  /** When the manifest was last updated */
+  indexedAt: z2.string(),
+  /** Map of file paths to their state */
+  files: z2.record(z2.string(), FileStateSchema)
+});
+function createEmptyManifest(storeId) {
+  return {
+    version: 1,
+    storeId,
+    indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: {}
+  };
+}
+
+// src/services/manifest.service.ts
+var ManifestService = class {
+  manifestsDir;
+  constructor(dataDir) {
+    this.manifestsDir = join8(dataDir, "manifests");
+  }
+  /**
+   * Initialize the manifests directory.
+   */
+  async initialize() {
+    await mkdir3(this.manifestsDir, { recursive: true });
+  }
+  /**
+   * Get the file path for a store's manifest.
+   */
+  getManifestPath(storeId) {
+    return join8(this.manifestsDir, `${storeId}.manifest.json`);
+  }
+  /**
+   * Load a store's manifest.
+   * Returns an empty manifest if one doesn't exist.
+   * Throws on parse/validation errors (fail fast).
+   */
+  async load(storeId) {
+    const manifestPath = this.getManifestPath(storeId);
+    const exists = await this.fileExists(manifestPath);
+    if (!exists) {
+      return createEmptyManifest(storeId);
+    }
+    const content = await readFile6(manifestPath, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (error) {
+      throw new Error(
+        `Failed to parse manifest at ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const result = StoreManifestSchema.safeParse(parsed);
+    if (!result.success) {
+      throw new Error(`Invalid manifest at ${manifestPath}: ${result.error.message}`);
+    }
+    return this.toTypedManifest(result.data, storeId);
+  }
+  /**
+   * Save a store's manifest atomically.
+   */
+  async save(manifest) {
+    const manifestPath = this.getManifestPath(manifest.storeId);
+    const toSave = {
+      ...manifest,
+      indexedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await atomicWriteFile(manifestPath, JSON.stringify(toSave, null, 2));
+  }
+  /**
+   * Delete a store's manifest.
+   * Called when a store is deleted or during full re-index.
+   */
+  async delete(storeId) {
+    const manifestPath = this.getManifestPath(storeId);
+    const { unlink } = await import("fs/promises");
+    const exists = await this.fileExists(manifestPath);
+    if (exists) {
+      await unlink(manifestPath);
+    }
+  }
+  /**
+   * Check if a file exists.
+   */
+  async fileExists(path4) {
+    try {
+      await access3(path4);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Convert a parsed manifest to a typed manifest with branded types.
+   */
+  toTypedManifest(data, storeId) {
+    const files = {};
+    for (const [path4, state] of Object.entries(data.files)) {
+      files[path4] = {
+        mtime: state.mtime,
+        size: state.size,
+        hash: state.hash,
+        documentIds: state.documentIds.map((id) => createDocumentId(id))
+      };
+    }
+    return {
+      version: 1,
+      storeId,
+      indexedAt: data.indexedAt,
+      files
+    };
+  }
+};
+
 // src/services/code-unit.service.ts
 var CodeUnitService = class {
   extractCodeUnit(code, symbolName, language) {
@@ -2966,6 +3560,8 @@ var INTENT_FILE_BOOSTS = {
     // Stronger penalty - internal code less useful
     test: 0.8,
     config: 0.7,
+    changelog: 0.6,
+    // Changelogs rarely answer "how to" questions
     other: 0.9
   },
   implementation: {
@@ -2978,6 +3574,8 @@ var INTENT_FILE_BOOSTS = {
     // Internal code can be relevant
     test: 1,
     config: 0.95,
+    changelog: 0.8,
+    // Might reference implementation changes
     other: 1
   },
   conceptual: {
@@ -2988,6 +3586,8 @@ var INTENT_FILE_BOOSTS = {
     "source-internal": 0.9,
     test: 0.9,
     config: 0.85,
+    changelog: 0.7,
+    // Sometimes explains concepts behind changes
     other: 0.95
   },
   comparison: {
@@ -2998,6 +3598,8 @@ var INTENT_FILE_BOOSTS = {
     "source-internal": 0.85,
     test: 0.9,
     config: 0.85,
+    changelog: 0.9,
+    // Version comparisons can be useful
     other: 0.95
   },
   debugging: {
@@ -3010,6 +3612,8 @@ var INTENT_FILE_BOOSTS = {
     test: 1.05,
     // Tests can show expected behavior
     config: 0.9,
+    changelog: 1.1,
+    // Often contains bug fixes and known issues
     other: 1
   }
 };
@@ -3092,6 +3696,17 @@ function classifyQueryIntents(query) {
 function getPrimaryIntent(intents) {
   return intents[0]?.intent ?? "how-to";
 }
+function mapSearchIntentToQueryIntent(intent) {
+  switch (intent) {
+    case "find-pattern":
+    case "find-implementation":
+    case "find-definition":
+      return "implementation";
+    case "find-usage":
+    case "find-documentation":
+      return "how-to";
+  }
+}
 var RRF_PRESETS = {
   code: { k: 20, vectorWeight: 0.6, ftsWeight: 0.4 },
   web: { k: 30, vectorWeight: 0.55, ftsWeight: 0.45 }
@@ -3106,12 +3721,27 @@ var SearchService = class {
   codeUnitService;
   codeGraphService;
   graphCache;
-  constructor(lanceStore, embeddingEngine, codeGraphService) {
+  searchConfig;
+  unsubscribeCacheInvalidation;
+  constructor(lanceStore, embeddingEngine, codeGraphService, searchConfig) {
     this.lanceStore = lanceStore;
     this.embeddingEngine = embeddingEngine;
     this.codeUnitService = new CodeUnitService();
     this.codeGraphService = codeGraphService;
     this.graphCache = /* @__PURE__ */ new Map();
+    this.searchConfig = searchConfig;
+    if (codeGraphService) {
+      this.unsubscribeCacheInvalidation = codeGraphService.onCacheInvalidation((event) => {
+        this.graphCache.delete(event.storeId);
+      });
+    }
+  }
+  /**
+   * Clean up resources (unsubscribe from events).
+   * Call this when destroying the service.
+   */
+  cleanup() {
+    this.unsubscribeCacheInvalidation?.();
   }
   /**
    * Load code graph for a store, with caching.
@@ -3139,12 +3769,12 @@ var SearchService = class {
   }
   async search(query) {
     const startTime = Date.now();
-    const mode = query.mode ?? "hybrid";
-    const limit = query.limit ?? 10;
+    const mode = query.mode ?? this.searchConfig?.defaultMode ?? "hybrid";
+    const limit = query.limit ?? this.searchConfig?.defaultLimit ?? 10;
     const stores = query.stores ?? [];
     const detail = query.detail ?? "minimal";
     const intents = classifyQueryIntents(query.query);
-    const primaryIntent = getPrimaryIntent(intents);
+    const primaryIntent = query.intent !== void 0 ? mapSearchIntentToQueryIntent(query.intent) : getPrimaryIntent(intents);
     logger2.debug(
       {
         query: query.query,
@@ -3153,7 +3783,8 @@ var SearchService = class {
         stores,
         detail,
         intent: primaryIntent,
-        intents,
+        userIntent: query.intent,
+        autoClassifiedIntents: intents,
         minRelevance: query.minRelevance
       },
       "Search query received"
@@ -3164,7 +3795,7 @@ var SearchService = class {
     if (mode === "vector") {
       const rawResults = await this.vectorSearchRaw(query.query, stores, fetchLimit);
       maxRawScore = rawResults.length > 0 ? rawResults[0]?.score ?? 0 : 0;
-      allResults = await this.vectorSearch(query.query, stores, fetchLimit, query.threshold);
+      allResults = this.normalizeAndFilterScores(rawResults, query.threshold).slice(0, fetchLimit);
     } else if (mode === "fts") {
       allResults = await this.ftsSearch(query.query, stores, fetchLimit);
     } else {
@@ -3177,28 +3808,35 @@ var SearchService = class {
       allResults = hybridResult.results;
       maxRawScore = hybridResult.maxRawScore;
     }
-    if (query.minRelevance !== void 0 && maxRawScore < query.minRelevance) {
-      const timeMs2 = Date.now() - startTime;
-      logger2.info(
-        {
+    if (query.minRelevance !== void 0) {
+      if (mode === "fts") {
+        logger2.warn(
+          { query: query.query, minRelevance: query.minRelevance },
+          "minRelevance filter ignored in FTS mode (no vector scores available)"
+        );
+      } else if (maxRawScore < query.minRelevance) {
+        const timeMs2 = Date.now() - startTime;
+        logger2.info(
+          {
+            query: query.query,
+            mode,
+            maxRawScore,
+            minRelevance: query.minRelevance,
+            timeMs: timeMs2
+          },
+          "Search filtered by minRelevance - no sufficiently relevant results"
+        );
+        return {
           query: query.query,
           mode,
-          maxRawScore,
-          minRelevance: query.minRelevance,
-          timeMs: timeMs2
-        },
-        "Search filtered by minRelevance - no sufficiently relevant results"
-      );
-      return {
-        query: query.query,
-        mode,
-        stores,
-        results: [],
-        totalResults: 0,
-        timeMs: timeMs2,
-        confidence: this.calculateConfidence(maxRawScore),
-        maxRawScore
-      };
+          stores,
+          results: [],
+          totalResults: 0,
+          timeMs: timeMs2,
+          confidence: this.calculateConfidence(maxRawScore),
+          maxRawScore
+        };
+      }
     }
     const dedupedResults = this.deduplicateBySource(allResults, query.query);
     const resultsToEnhance = dedupedResults.slice(0, limit);
@@ -3247,7 +3885,9 @@ var SearchService = class {
     const bySource = /* @__PURE__ */ new Map();
     const queryTerms = query.toLowerCase().split(/\s+/).filter((t2) => t2.length > 2);
     for (const result of results) {
-      const sourceKey = result.metadata.path ?? result.metadata.url ?? result.id;
+      const storeId = result.metadata.storeId;
+      const source = result.metadata.path ?? result.metadata.url ?? result.id;
+      const sourceKey = `${storeId}:${source}`;
       const existing = bySource.get(sourceKey);
       if (!existing) {
         bySource.set(sourceKey, result);
@@ -3318,11 +3958,6 @@ var SearchService = class {
     }
     return results.sort((a, b) => b.score - a.score).slice(0, limit);
   }
-  async vectorSearch(query, stores, limit, threshold) {
-    const results = await this.vectorSearchRaw(query, stores, limit);
-    const normalized = this.normalizeAndFilterScores(results, threshold);
-    return normalized.slice(0, limit);
-  }
   async ftsSearch(query, stores, limit) {
     const results = [];
     for (const storeId of stores) {
@@ -3482,6 +4117,9 @@ var SearchService = class {
       case "config":
         baseBoost = 0.5;
         break;
+      case "changelog":
+        baseBoost = 0.7;
+        break;
       default:
         baseBoost = 1;
     }
@@ -3887,42 +4525,53 @@ var SearchService = class {
 };
 
 // src/services/store-definition.service.ts
-import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3, access as access3 } from "fs/promises";
-import { dirname as dirname4, resolve as resolve2, isAbsolute, join as join8 } from "path";
+import { readFile as readFile7, access as access4 } from "fs/promises";
+import { resolve as resolve2, isAbsolute as isAbsolute2, join as join9 } from "path";
 
 // src/types/store-definition.ts
-import { z as z2 } from "zod";
-var BaseStoreDefinitionSchema = z2.object({
-  name: z2.string().min(1, "Store name is required"),
-  description: z2.string().optional(),
-  tags: z2.array(z2.string()).optional()
+import { z as z3 } from "zod";
+var BaseStoreDefinitionSchema = z3.object({
+  name: z3.string().min(1, "Store name is required"),
+  description: z3.string().optional(),
+  tags: z3.array(z3.string()).optional()
 });
 var FileStoreDefinitionSchema = BaseStoreDefinitionSchema.extend({
-  type: z2.literal("file"),
-  path: z2.string().min(1, "Path is required for file stores")
+  type: z3.literal("file"),
+  path: z3.string().min(1, "Path is required for file stores")
 });
+var GitUrlSchema = z3.string().refine(
+  (val) => {
+    try {
+      new URL(val);
+      return true;
+    } catch {
+      return /^git@[\w.-]+:[\w./-]+$/.test(val);
+    }
+  },
+  { message: "Must be a valid URL or SSH URL (git@host:path)" }
+);
 var RepoStoreDefinitionSchema = BaseStoreDefinitionSchema.extend({
-  type: z2.literal("repo"),
-  url: z2.url("Valid URL is required for repo stores"),
-  branch: z2.string().optional(),
-  depth: z2.number().int().positive("Depth must be a positive integer").optional()
+  type: z3.literal("repo"),
+  url: GitUrlSchema,
+  branch: z3.string().optional(),
+  depth: z3.number().int().positive("Depth must be a positive integer").optional()
 });
 var WebStoreDefinitionSchema = BaseStoreDefinitionSchema.extend({
-  type: z2.literal("web"),
-  url: z2.url("Valid URL is required for web stores"),
-  depth: z2.number().int().min(0, "Depth must be non-negative").default(1),
-  maxPages: z2.number().int().positive("maxPages must be a positive integer").optional(),
-  crawlInstructions: z2.string().optional(),
-  extractInstructions: z2.string().optional()
+  type: z3.literal("web"),
+  url: z3.url("Valid URL is required for web stores"),
+  depth: z3.number().int().min(0, "Depth must be non-negative").default(1),
+  maxPages: z3.number().int().positive("maxPages must be a positive integer").optional(),
+  crawlInstructions: z3.string().optional(),
+  extractInstructions: z3.string().optional()
 });
-var StoreDefinitionSchema = z2.discriminatedUnion("type", [
+var StoreDefinitionSchema = z3.discriminatedUnion("type", [
   FileStoreDefinitionSchema,
   RepoStoreDefinitionSchema,
   WebStoreDefinitionSchema
 ]);
-var StoreDefinitionsConfigSchema = z2.object({
-  version: z2.literal(1),
-  stores: z2.array(StoreDefinitionSchema)
+var StoreDefinitionsConfigSchema = z3.object({
+  version: z3.literal(1),
+  stores: z3.array(StoreDefinitionSchema)
 });
 function isFileStoreDefinition(def) {
   return def.type === "file";
@@ -3941,7 +4590,7 @@ var DEFAULT_STORE_DEFINITIONS_CONFIG = {
 // src/services/store-definition.service.ts
 async function fileExists3(path4) {
   try {
-    await access3(path4);
+    await access4(path4);
     return true;
   } catch {
     return false;
@@ -3953,7 +4602,7 @@ var StoreDefinitionService = class {
   config = null;
   constructor(projectRoot) {
     this.projectRoot = projectRoot ?? ProjectRootService.resolve();
-    this.configPath = join8(this.projectRoot, ".bluera/bluera-knowledge/stores.config.json");
+    this.configPath = join9(this.projectRoot, ".bluera/bluera-knowledge/stores.config.json");
   }
   /**
    * Load store definitions from config file.
@@ -3972,7 +4621,7 @@ var StoreDefinitionService = class {
       };
       return this.config;
     }
-    const content = await readFile5(this.configPath, "utf-8");
+    const content = await readFile7(this.configPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(content);
@@ -3992,8 +4641,7 @@ var StoreDefinitionService = class {
    * Save store definitions to config file.
    */
   async save(config) {
-    await mkdir3(dirname4(this.configPath), { recursive: true });
-    await writeFile4(this.configPath, JSON.stringify(config, null, 2));
+    await atomicWriteFile(this.configPath, JSON.stringify(config, null, 2));
     this.config = config;
   }
   /**
@@ -4065,7 +4713,7 @@ var StoreDefinitionService = class {
    * Resolve a file store path relative to project root.
    */
   resolvePath(path4) {
-    if (isAbsolute(path4)) {
+    if (isAbsolute2(path4)) {
       return path4;
     }
     return resolve2(this.projectRoot, path4);
@@ -4092,8 +4740,8 @@ var StoreDefinitionService = class {
 
 // src/services/store.service.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir5, stat, access as access4 } from "fs/promises";
-import { join as join9, resolve as resolve3 } from "path";
+import { readFile as readFile8, mkdir as mkdir5, stat as stat2, access as access5 } from "fs/promises";
+import { join as join10, resolve as resolve3 } from "path";
 
 // src/plugin/git-clone.ts
 import { spawn } from "child_process";
@@ -4124,6 +4772,9 @@ async function cloneRepository(options) {
     });
   });
 }
+function isGitUrl(source) {
+  return source.startsWith("http://") || source.startsWith("https://") || source.startsWith("git@");
+}
 function extractRepoName(url) {
   const match = /\/([^/]+?)(\.git)?$/.exec(url);
   const name = match?.[1];
@@ -4136,7 +4787,7 @@ function extractRepoName(url) {
 // src/services/store.service.ts
 async function fileExists4(path4) {
   try {
-    await access4(path4);
+    await access5(path4);
     return true;
   } catch {
     return false;
@@ -4146,11 +4797,13 @@ var StoreService = class {
   dataDir;
   definitionService;
   gitignoreService;
+  projectRoot;
   registry = { stores: [] };
   constructor(dataDir, options) {
     this.dataDir = dataDir;
     this.definitionService = options?.definitionService ?? void 0;
     this.gitignoreService = options?.gitignoreService ?? void 0;
+    this.projectRoot = options?.projectRoot ?? void 0;
   }
   async initialize() {
     await mkdir5(this.dataDir, { recursive: true });
@@ -4158,6 +4811,7 @@ var StoreService = class {
   }
   /**
    * Convert a Store and CreateStoreInput to a StoreDefinition for persistence.
+   * Returns undefined for stores that shouldn't be persisted (e.g., local repo stores).
    */
   createDefinitionFromStore(store, input) {
     const tags = store.tags !== void 0 ? [...store.tags] : void 0;
@@ -4179,10 +4833,13 @@ var StoreService = class {
       }
       case "repo": {
         const repoStore = store;
+        if (repoStore.url === void 0) {
+          return void 0;
+        }
         const repoDef = {
           ...base,
           type: "repo",
-          url: repoStore.url ?? "",
+          url: repoStore.url,
           branch: repoStore.branch,
           depth: input.depth
         };
@@ -4194,7 +4851,58 @@ var StoreService = class {
           ...base,
           type: "web",
           url: webStore.url,
-          depth: webStore.depth
+          depth: webStore.depth,
+          maxPages: input.maxPages,
+          crawlInstructions: input.crawlInstructions,
+          extractInstructions: input.extractInstructions
+        };
+        return webDef;
+      }
+    }
+  }
+  /**
+   * Create a StoreDefinition from an existing store (without original input).
+   * Used when updating/renaming stores where we don't have the original input.
+   * Returns undefined for stores that shouldn't be persisted (e.g., local repo stores).
+   */
+  createDefinitionFromExistingStore(store) {
+    const tags = store.tags !== void 0 ? [...store.tags] : void 0;
+    const base = {
+      name: store.name,
+      description: store.description,
+      tags
+    };
+    switch (store.type) {
+      case "file": {
+        const fileDef = {
+          ...base,
+          type: "file",
+          path: store.path
+        };
+        return fileDef;
+      }
+      case "repo": {
+        if (store.url === void 0) {
+          return void 0;
+        }
+        const repoDef = {
+          ...base,
+          type: "repo",
+          url: store.url,
+          branch: store.branch,
+          depth: store.depth
+        };
+        return repoDef;
+      }
+      case "web": {
+        const webDef = {
+          ...base,
+          type: "web",
+          url: store.url,
+          depth: store.depth,
+          maxPages: store.maxPages,
+          crawlInstructions: store.crawlInstructions,
+          extractInstructions: store.extractInstructions
         };
         return webDef;
       }
@@ -4216,9 +4924,9 @@ var StoreService = class {
         if (input.path === void 0) {
           return err(new Error("Path is required for file stores"));
         }
-        const normalizedPath = resolve3(input.path);
+        const normalizedPath = this.projectRoot !== void 0 ? resolve3(this.projectRoot, input.path) : resolve3(input.path);
         try {
-          const stats = await stat(normalizedPath);
+          const stats = await stat2(normalizedPath);
           if (!stats.isDirectory()) {
             return err(new Error(`Path is not a directory: ${normalizedPath}`));
           }
@@ -4241,7 +4949,7 @@ var StoreService = class {
       case "repo": {
         let repoPath = input.path;
         if (input.url !== void 0) {
-          const cloneDir = join9(this.dataDir, "repos", id);
+          const cloneDir = join10(this.dataDir, "repos", id);
           const result = await cloneRepository({
             url: input.url,
             targetDir: cloneDir,
@@ -4256,7 +4964,17 @@ var StoreService = class {
         if (repoPath === void 0) {
           return err(new Error("Path or URL required for repo stores"));
         }
-        const normalizedRepoPath = resolve3(repoPath);
+        const normalizedRepoPath = this.projectRoot !== void 0 ? resolve3(this.projectRoot, repoPath) : resolve3(repoPath);
+        if (input.url === void 0) {
+          try {
+            const stats = await stat2(normalizedRepoPath);
+            if (!stats.isDirectory()) {
+              return err(new Error(`Path is not a directory: ${normalizedRepoPath}`));
+            }
+          } catch {
+            return err(new Error(`Repository path does not exist: ${normalizedRepoPath}`));
+          }
+        }
         store = {
           type: "repo",
           id,
@@ -4264,6 +4982,7 @@ var StoreService = class {
           path: normalizedRepoPath,
           url: input.url,
           branch: input.branch,
+          depth: input.depth ?? 1,
           description: input.description,
           tags: input.tags,
           status: "ready",
@@ -4282,6 +5001,9 @@ var StoreService = class {
           name: input.name,
           url: input.url,
           depth: input.depth ?? 1,
+          maxPages: input.maxPages,
+          crawlInstructions: input.crawlInstructions,
+          extractInstructions: input.extractInstructions,
           description: input.description,
           tags: input.tags,
           status: "ready",
@@ -4301,7 +5023,9 @@ var StoreService = class {
     }
     if (this.definitionService !== void 0 && options?.skipDefinitionSync !== true) {
       const definition = this.createDefinitionFromStore(store, input);
-      await this.definitionService.addDefinition(definition);
+      if (definition !== void 0) {
+        await this.definitionService.addDefinition(definition);
+      }
     }
     return ok(store);
   }
@@ -4331,6 +5055,16 @@ var StoreService = class {
     if (store === void 0) {
       return err(new Error(`Store not found: ${id}`));
     }
+    if (updates.name?.trim() === "") {
+      return err(new Error("Store name cannot be empty"));
+    }
+    const isRenaming = updates.name !== void 0 && updates.name !== store.name;
+    if (isRenaming) {
+      const existing = this.registry.stores.find((s) => s.name === updates.name && s.id !== id);
+      if (existing !== void 0) {
+        return err(new Error(`Store with name '${updates.name}' already exists`));
+      }
+    }
     const updated = {
       ...store,
       ...updates,
@@ -4339,14 +5073,24 @@ var StoreService = class {
     this.registry.stores[index] = updated;
     await this.saveRegistry();
     if (this.definitionService !== void 0 && options?.skipDefinitionSync !== true) {
-      const defUpdates = {};
-      if (updates.description !== void 0) {
-        defUpdates.description = updates.description;
-      }
-      if (updates.tags !== void 0) {
-        defUpdates.tags = [...updates.tags];
+      if (isRenaming) {
+        await this.definitionService.removeDefinition(store.name);
+        const newDefinition = this.createDefinitionFromExistingStore(updated);
+        if (newDefinition !== void 0) {
+          await this.definitionService.addDefinition(newDefinition);
+        }
+      } else {
+        const defUpdates = {};
+        if (updates.description !== void 0) {
+          defUpdates.description = updates.description;
+        }
+        if (updates.tags !== void 0) {
+          defUpdates.tags = [...updates.tags];
+        }
+        if (Object.keys(defUpdates).length > 0) {
+          await this.definitionService.updateDefinition(store.name, defUpdates);
+        }
       }
-      await this.definitionService.updateDefinition(store.name, defUpdates);
     }
     return ok(updated);
   }
@@ -4368,14 +5112,14 @@ var StoreService = class {
     return ok(void 0);
   }
   async loadRegistry() {
-    const registryPath = join9(this.dataDir, "stores.json");
+    const registryPath = join10(this.dataDir, "stores.json");
     const exists = await fileExists4(registryPath);
     if (!exists) {
       this.registry = { stores: [] };
       await this.saveRegistry();
       return;
     }
-    const content = await readFile6(registryPath, "utf-8");
+    const content = await readFile8(registryPath, "utf-8");
     try {
       const data = JSON.parse(content);
       this.registry = {
@@ -4393,8 +5137,8 @@ var StoreService = class {
     }
   }
   async saveRegistry() {
-    const registryPath = join9(this.dataDir, "stores.json");
-    await writeFile5(registryPath, JSON.stringify(this.registry, null, 2));
+    const registryPath = join10(this.dataDir, "stores.json");
+    await atomicWriteFile(registryPath, JSON.stringify(this.registry, null, 2));
   }
 };
 
@@ -4408,33 +5152,33 @@ import { fileURLToPath } from "url";
 import { ZodError } from "zod";
 
 // src/crawl/schemas.ts
-import { z as z3 } from "zod";
-var CrawledLinkSchema = z3.object({
-  href: z3.string(),
-  text: z3.string(),
-  title: z3.string().optional(),
-  base_domain: z3.string().optional(),
-  head_data: z3.unknown().optional(),
-  head_extraction_status: z3.unknown().optional(),
-  head_extraction_error: z3.unknown().optional(),
-  intrinsic_score: z3.number().optional(),
-  contextual_score: z3.unknown().optional(),
-  total_score: z3.unknown().optional()
+import { z as z4 } from "zod";
+var CrawledLinkSchema = z4.object({
+  href: z4.string(),
+  text: z4.string(),
+  title: z4.string().optional(),
+  base_domain: z4.string().optional(),
+  head_data: z4.unknown().optional(),
+  head_extraction_status: z4.unknown().optional(),
+  head_extraction_error: z4.unknown().optional(),
+  intrinsic_score: z4.number().optional(),
+  contextual_score: z4.unknown().optional(),
+  total_score: z4.unknown().optional()
 });
-var CrawlPageSchema = z3.object({
-  url: z3.string(),
-  title: z3.string(),
-  content: z3.string(),
-  links: z3.array(z3.string()),
-  crawledAt: z3.string()
+var CrawlPageSchema = z4.object({
+  url: z4.string(),
+  title: z4.string(),
+  content: z4.string(),
+  links: z4.array(z4.string()),
+  crawledAt: z4.string()
 });
-var CrawlResultSchema = z3.object({
-  pages: z3.array(CrawlPageSchema)
+var CrawlResultSchema = z4.object({
+  pages: z4.array(CrawlPageSchema)
 });
-var HeadlessResultSchema = z3.object({
-  html: z3.string(),
-  markdown: z3.string(),
-  links: z3.array(z3.union([CrawledLinkSchema, z3.string()]))
+var HeadlessResultSchema = z4.object({
+  html: z4.string(),
+  markdown: z4.string(),
+  links: z4.array(z4.union([CrawledLinkSchema, z4.string()]))
 });
 function validateHeadlessResult(data) {
   return HeadlessResultSchema.parse(data);
@@ -4442,33 +5186,33 @@ function validateHeadlessResult(data) {
 function validateCrawlResult(data) {
   return CrawlResultSchema.parse(data);
 }
-var MethodInfoSchema = z3.object({
-  name: z3.string(),
-  async: z3.boolean(),
-  signature: z3.string(),
-  startLine: z3.number(),
-  endLine: z3.number(),
-  calls: z3.array(z3.string())
+var MethodInfoSchema = z4.object({
+  name: z4.string(),
+  async: z4.boolean(),
+  signature: z4.string(),
+  startLine: z4.number(),
+  endLine: z4.number(),
+  calls: z4.array(z4.string())
 });
-var CodeNodeSchema = z3.object({
-  type: z3.enum(["function", "class"]),
-  name: z3.string(),
-  exported: z3.boolean(),
-  startLine: z3.number(),
-  endLine: z3.number(),
-  async: z3.boolean().optional(),
-  signature: z3.string().optional(),
-  calls: z3.array(z3.string()).optional(),
-  methods: z3.array(MethodInfoSchema).optional()
+var CodeNodeSchema = z4.object({
+  type: z4.enum(["function", "class"]),
+  name: z4.string(),
+  exported: z4.boolean(),
+  startLine: z4.number(),
+  endLine: z4.number(),
+  async: z4.boolean().optional(),
+  signature: z4.string().optional(),
+  calls: z4.array(z4.string()).optional(),
+  methods: z4.array(MethodInfoSchema).optional()
 });
-var ImportInfoSchema = z3.object({
-  source: z3.string(),
-  imported: z3.string(),
-  alias: z3.string().optional().nullable()
+var ImportInfoSchema = z4.object({
+  source: z4.string(),
+  imported: z4.string(),
+  alias: z4.string().optional().nullable()
 });
-var ParsePythonResultSchema = z3.object({
-  nodes: z3.array(CodeNodeSchema),
-  imports: z3.array(ImportInfoSchema)
+var ParsePythonResultSchema = z4.object({
+  nodes: z4.array(CodeNodeSchema),
+  imports: z4.array(ImportInfoSchema)
 });
 function validateParsePythonResult(data) {
   return ParsePythonResultSchema.parse(data);
@@ -4476,6 +5220,15 @@ function validateParsePythonResult(data) {
 
 // src/crawl/bridge.ts
 var logger3 = createLogger("python-bridge");
+function getPythonExecutable() {
+  return process.platform === "win32" ? "python" : "python3";
+}
+function getVenvPythonPath(pluginRoot) {
+  if (process.platform === "win32") {
+    return path3.join(pluginRoot, ".venv", "Scripts", "python.exe");
+  }
+  return path3.join(pluginRoot, ".venv", "bin", "python3");
+}
 var PythonBridge = class {
   process = null;
   pending = /* @__PURE__ */ new Map();
@@ -4485,20 +5238,21 @@ var PythonBridge = class {
   start() {
     if (this.process) return Promise.resolve();
     const currentFilePath = fileURLToPath(import.meta.url);
-    const isProduction = currentFilePath.includes("/dist/");
+    const distPattern = `${path3.sep}dist${path3.sep}`;
+    const isProduction = currentFilePath.includes(distPattern);
     let pythonWorkerPath;
     let pythonPath;
     if (isProduction) {
-      const distIndex = currentFilePath.indexOf("/dist/");
+      const distIndex = currentFilePath.indexOf(distPattern);
       const pluginRoot = currentFilePath.substring(0, distIndex);
       pythonWorkerPath = path3.join(pluginRoot, "python", "crawl_worker.py");
-      const venvPython = path3.join(pluginRoot, ".venv", "bin", "python3");
-      pythonPath = existsSync4(venvPython) ? venvPython : "python3";
+      const venvPython = getVenvPythonPath(pluginRoot);
+      pythonPath = existsSync4(venvPython) ? venvPython : getPythonExecutable();
     } else {
       const srcDir = path3.dirname(path3.dirname(currentFilePath));
       const projectRoot = path3.dirname(srcDir);
       pythonWorkerPath = path3.join(projectRoot, "python", "crawl_worker.py");
-      pythonPath = "python3";
+      pythonPath = getPythonExecutable();
     }
     logger3.debug(
       { pythonWorkerPath, pythonPath, currentFilePath, isProduction },
@@ -4734,17 +5488,19 @@ var PythonBridge = class {
 };
 
 // src/db/embeddings.ts
-import { homedir as homedir3 } from "os";
-import { join as join10 } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join11 } from "path";
 import { pipeline, env } from "@huggingface/transformers";
-env.cacheDir = join10(homedir3(), ".cache", "huggingface-transformers");
+env.cacheDir = join11(homedir2(), ".cache", "huggingface-transformers");
 var EmbeddingEngine = class {
   extractor = null;
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly -- mutated in embed()
+  _dimensions = null;
   modelName;
-  dimensions;
-  constructor(modelName = "Xenova/all-MiniLM-L6-v2", dimensions = 384) {
+  batchSize;
+  constructor(modelName = "Xenova/all-MiniLM-L6-v2", batchSize = 32) {
     this.modelName = modelName;
-    this.dimensions = dimensions;
+    this.batchSize = batchSize;
   }
   async initialize() {
     if (this.extractor !== null) return;
@@ -4764,23 +5520,43 @@ var EmbeddingEngine = class {
       normalize: true
     });
     const result = Array.from(output.data);
+    this._dimensions ??= result.length;
     return result.map((v) => Number(v));
   }
   async embedBatch(texts) {
-    const BATCH_SIZE = 32;
     const results = [];
-    for (let i = 0; i < texts.length; i += BATCH_SIZE) {
-      const batch = texts.slice(i, i + BATCH_SIZE);
+    for (let i = 0; i < texts.length; i += this.batchSize) {
+      const batch = texts.slice(i, i + this.batchSize);
       const batchResults = await Promise.all(batch.map((text) => this.embed(text)));
       results.push(...batchResults);
-      if (i + BATCH_SIZE < texts.length) {
+      if (i + this.batchSize < texts.length) {
         await new Promise((resolve4) => setTimeout(resolve4, 100));
       }
     }
     return results;
   }
+  /**
+   * Get cached embedding dimensions. Throws if embed() hasn't been called yet.
+   * Use ensureDimensions() if you need to guarantee dimensions are available.
+   */
   getDimensions() {
-    return this.dimensions;
+    if (this._dimensions === null) {
+      throw new Error("Cannot get dimensions before first embed() call");
+    }
+    return this._dimensions;
+  }
+  /**
+   * Ensure dimensions are available, initializing the model if needed.
+   * Returns the embedding dimensions for the current model.
+   */
+  async ensureDimensions() {
+    if (this._dimensions === null) {
+      await this.embed("");
+    }
+    if (this._dimensions === null) {
+      throw new Error("Failed to determine embedding dimensions");
+    }
+    return this._dimensions;
   }
   /**
    * Dispose the embedding pipeline to free resources.
@@ -4798,17 +5574,18 @@ var EmbeddingEngine = class {
 import * as lancedb from "@lancedb/lancedb";
 
 // src/types/document.ts
-import { z as z4 } from "zod";
-var DocumentTypeSchema = z4.enum(["file", "chunk", "web"]);
-var DocumentMetadataSchema = z4.object({
-  path: z4.string().optional(),
-  url: z4.string().optional(),
+import { z as z5 } from "zod";
+var DocumentTypeSchema = z5.enum(["file", "chunk", "web"]);
+var DocumentMetadataSchema = z5.object({
+  path: z5.string().optional(),
+  url: z5.string().optional(),
   type: DocumentTypeSchema,
-  storeId: z4.string(),
-  indexedAt: z4.union([z4.string(), z4.date()]),
-  fileHash: z4.string().optional(),
-  chunkIndex: z4.number().optional(),
-  totalChunks: z4.number().optional()
+  storeId: z5.string(),
+  indexedAt: z5.string(),
+  // ISO 8601 string (what JSON serialization produces)
+  fileHash: z5.string().optional(),
+  chunkIndex: z5.number().optional(),
+  totalChunks: z5.number().optional()
 }).loose();
 
 // src/db/lance.ts
@@ -4816,10 +5593,23 @@ var LanceStore = class {
   connection = null;
   tables = /* @__PURE__ */ new Map();
   dataDir;
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly -- set via setDimensions()
+  _dimensions = null;
   constructor(dataDir) {
     this.dataDir = dataDir;
   }
+  /**
+   * Set the embedding dimensions. Must be called before initialize().
+   * This allows dimensions to be derived from the embedding model at runtime.
+   * Idempotent: subsequent calls are ignored if dimensions are already set.
+   */
+  setDimensions(dimensions) {
+    this._dimensions ??= dimensions;
+  }
   async initialize(storeId) {
+    if (this._dimensions === null) {
+      throw new Error("Dimensions not set. Call setDimensions() before initialize().");
+    }
     this.connection ??= await lancedb.connect(this.dataDir);
     const tableName = this.getTableName(storeId);
     const tableNames = await this.connection.tableNames();
@@ -4828,7 +5618,7 @@ var LanceStore = class {
         {
           id: "__init__",
           content: "",
-          vector: new Array(384).fill(0),
+          vector: new Array(this._dimensions).fill(0),
           metadata: "{}"
         }
       ]);
@@ -4850,10 +5640,17 @@ var LanceStore = class {
     await table.add(lanceDocuments);
   }
   async deleteDocuments(storeId, documentIds) {
+    if (documentIds.length === 0) {
+      return;
+    }
     const table = await this.getTable(storeId);
     const idList = documentIds.map((id) => `"${id}"`).join(", ");
     await table.delete(`id IN (${idList})`);
   }
+  async clearAllDocuments(storeId) {
+    const table = await this.getTable(storeId);
+    await table.delete("id IS NOT NULL");
+  }
   async search(storeId, vector, limit, _threshold) {
     const table = await this.getTable(storeId);
     const query = table.vectorSearch(vector).limit(limit).distanceType("cosine");
@@ -4893,7 +5690,9 @@ var LanceStore = class {
   }
   async deleteStore(storeId) {
     const tableName = this.getTableName(storeId);
-    if (this.connection !== null) {
+    this.connection ??= await lancedb.connect(this.dataDir);
+    const tableNames = await this.connection.tableNames();
+    if (tableNames.includes(tableName)) {
       await this.connection.dropTable(tableName);
       this.tables.delete(tableName);
     }
@@ -4943,6 +5742,8 @@ var LazyServiceContainer = class {
   appConfig;
   dataDir;
   // Lazily initialized (heavy)
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly -- mutated in lazy getter
+  _manifest = null;
   _embeddings = null;
   _codeGraph = null;
   _search = null;
@@ -4964,7 +5765,7 @@ var LazyServiceContainer = class {
       logger4.debug("Lazy-initializing EmbeddingEngine");
       this._embeddings = new EmbeddingEngine(
         this.appConfig.embedding.model,
-        this.appConfig.embedding.dimensions
+        this.appConfig.embedding.batchSize
       );
     }
     return this._embeddings;
@@ -4985,7 +5786,12 @@ var LazyServiceContainer = class {
   get search() {
     if (this._search === null) {
       logger4.debug("Lazy-initializing SearchService");
-      this._search = new SearchService(this.lance, this.embeddings, this.codeGraph);
+      this._search = new SearchService(
+        this.lance,
+        this.embeddings,
+        this.codeGraph,
+        this.appConfig.search
+      );
     }
     return this._search;
   }
@@ -4996,17 +5802,38 @@ var LazyServiceContainer = class {
     if (this._index === null) {
       logger4.debug("Lazy-initializing IndexService");
       this._index = new IndexService(this.lance, this.embeddings, {
-        codeGraphService: this.codeGraph
+        codeGraphService: this.codeGraph,
+        manifestService: this.manifest,
+        chunkSize: this.appConfig.indexing.chunkSize,
+        chunkOverlap: this.appConfig.indexing.chunkOverlap,
+        concurrency: this.appConfig.indexing.concurrency,
+        ignorePatterns: this.appConfig.indexing.ignorePatterns
       });
     }
     return this._index;
   }
+  /**
+   * ManifestService is lazily created on first access.
+   */
+  get manifest() {
+    if (this._manifest === null) {
+      logger4.debug("Lazy-initializing ManifestService");
+      this._manifest = new ManifestService(this.dataDir);
+    }
+    return this._manifest;
+  }
   /**
    * Check if embeddings have been initialized (for cleanup purposes).
    */
   get hasEmbeddings() {
     return this._embeddings !== null;
   }
+  /**
+   * Check if search service has been initialized (for cleanup purposes).
+   */
+  get hasSearch() {
+    return this._search !== null;
+  }
 };
 async function createLazyServices(configPath, dataDir, projectRoot) {
   logger4.info({ configPath, dataDir, projectRoot }, "Initializing lazy services");
@@ -5017,16 +5844,21 @@ async function createLazyServices(configPath, dataDir, projectRoot) {
   const pythonBridge = new PythonBridge();
   await pythonBridge.start();
   const lance = new LanceStore(resolvedDataDir);
-  let storeOptions;
-  if (projectRoot !== void 0) {
-    const definitionService = new StoreDefinitionService(projectRoot);
-    const gitignoreService = new GitignoreService(projectRoot);
-    storeOptions = { definitionService, gitignoreService };
-  }
+  const resolvedProjectRoot = config.resolveProjectRoot();
+  const definitionService = new StoreDefinitionService(resolvedProjectRoot);
+  const gitignoreService = new GitignoreService(resolvedProjectRoot);
+  const storeOptions = {
+    definitionService,
+    gitignoreService,
+    projectRoot: resolvedProjectRoot
+  };
   const store = new StoreService(resolvedDataDir, storeOptions);
   await store.initialize();
   const durationMs = Date.now() - startTime;
-  logger4.info({ dataDir: resolvedDataDir, durationMs }, "Lazy services initialized");
+  logger4.info(
+    { dataDir: resolvedDataDir, projectRoot: resolvedProjectRoot, durationMs },
+    "Lazy services initialized"
+  );
   return new LazyServiceContainer(config, appConfig, resolvedDataDir, store, lance, pythonBridge);
 }
 async function createServices(configPath, dataDir, projectRoot) {
@@ -5037,20 +5869,33 @@ async function createServices(configPath, dataDir, projectRoot) {
   const pythonBridge = new PythonBridge();
   await pythonBridge.start();
   const lance = new LanceStore(resolvedDataDir);
-  const embeddings = new EmbeddingEngine(appConfig.embedding.model, appConfig.embedding.dimensions);
+  const embeddings = new EmbeddingEngine(appConfig.embedding.model, appConfig.embedding.batchSize);
   await embeddings.initialize();
-  let storeOptions;
-  if (projectRoot !== void 0) {
-    const definitionService = new StoreDefinitionService(projectRoot);
-    const gitignoreService = new GitignoreService(projectRoot);
-    storeOptions = { definitionService, gitignoreService };
-  }
+  const resolvedProjectRoot = config.resolveProjectRoot();
+  const definitionService = new StoreDefinitionService(resolvedProjectRoot);
+  const gitignoreService = new GitignoreService(resolvedProjectRoot);
+  const storeOptions = {
+    definitionService,
+    gitignoreService,
+    projectRoot: resolvedProjectRoot
+  };
   const store = new StoreService(resolvedDataDir, storeOptions);
   await store.initialize();
   const codeGraph = new CodeGraphService(resolvedDataDir, pythonBridge);
-  const search = new SearchService(lance, embeddings, codeGraph);
-  const index = new IndexService(lance, embeddings, { codeGraphService: codeGraph });
-  logger4.info({ dataDir: resolvedDataDir }, "Services initialized successfully");
+  const manifest = new ManifestService(resolvedDataDir);
+  const search = new SearchService(lance, embeddings, codeGraph, appConfig.search);
+  const index = new IndexService(lance, embeddings, {
+    codeGraphService: codeGraph,
+    manifestService: manifest,
+    chunkSize: appConfig.indexing.chunkSize,
+    chunkOverlap: appConfig.indexing.chunkOverlap,
+    concurrency: appConfig.indexing.concurrency,
+    ignorePatterns: appConfig.indexing.ignorePatterns
+  });
+  logger4.info(
+    { dataDir: resolvedDataDir, projectRoot: resolvedProjectRoot },
+    "Services initialized successfully"
+  );
   return {
     config,
     store,
@@ -5059,12 +5904,20 @@ async function createServices(configPath, dataDir, projectRoot) {
     lance,
     embeddings,
     codeGraph,
-    pythonBridge
+    pythonBridge,
+    manifest
   };
 }
 async function destroyServices(services) {
   logger4.info("Shutting down services");
   const errors = [];
+  const isLazyContainer = services instanceof LazyServiceContainer;
+  const shouldCleanupSearch = !isLazyContainer || services.hasSearch;
+  if (shouldCleanupSearch) {
+    services.search.cleanup();
+  } else {
+    logger4.debug("Skipping search cleanup (not initialized)");
+  }
   try {
     await services.pythonBridge.stop();
   } catch (e) {
@@ -5072,7 +5925,6 @@ async function destroyServices(services) {
     logger4.error({ error }, "Error stopping Python bridge");
     errors.push(error);
   }
-  const isLazyContainer = services instanceof LazyServiceContainer;
   const shouldDisposeEmbeddings = !isLazyContainer || services.hasEmbeddings;
   if (shouldDisposeEmbeddings) {
     try {
@@ -5102,6 +5954,7 @@ async function destroyServices(services) {
 
 export {
   AdapterRegistry,
+  ProjectRootService,
   createLogger,
   shutdownLogger,
   summarizePayload,
@@ -5109,8 +5962,6 @@ export {
   PythonBridge,
   ChunkingService,
   ASTParser,
-  createStoreId,
-  createDocumentId,
   ok,
   err,
   classifyWebContentType,
@@ -5118,10 +5969,11 @@ export {
   isRepoStoreDefinition,
   isWebStoreDefinition,
   StoreDefinitionService,
+  isGitUrl,
   extractRepoName,
   JobService,
   createLazyServices,
   createServices,
   destroyServices
 };
-//# sourceMappingURL=chunk-VKTVMW45.js.map
+//# sourceMappingURL=chunk-RDDGZIDL.js.map