kontext-engine 0.1.4 → 0.1.5

package/dist/index.js

@@ -802,29 +802,29 @@ async function createLocalEmbedder() {
 }
 var VOYAGE_API_URL = "https://api.voyageai.com/v1/embeddings";
 var VOYAGE_MODEL = "voyage-code-3";
-var VOYAGE_DIMENSIONS = 1024;
+var VOYAGE_DEFAULT_DIMENSIONS = 1024;
 var VOYAGE_BATCH_SIZE = 128;
-function createVoyageEmbedder(apiKey) {
+function createVoyageEmbedder(apiKey, dimensions = VOYAGE_DEFAULT_DIMENSIONS) {
   return {
     name: VOYAGE_MODEL,
-    dimensions: VOYAGE_DIMENSIONS,
+    dimensions,
     async embed(texts, onProgress) {
       const results = [];
       for (let i = 0; i < texts.length; i += VOYAGE_BATCH_SIZE) {
         const batch = texts.slice(i, i + VOYAGE_BATCH_SIZE);
-        const vectors = await callVoyageAPI(apiKey, batch);
+        const vectors = await callVoyageAPI(apiKey, batch, "document", dimensions);
         results.push(...vectors);
         onProgress?.(Math.min(i + batch.length, texts.length), texts.length);
       }
       return results;
     },
     async embedSingle(text) {
-      const vectors = await callVoyageAPI(apiKey, [text]);
+      const vectors = await callVoyageAPI(apiKey, [text], "query", dimensions);
       return vectors[0];
     }
   };
 }
-async function callVoyageAPI(apiKey, texts) {
+async function callVoyageAPI(apiKey, texts, inputType, dimensions) {
   const response = await fetchWithRetry(VOYAGE_API_URL, {
     method: "POST",
     headers: {
@@ -834,7 +834,8 @@ async function callVoyageAPI(apiKey, texts) {
     body: JSON.stringify({
       model: VOYAGE_MODEL,
       input: texts,
-      input_type: "document"
+      input_type: inputType,
+      output_dimension: dimensions
     })
   });
   const json = await response.json();
@@ -842,29 +843,29 @@ async function callVoyageAPI(apiKey, texts) {
 }
 var OPENAI_API_URL = "https://api.openai.com/v1/embeddings";
 var OPENAI_MODEL = "text-embedding-3-large";
-var OPENAI_DIMENSIONS = 1024;
+var OPENAI_DEFAULT_DIMENSIONS = 1024;
 var OPENAI_BATCH_SIZE = 128;
-function createOpenAIEmbedder(apiKey) {
+function createOpenAIEmbedder(apiKey, dimensions = OPENAI_DEFAULT_DIMENSIONS) {
   return {
     name: OPENAI_MODEL,
-    dimensions: OPENAI_DIMENSIONS,
+    dimensions,
     async embed(texts, onProgress) {
       const results = [];
       for (let i = 0; i < texts.length; i += OPENAI_BATCH_SIZE) {
         const batch = texts.slice(i, i + OPENAI_BATCH_SIZE);
-        const vectors = await callOpenAIAPI(apiKey, batch);
+        const vectors = await callOpenAIAPI(apiKey, batch, dimensions);
         results.push(...vectors);
         onProgress?.(Math.min(i + batch.length, texts.length), texts.length);
       }
       return results;
     },
     async embedSingle(text) {
-      const vectors = await callOpenAIAPI(apiKey, [text]);
+      const vectors = await callOpenAIAPI(apiKey, [text], dimensions);
       return vectors[0];
     }
   };
 }
-async function callOpenAIAPI(apiKey, texts) {
+async function callOpenAIAPI(apiKey, texts, dimensions) {
   const response = await fetchWithRetry(OPENAI_API_URL, {
     method: "POST",
     headers: {
@@ -874,7 +875,7 @@ async function callOpenAIAPI(apiKey, texts) {
     body: JSON.stringify({
       model: OPENAI_MODEL,
       input: texts,
-      dimensions: OPENAI_DIMENSIONS
+      dimensions
     })
   });
   const json = await response.json();
@@ -1038,9 +1039,57 @@ function searchVectors(db, query, limit) {
   }));
 }
 
+// src/utils/errors.ts
+var ErrorCode = {
+  NOT_INITIALIZED: "NOT_INITIALIZED",
+  INDEX_FAILED: "INDEX_FAILED",
+  PARSE_FAILED: "PARSE_FAILED",
+  CHUNK_FAILED: "CHUNK_FAILED",
+  EMBEDDER_FAILED: "EMBEDDER_FAILED",
+  SEARCH_FAILED: "SEARCH_FAILED",
+  CONFIG_INVALID: "CONFIG_INVALID",
+  DB_CORRUPTED: "DB_CORRUPTED",
+  DB_WRITE_FAILED: "DB_WRITE_FAILED",
+  WATCHER_FAILED: "WATCHER_FAILED",
+  LLM_FAILED: "LLM_FAILED"
+};
+var KontextError = class extends Error {
+  code;
+  constructor(message, code, cause) {
+    super(message, { cause });
+    this.name = "KontextError";
+    this.code = code;
+  }
+};
+var IndexError = class extends KontextError {
+  constructor(message, code, cause) {
+    super(message, code, cause);
+    this.name = "IndexError";
+  }
+};
+var SearchError = class extends KontextError {
+  constructor(message, code, cause) {
+    super(message, code, cause);
+    this.name = "SearchError";
+  }
+};
+var ConfigError = class extends KontextError {
+  constructor(message, code, cause) {
+    super(message, code, cause);
+    this.name = "ConfigError";
+  }
+};
+var DatabaseError = class extends KontextError {
+  constructor(message, code, cause) {
+    super(message, code, cause);
+    this.name = "DatabaseError";
+  }
+};
+
 // src/storage/db.ts
 var DEFAULT_DIMENSIONS = 384;
-function createDatabase(dbPath, dimensions = DEFAULT_DIMENSIONS) {
+var VECTOR_DIMENSIONS_META_KEY = "vector_dimensions";
+function createDatabase(dbPath, dimensions) {
   const dir = path3.dirname(dbPath);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
@@ -1049,7 +1098,8 @@ function createDatabase(dbPath, dimensions = DEFAULT_DIMENSIONS) {
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   sqliteVec.load(db);
-  initializeSchema(db, dimensions);
+  initializeSchema(db, dimensions ?? DEFAULT_DIMENSIONS);
+  ensureVectorDimensions(db, dimensions);
   const stmtUpsertFile = db.prepare(`
     INSERT INTO files (path, language, hash, last_indexed, size)
     VALUES (@path, @language, @hash, @lastIndexed, @size)
@@ -1058,6 +1108,7 @@ function createDatabase(dbPath, dimensions = DEFAULT_DIMENSIONS) {
       hash = excluded.hash,
       last_indexed = excluded.last_indexed,
       size = excluded.size
+    RETURNING id
   `);
   const stmtGetFile = db.prepare(
     "SELECT id, path, language, hash, last_indexed as lastIndexed, size FROM files WHERE path = ?"
@@ -1101,18 +1152,20 @@ function createDatabase(dbPath, dimensions = DEFAULT_DIMENSIONS) {
   );
   return {
     upsertFile(file) {
-      const result = stmtUpsertFile.run({
+      const row = stmtUpsertFile.get({
         path: file.path,
         language: file.language,
         hash: file.hash,
         lastIndexed: Date.now(),
         size: file.size
       });
-      if (result.changes > 0 && result.lastInsertRowid) {
-        return Number(result.lastInsertRowid);
+      if (!row?.id) {
+        throw new DatabaseError(
+          `Failed to upsert file: ${file.path}`,
+          ErrorCode.DB_WRITE_FAILED
+        );
       }
-      const existing = stmtGetFile.get(file.path);
-      return existing?.id ?? 0;
+      return row.id;
     },
     getFile(filePath) {
       const row = stmtGetFile.get(filePath);
@@ -1155,15 +1208,17 @@ function createDatabase(dbPath, dimensions = DEFAULT_DIMENSIONS) {
       return row.lastIndexed;
     },
     deleteFile(filePath) {
-      const file = stmtGetFile.get(filePath);
-      if (file) {
-        const chunkRows = stmtGetChunkIdsByFile.all(file.id);
-        const chunkIds = chunkRows.map((r) => r.id);
-        if (chunkIds.length > 0) {
-          deleteVectorsByChunkIds(db, chunkIds);
+      db.transaction(() => {
+        const file = stmtGetFile.get(filePath);
+        if (file) {
+          const chunkRows = stmtGetChunkIdsByFile.all(file.id);
+          const chunkIds = chunkRows.map((r) => r.id);
+          if (chunkIds.length > 0) {
+            deleteVectorsByChunkIds(db, chunkIds);
+          }
         }
-      }
-      stmtDeleteFile.run(filePath);
+        stmtDeleteFile.run(filePath);
+      })();
     },
     insertChunks(fileId, chunks) {
       const ids = [];
@@ -1258,12 +1313,14 @@ function createDatabase(dbPath, dimensions = DEFAULT_DIMENSIONS) {
       }));
     },
     deleteChunksByFile(fileId) {
-      const chunkRows = stmtGetChunkIdsByFile.all(fileId);
-      const chunkIds = chunkRows.map((r) => r.id);
-      if (chunkIds.length > 0) {
-        deleteVectorsByChunkIds(db, chunkIds);
-      }
-      stmtDeleteChunksByFile.run(fileId);
+      db.transaction(() => {
+        const chunkRows = stmtGetChunkIdsByFile.all(fileId);
+        const chunkIds = chunkRows.map((r) => r.id);
+        if (chunkIds.length > 0) {
+          deleteVectorsByChunkIds(db, chunkIds);
+        }
+        stmtDeleteChunksByFile.run(fileId);
+      })();
     },
     insertDependency(sourceChunkId, targetChunkId, type) {
       stmtInsertDep.run(sourceChunkId, targetChunkId, type);
@@ -1325,6 +1382,59 @@ function getMetaVersion(db) {
     return 0;
   }
 }
+function ensureVectorDimensions(db, expectedDimensions) {
+  const actual = getExistingVectorDimensions(db);
+  const stored = db.prepare("SELECT value FROM meta WHERE key = ?").get(VECTOR_DIMENSIONS_META_KEY);
+  const storedValue = stored?.value;
+  const storedDimensions = storedValue ? Number.parseInt(storedValue, 10) : void 0;
+  if (storedDimensions !== void 0 && (!Number.isInteger(storedDimensions) || storedDimensions <= 0)) {
+    throw new DatabaseError(
+      `Invalid stored vector dimensions metadata: ${storedValue ?? "unknown"}`,
+      ErrorCode.DB_CORRUPTED
+    );
+  }
+  if (actual !== null && storedDimensions !== void 0 && storedDimensions !== actual) {
+    throw new DatabaseError(
+      `Vector dimensions metadata mismatch: meta=${storedDimensions}, table=${actual}.`,
+      ErrorCode.DB_CORRUPTED
+    );
+  }
+  if (expectedDimensions === void 0) {
+    if (storedDimensions !== void 0) return;
+    const dimensions = actual ?? DEFAULT_DIMENSIONS;
+    db.prepare(
+      "INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)"
+    ).run(VECTOR_DIMENSIONS_META_KEY, String(dimensions));
+    return;
+  }
+  if (!stored) {
+    const dimensions = actual ?? expectedDimensions;
+    db.prepare(
+      "INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)"
+    ).run(VECTOR_DIMENSIONS_META_KEY, String(dimensions));
+    if (actual !== null && actual !== expectedDimensions) {
+      throw new DatabaseError(
+        `Vector dimension mismatch: index uses ${actual} dims, but config requests ${expectedDimensions} dims. Rebuild the index.`,
+        ErrorCode.CONFIG_INVALID
+      );
+    }
+    return;
+  }
+  if (storedDimensions !== expectedDimensions) {
+    throw new DatabaseError(
+      `Vector dimension mismatch: index uses ${storedDimensions} dims, but config requests ${expectedDimensions} dims. Rebuild the index.`,
+      ErrorCode.CONFIG_INVALID
+    );
+  }
+}
+function getExistingVectorDimensions(db) {
+  const row = db.prepare("SELECT sql FROM sqlite_master WHERE name = 'chunk_vectors'").get();
+  const sql = row?.sql;
+  if (!sql) return null;
+  const match = sql.match(/embedding\s+float\[(\d+)\]/i);
+  if (!match) return null;
+  return Number.parseInt(match[1], 10);
+}
 
 // src/search/vector.ts
 function distanceToScore(distance) {
@@ -2155,7 +2265,9 @@ var COMMON_STEMS = {
   transformer: "transform",
   transformation: "transform",
   connection: "connect",
+  connecting: "connect",
   connector: "connect",
+  migrating: "migrate",
   migration: "migrate",
   scheduling: "schedule",
   scheduler: "schedule",
@@ -2164,7 +2276,8 @@ var COMMON_STEMS = {
   routing: "route",
   router: "route",
   indexing: "index",
-  indexer: "index"
+  indexer: "index",
+  subscribing: "subscribe"
 };
 var STEM_SUFFIXES = [
   "tion",
@@ -2358,53 +2471,6 @@ async function steer(provider, query, limit, searchExecutor) {
 import fs6 from "fs";
 import path5 from "path";
 
-// src/utils/errors.ts
-var ErrorCode = {
-  NOT_INITIALIZED: "NOT_INITIALIZED",
-  INDEX_FAILED: "INDEX_FAILED",
-  PARSE_FAILED: "PARSE_FAILED",
-  CHUNK_FAILED: "CHUNK_FAILED",
-  EMBEDDER_FAILED: "EMBEDDER_FAILED",
-  SEARCH_FAILED: "SEARCH_FAILED",
-  CONFIG_INVALID: "CONFIG_INVALID",
-  DB_CORRUPTED: "DB_CORRUPTED",
-  DB_WRITE_FAILED: "DB_WRITE_FAILED",
-  WATCHER_FAILED: "WATCHER_FAILED",
-  LLM_FAILED: "LLM_FAILED"
-};
-var KontextError = class extends Error {
-  code;
-  constructor(message, code, cause) {
-    super(message, { cause });
-    this.name = "KontextError";
-    this.code = code;
-  }
-};
-var IndexError = class extends KontextError {
-  constructor(message, code, cause) {
-    super(message, code, cause);
-    this.name = "IndexError";
-  }
-};
-var SearchError = class extends KontextError {
-  constructor(message, code, cause) {
-    super(message, code, cause);
-    this.name = "SearchError";
-  }
-};
-var ConfigError = class extends KontextError {
-  constructor(message, code, cause) {
-    super(message, code, cause);
-    this.name = "ConfigError";
-  }
-};
-var DatabaseError = class extends KontextError {
-  constructor(message, code, cause) {
-    super(message, code, cause);
-    this.name = "DatabaseError";
-  }
-};
-
 // src/utils/logger.ts
 var LogLevel = {
   DEBUG: 0,
@@ -2447,6 +2513,8 @@ function createLogger(options) {
 // src/cli/commands/config.ts
 import fs5 from "fs";
 import path4 from "path";
+var CTX_DIR = ".ctx";
+var CONFIG_FILENAME = "config.json";
 var DEFAULT_CONFIG = {
   embedder: {
     provider: "local",
@@ -2491,11 +2559,110 @@ var VALIDATION_RULES = {
     message: `Must be null or one of: ${[...VALID_LLM_PROVIDERS].join(", ")}`
   }
 };
+function resolveCtxDir(projectPath) {
+  const absoluteRoot = path4.resolve(projectPath);
+  const ctxDir = path4.join(absoluteRoot, CTX_DIR);
+  if (!fs5.existsSync(ctxDir)) {
+    throw new ConfigError(
+      `Project not initialized. Run "ctx init" first. (${CTX_DIR}/ not found)`,
+      ErrorCode.NOT_INITIALIZED
+    );
+  }
+  return ctxDir;
+}
+function configPath(ctxDir) {
+  return path4.join(ctxDir, CONFIG_FILENAME);
+}
+function readConfig(ctxDir) {
+  const filePath = configPath(ctxDir);
+  if (!fs5.existsSync(filePath)) {
+    writeConfig(ctxDir, DEFAULT_CONFIG);
+    return structuredClone(DEFAULT_CONFIG);
+  }
+  const raw = fs5.readFileSync(filePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  return mergeWithDefaults(parsed);
+}
+function writeConfig(ctxDir, config) {
+  fs5.writeFileSync(
+    configPath(ctxDir),
+    JSON.stringify(config, null, 2) + "\n"
+  );
+}
+function mergeWithDefaults(partial) {
+  return {
+    embedder: { ...DEFAULT_CONFIG.embedder, ...partial.embedder },
+    search: {
+      ...DEFAULT_CONFIG.search,
+      ...partial.search,
+      weights: { ...DEFAULT_CONFIG.search.weights, ...partial.search?.weights }
+    },
+    watch: { ...DEFAULT_CONFIG.watch, ...partial.watch },
+    llm: { ...DEFAULT_CONFIG.llm, ...partial.llm }
+  };
+}
+function runConfigShow(projectPath) {
+  const ctxDir = resolveCtxDir(projectPath);
+  const config = readConfig(ctxDir);
+  return {
+    config,
+    text: JSON.stringify(config, null, 2)
+  };
+}
+
+// src/cli/embedder.ts
+function getProjectEmbedderConfig(projectPath) {
+  const { config } = runConfigShow(projectPath);
+  return config.embedder;
+}
+async function createProjectEmbedder(projectPath) {
+  const config = getProjectEmbedderConfig(projectPath);
+  validateProjectEmbedderConfig(config);
+  switch (config.provider) {
+    case "local":
+      return await createLocalEmbedder();
+    case "voyage": {
+      const apiKey = requireApiKey("CTX_VOYAGE_KEY", "voyage");
+      return createVoyageEmbedder(apiKey, config.dimensions);
+    }
+    case "openai": {
+      const apiKey = requireApiKey("CTX_OPENAI_KEY", "openai");
+      return createOpenAIEmbedder(apiKey, config.dimensions);
+    }
+    default:
+      throw new ConfigError(
+        `Unsupported embedder provider "${config.provider}". Use local, voyage, or openai.`,
+        ErrorCode.CONFIG_INVALID
+      );
+  }
+}
+function requireApiKey(envVar, provider) {
+  const value = process.env[envVar];
+  if (typeof value === "string" && value.length > 0) return value;
+  throw new ConfigError(
+    `Embedder provider "${provider}" requires ${envVar}. Export ${envVar} before running this command.`,
+    ErrorCode.CONFIG_INVALID
+  );
+}
+function validateProjectEmbedderConfig(config) {
+  if (!Number.isInteger(config.dimensions) || config.dimensions <= 0) {
+    throw new ConfigError(
+      `Invalid embedder.dimensions (${String(config.dimensions)}). Must be a positive integer.`,
+      ErrorCode.CONFIG_INVALID
+    );
+  }
+  if (config.provider === "local" && config.dimensions !== 384) {
+    throw new ConfigError(
+      'Local embedder requires "embedder.dimensions" = 384. Update config or switch provider.',
+      ErrorCode.CONFIG_INVALID
+    );
+  }
+}
 
 // src/cli/commands/init.ts
-var CTX_DIR = ".ctx";
+var CTX_DIR2 = ".ctx";
 var DB_FILENAME = "index.db";
-var CONFIG_FILENAME = "config.json";
+var CONFIG_FILENAME2 = "config.json";
 var GITIGNORE_ENTRY = ".ctx/";
 function ensureGitignore(projectRoot) {
   const gitignorePath = path5.join(projectRoot, ".gitignore");
@@ -2511,10 +2678,10 @@ function ensureGitignore(projectRoot) {
   }
 }
 function ensureConfig(ctxDir) {
-  const configPath = path5.join(ctxDir, CONFIG_FILENAME);
-  if (fs6.existsSync(configPath)) return;
+  const configPath2 = path5.join(ctxDir, CONFIG_FILENAME2);
+  if (fs6.existsSync(configPath2)) return;
   fs6.writeFileSync(
-    configPath,
+    configPath2,
     JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n"
   );
 }
@@ -2536,12 +2703,13 @@ async function runInit(projectPath, options = {}) {
   const absoluteRoot = path5.resolve(projectPath);
   const start = performance.now();
   log(`Indexing ${absoluteRoot}...`);
-  const ctxDir = path5.join(absoluteRoot, CTX_DIR);
+  const ctxDir = path5.join(absoluteRoot, CTX_DIR2);
   if (!fs6.existsSync(ctxDir)) fs6.mkdirSync(ctxDir, { recursive: true });
   ensureGitignore(absoluteRoot);
   ensureConfig(ctxDir);
+  const embedderConfig = getProjectEmbedderConfig(absoluteRoot);
   const dbPath = path5.join(ctxDir, DB_FILENAME);
-  const db = createDatabase(dbPath);
+  const db = createDatabase(dbPath, embedderConfig.dimensions);
   try {
     const discovered = await discoverFiles({
       root: absoluteRoot,
@@ -2629,7 +2797,7 @@ async function runInit(projectPath, options = {}) {
     log(`  ${allChunksWithMeta.length} chunks created`);
     let vectorsCreated = 0;
     if (!options.skipEmbedding && allChunksWithMeta.length > 0) {
-      const embedder = await createEmbedder();
+      const embedder = await createEmbedder(absoluteRoot);
       const texts = allChunksWithMeta.map(
         (cm) => prepareChunkText(cm.fileRelPath, cm.chunk.parent, cm.chunk.text)
       );
@@ -2651,7 +2819,7 @@ async function runInit(projectPath, options = {}) {
     log(
       `  ${discovered.length} files \u2192 ${allChunksWithMeta.length} chunks` + (vectorsCreated > 0 ? ` \u2192 ${vectorsCreated} vectors` : "")
     );
-    log(`  Database: ${CTX_DIR}/${DB_FILENAME} (${formatBytes(dbSize)})`);
+    log(`  Database: ${CTX_DIR2}/${DB_FILENAME} (${formatBytes(dbSize)})`);
     return {
       filesDiscovered: discovered.length,
       filesAdded: changes.added.length,
@@ -2667,14 +2835,14 @@ async function runInit(projectPath, options = {}) {
     db.close();
   }
 }
-async function createEmbedder() {
-  return createLocalEmbedder();
+async function createEmbedder(projectPath) {
+  return createProjectEmbedder(projectPath);
 }
 
 // src/cli/commands/query.ts
 import fs7 from "fs";
 import path6 from "path";
-var CTX_DIR2 = ".ctx";
+var CTX_DIR3 = ".ctx";
 var DB_FILENAME2 = "index.db";
 var SNIPPET_MAX_LENGTH = 200;
 var STRATEGY_WEIGHTS = {
@@ -2740,17 +2908,21 @@ function isPathLike(query) {
 async function runQuery(projectPath, query, options) {
   const limit = normalizeLimit(options.limit);
   const absoluteRoot = path6.resolve(projectPath);
-  const dbPath = path6.join(absoluteRoot, CTX_DIR2, DB_FILENAME2);
+  const dbPath = path6.join(absoluteRoot, CTX_DIR3, DB_FILENAME2);
   if (!fs7.existsSync(dbPath)) {
     throw new KontextError(
-      `Project not initialized. Run "ctx init" first. (${CTX_DIR2}/${DB_FILENAME2} not found)`,
+      `Project not initialized. Run "ctx init" first. (${CTX_DIR3}/${DB_FILENAME2} not found)`,
       ErrorCode.NOT_INITIALIZED
     );
   }
   const start = performance.now();
-  const db = createDatabase(dbPath);
+  const embedderConfig = getProjectEmbedderConfig(absoluteRoot);
+  const db = createDatabase(dbPath, embedderConfig.dimensions);
   try {
-    const strategyResults = await runStrategies(db, query, { ...options, limit });
+    const strategyResults = await runStrategies(db, absoluteRoot, query, {
+      ...options,
+      limit
+    });
     const pathBoostTerms = extractPathBoostTerms(query);
     const fused = fusionMergeWithPathBoost(strategyResults, limit, pathBoostTerms);
     const outputResults = fused.map(toOutputResult);
@@ -2770,7 +2942,7 @@ async function runQuery(projectPath, query, options) {
     db.close();
   }
 }
-async function runStrategies(db, query, options) {
+async function runStrategies(db, projectPath, query, options) {
   const results = [];
   const filters = options.language ? { language: options.language } : void 0;
   const limit = options.limit * 3;
@@ -2779,6 +2951,7 @@ async function runStrategies(db, query, options) {
     const weight = effectiveWeights[strategy];
     const searchResults = await executeStrategy(
       db,
+      projectPath,
       strategy,
       query,
       limit,
@@ -2790,10 +2963,10 @@ async function runStrategies(db, query, options) {
   }
   return results;
 }
-async function executeStrategy(db, strategy, query, limit, filters) {
+async function executeStrategy(db, projectPath, strategy, query, limit, filters) {
   switch (strategy) {
     case "vector": {
-      const embedder = await loadEmbedder();
+      const embedder = await loadEmbedder(projectPath);
       return vectorSearch(db, embedder, query, limit, filters);
     }
     case "fts":
@@ -2826,16 +2999,23 @@ async function executeStrategy(db, strategy, query, limit, filters) {
   }
 }
 var embedderInstance = null;
-async function loadEmbedder() {
-  if (embedderInstance) return embedderInstance;
-  embedderInstance = await createLocalEmbedder();
+var embedderKey = null;
+function getCacheKey(projectPath) {
+  const config = getProjectEmbedderConfig(projectPath);
+  return `${projectPath}:${config.provider}:${config.model}:${config.dimensions}`;
+}
+async function loadEmbedder(projectPath) {
+  const cacheKey = getCacheKey(projectPath);
+  if (embedderInstance && embedderKey === cacheKey) return embedderInstance;
+  embedderInstance = await createProjectEmbedder(projectPath);
+  embedderKey = cacheKey;
   return embedderInstance;
 }
 
 // src/cli/commands/ask.ts
 import fs8 from "fs";
 import path7 from "path";
-var CTX_DIR3 = ".ctx";
+var CTX_DIR4 = ".ctx";
 var DB_FILENAME3 = "index.db";
 var SNIPPET_MAX_LENGTH2 = 200;
 var FALLBACK_NOTICE = "No LLM provider configured. Set CTX_GEMINI_KEY, CTX_OPENAI_KEY, or CTX_ANTHROPIC_KEY. Running basic search instead.";
@@ -2895,13 +3075,13 @@ function formatTextOutput2(output) {
   );
   return lines.join("\n");
 }
-function createSearchExecutor(db, query) {
+function createSearchExecutor(db, projectPath, query) {
   const pathBoostTerms = extractPathBoostTerms(query);
   return async (strategies, limit) => {
     const strategyResults = [];
     const fetchLimit = limit * 3;
     for (const plan of strategies) {
-      const results = await executeStrategy2(db, plan, fetchLimit);
+      const results = await executeStrategy2(db, projectPath, plan, fetchLimit);
       if (results.length > 0) {
         strategyResults.push({
           strategy: plan.strategy,
@@ -2920,10 +3100,10 @@ function extractSymbolNames2(query) {
 function isPathLike2(query) {
   return query.includes("/") || query.includes("*") || query.includes(".");
 }
-async function executeStrategy2(db, plan, limit) {
+async function executeStrategy2(db, projectPath, plan, limit) {
   switch (plan.strategy) {
     case "vector": {
-      const embedder = await loadEmbedder2();
+      const embedder = await loadEmbedder2(projectPath);
       return vectorSearch(db, embedder, plan.query, limit);
     }
     case "fts":
@@ -2952,13 +3132,20 @@ async function executeStrategy2(db, plan, limit) {
   }
 }
 var embedderInstance2 = null;
-async function loadEmbedder2() {
-  if (embedderInstance2) return embedderInstance2;
-  embedderInstance2 = await createLocalEmbedder();
+var embedderKey2 = null;
+function getCacheKey2(projectPath) {
+  const config = getProjectEmbedderConfig(projectPath);
+  return `${projectPath}:${config.provider}:${config.model}:${config.dimensions}`;
+}
+async function loadEmbedder2(projectPath) {
+  const cacheKey = getCacheKey2(projectPath);
+  if (embedderInstance2 && embedderKey2 === cacheKey) return embedderInstance2;
+  embedderInstance2 = await createProjectEmbedder(projectPath);
+  embedderKey2 = cacheKey;
   return embedderInstance2;
 }
-async function fallbackSearch(db, query, limit) {
-  const executor = createSearchExecutor(db, query);
+async function fallbackSearch(db, projectPath, query, limit) {
+  const executor = createSearchExecutor(db, projectPath, query);
   const fallbackStrategies = buildFallbackStrategies(query);
   const results = await executor(fallbackStrategies, limit);
   return {
@@ -2978,25 +3165,26 @@ async function fallbackSearch(db, query, limit) {
 async function runAsk(projectPath, query, options) {
   const limit = normalizeLimit2(options.limit);
   const absoluteRoot = path7.resolve(projectPath);
-  const dbPath = path7.join(absoluteRoot, CTX_DIR3, DB_FILENAME3);
+  const dbPath = path7.join(absoluteRoot, CTX_DIR4, DB_FILENAME3);
   if (!fs8.existsSync(dbPath)) {
     throw new KontextError(
-      `Project not initialized. Run "ctx init" first. (${CTX_DIR3}/${DB_FILENAME3} not found)`,
+      `Project not initialized. Run "ctx init" first. (${CTX_DIR4}/${DB_FILENAME3} not found)`,
       ErrorCode.NOT_INITIALIZED
     );
   }
-  const db = createDatabase(dbPath);
+  const embedderConfig = getProjectEmbedderConfig(absoluteRoot);
+  const db = createDatabase(dbPath, embedderConfig.dimensions);
   try {
     const provider = options.provider ?? null;
     if (!provider) {
-      const output = await fallbackSearch(db, query, limit);
+      const output = await fallbackSearch(db, absoluteRoot, query, limit);
       output.warning = FALLBACK_NOTICE;
       if (options.format === "text") {
         output.text = formatTextOutput2(output);
       }
       return output;
     }
-    const executor = createSearchExecutor(db, query);
+    const executor = createSearchExecutor(db, absoluteRoot, query);
     if (options.noExplain) {
       return await runNoExplain(provider, query, limit, options, executor);
     }
@@ -3048,9 +3236,9 @@ async function runWithSteering(provider, query, limit, options, executor) {
 // src/cli/commands/status.ts
 import fs9 from "fs";
 import path8 from "path";
-var CTX_DIR4 = ".ctx";
+var CTX_DIR5 = ".ctx";
 var DB_FILENAME4 = "index.db";
-var CONFIG_FILENAME2 = "config.json";
+var CONFIG_FILENAME3 = "config.json";
 function formatBytes2(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -3065,14 +3253,15 @@ function formatTimestamp(raw) {
 function capitalize(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
-function readConfig(ctxDir) {
-  const configPath = path8.join(ctxDir, CONFIG_FILENAME2);
-  if (!fs9.existsSync(configPath)) return null;
+function readConfig2(ctxDir) {
+  const configPath2 = path8.join(ctxDir, CONFIG_FILENAME3);
+  if (!fs9.existsSync(configPath2)) return null;
   try {
-    const raw = fs9.readFileSync(configPath, "utf-8");
+    const raw = fs9.readFileSync(configPath2, "utf-8");
     const parsed = JSON.parse(raw);
     const embedder = parsed.embedder;
     return {
+      provider: embedder?.provider ?? parsed.provider ?? "unknown",
       model: embedder?.model ?? parsed.model ?? "unknown",
       dimensions: embedder?.dimensions ?? parsed.dimensions ?? 0
     };
@@ -3093,7 +3282,7 @@ function formatStatus(projectPath, output) {
     `Kontext Status \u2014 ${projectPath}`,
     "",
     `  Initialized:  Yes`,
-    `  Database:     ${CTX_DIR4}/${DB_FILENAME4} (${formatBytes2(output.dbSizeBytes)})`
+    `  Database:     ${CTX_DIR5}/${DB_FILENAME4} (${formatBytes2(output.dbSizeBytes)})`
   ];
   if (output.lastIndexed) {
     lines.push(`  Last indexed: ${formatTimestamp(output.lastIndexed)}`);
@@ -3116,7 +3305,7 @@ function formatStatus(projectPath, output) {
   if (output.config) {
     lines.push("");
     lines.push(
-      `  Embedder: local (${output.config.model}, ${output.config.dimensions} dims)`
+      `  Embedder: ${output.config.provider} (${output.config.model}, ${output.config.dimensions} dims)`
     );
   }
   lines.push("");
@@ -3124,7 +3313,7 @@ function formatStatus(projectPath, output) {
 }
 async function runStatus(projectPath) {
   const absoluteRoot = path8.resolve(projectPath);
-  const ctxDir = path8.join(absoluteRoot, CTX_DIR4);
+  const ctxDir = path8.join(absoluteRoot, CTX_DIR5);
   const dbPath = path8.join(ctxDir, DB_FILENAME4);
   if (!fs9.existsSync(dbPath)) {
     const output = {
@@ -3147,7 +3336,7 @@ async function runStatus(projectPath) {
     const vectorCount = db.getVectorCount();
     const languages = db.getLanguageBreakdown();
     const lastIndexed = db.getLastIndexed();
-    const config = readConfig(ctxDir);
+    const config = readConfig2(ctxDir);
     const dbSizeBytes = fs9.statSync(dbPath).size;
     const output = {
       initialized: true,