kontext-engine 0.1.3 → 0.1.5

package/dist/cli/index.js

@@ -2,10 +2,11 @@
 
 // src/cli/index.ts
 import { Command } from "commander";
+import { createRequire as createRequire2 } from "module";
 
 // src/cli/commands/init.ts
-import fs5 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path5 from "path";
 
 // src/indexer/discovery.ts
 import fs from "fs/promises";
@@ -778,6 +779,25 @@ function prepareChunkText(filePath, parent, text) {
   parts.push(text);
   return parts.join("\n");
 }
+var MAX_RETRIES = 3;
+var BASE_DELAY_MS = 500;
+async function fetchWithRetry(url, init) {
+  let lastError = null;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    const response = await fetch(url, init);
+    if (response.ok) return response;
+    if (response.status === 429 && attempt < MAX_RETRIES) {
+      const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+      continue;
+    }
+    throw new Error(
+      `Embedding API error: HTTP ${response.status} ${response.statusText}`
+    );
+  }
+  throw lastError ?? new Error("Embedding API request failed after retries");
+}
 var LOCAL_MODEL_ID = "Xenova/all-MiniLM-L6-v2";
 var LOCAL_DIMENSIONS = 384;
 var LOCAL_BATCH_SIZE = 32;
@@ -835,6 +855,87 @@ async function createLocalEmbedder() {
     }
   };
 }
+var VOYAGE_API_URL = "https://api.voyageai.com/v1/embeddings";
+var VOYAGE_MODEL = "voyage-code-3";
+var VOYAGE_DEFAULT_DIMENSIONS = 1024;
+var VOYAGE_BATCH_SIZE = 128;
+function createVoyageEmbedder(apiKey, dimensions = VOYAGE_DEFAULT_DIMENSIONS) {
+  return {
+    name: VOYAGE_MODEL,
+    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, "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], "query", dimensions);
+      return vectors[0];
+    }
+  };
+}
+async function callVoyageAPI(apiKey, texts, inputType, dimensions) {
+  const response = await fetchWithRetry(VOYAGE_API_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: VOYAGE_MODEL,
+      input: texts,
+      input_type: inputType,
+      output_dimension: dimensions
+    })
+  });
+  const json = await response.json();
+  return json.data.map((d) => normalizeVector(new Float32Array(d.embedding)));
+}
+var OPENAI_API_URL = "https://api.openai.com/v1/embeddings";
+var OPENAI_MODEL = "text-embedding-3-large";
+var OPENAI_DEFAULT_DIMENSIONS = 1024;
+var OPENAI_BATCH_SIZE = 128;
+function createOpenAIEmbedder(apiKey, dimensions = OPENAI_DEFAULT_DIMENSIONS) {
+  return {
+    name: OPENAI_MODEL,
+    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, 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], dimensions);
+      return vectors[0];
+    }
+  };
+}
+async function callOpenAIAPI(apiKey, texts, dimensions) {
+  const response = await fetchWithRetry(OPENAI_API_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: OPENAI_MODEL,
+      input: texts,
+      dimensions
+    })
+  });
+  const json = await response.json();
+  return json.data.map((d) => normalizeVector(new Float32Array(d.embedding)));
+}
 
 // src/utils/errors.ts
 var ErrorCode = {
@@ -876,6 +977,12 @@ var ConfigError = class extends KontextError {
     this.name = "ConfigError";
   }
 };
+var DatabaseError = class extends KontextError {
+  constructor(message, code, cause) {
+    super(message, code, cause);
+    this.name = "DatabaseError";
+  }
+};
 
 // src/utils/error-boundary.ts
 function handleCommandError(err, logger, verbose) {
@@ -1050,7 +1157,8 @@ function searchVectors(db, query, limit) {
 
 // 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 });
@@ -1059,7 +1167,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)
@@ -1068,6 +1177,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 = ?"
@@ -1111,18 +1221,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);
@@ -1165,15 +1277,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 = [];
@@ -1268,12 +1382,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);
@@ -1335,105 +1451,440 @@ 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/cli/commands/init.ts
+// src/cli/commands/config.ts
+import fs5 from "fs";
+import path4 from "path";
 var CTX_DIR = ".ctx";
-var DB_FILENAME = "index.db";
 var CONFIG_FILENAME = "config.json";
-var GITIGNORE_ENTRY = ".ctx/";
-function ensureGitignore(projectRoot) {
-  const gitignorePath = path4.join(projectRoot, ".gitignore");
-  if (fs5.existsSync(gitignorePath)) {
-    const content = fs5.readFileSync(gitignorePath, "utf-8");
-    if (content.includes(GITIGNORE_ENTRY)) return;
-    const suffix = content.endsWith("\n") ? "" : "\n";
-    fs5.writeFileSync(gitignorePath, `${content}${suffix}${GITIGNORE_ENTRY}
-`);
-  } else {
-    fs5.writeFileSync(gitignorePath, `${GITIGNORE_ENTRY}
-`);
+var DEFAULT_CONFIG = {
+  embedder: {
+    provider: "local",
+    model: "Xenova/all-MiniLM-L6-v2",
+    dimensions: 384
+  },
+  search: {
+    defaultLimit: 10,
+    strategies: ["vector", "fts", "ast", "path"],
+    weights: { vector: 1, fts: 0.8, ast: 0.9, path: 0.7, dependency: 0.6 }
+  },
+  watch: {
+    debounceMs: 500,
+    ignored: []
+  },
+  llm: {
+    provider: null,
+    model: null
+  }
+};
+var VALID_EMBEDDER_PROVIDERS = /* @__PURE__ */ new Set(["local", "voyage", "openai"]);
+var VALID_LLM_PROVIDERS = /* @__PURE__ */ new Set(["gemini", "openai", "anthropic"]);
+var VALIDATION_RULES = {
+  "embedder.provider": {
+    validate: (v) => typeof v === "string" && VALID_EMBEDDER_PROVIDERS.has(v),
+    message: `Must be one of: ${[...VALID_EMBEDDER_PROVIDERS].join(", ")}`
+  },
+  "embedder.dimensions": {
+    validate: (v) => typeof v === "number" && v > 0 && Number.isInteger(v),
+    message: "Must be a positive integer"
+  },
+  "search.defaultLimit": {
+    validate: (v) => typeof v === "number" && v > 0 && Number.isInteger(v),
+    message: "Must be a positive integer"
+  },
+  "watch.debounceMs": {
+    validate: (v) => typeof v === "number" && v >= 0 && Number.isInteger(v),
+    message: "Must be a non-negative integer"
+  },
+  "llm.provider": {
+    validate: (v) => v === null || typeof v === "string" && VALID_LLM_PROVIDERS.has(v),
+    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 ensureConfig(ctxDir) {
-  const configPath2 = path4.join(ctxDir, CONFIG_FILENAME);
-  if (fs5.existsSync(configPath2)) return;
-  const config = {
-    version: 1,
-    dimensions: 384,
-    model: "all-MiniLM-L6-v2"
-  };
-  fs5.writeFileSync(configPath2, JSON.stringify(config, null, 2) + "\n");
+function configPath(ctxDir) {
+  return path4.join(ctxDir, CONFIG_FILENAME);
 }
-function formatDuration(ms) {
-  if (ms < 1e3) return `${Math.round(ms)}ms`;
-  return `${(ms / 1e3).toFixed(1)}s`;
+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 formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+function writeConfig(ctxDir, config) {
+  fs5.writeFileSync(
+    configPath(ctxDir),
+    JSON.stringify(config, null, 2) + "\n"
+  );
 }
-function formatLanguageSummary(counts) {
-  const entries = [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([lang, count]) => `${lang}: ${count}`);
-  return entries.join(", ");
+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 }
+  };
 }
-async function runInit(projectPath, options = {}) {
-  const log = options.log ?? console.log;
-  const absoluteRoot = path4.resolve(projectPath);
-  const start = performance.now();
-  log(`Indexing ${absoluteRoot}...`);
-  const ctxDir = path4.join(absoluteRoot, CTX_DIR);
-  if (!fs5.existsSync(ctxDir)) fs5.mkdirSync(ctxDir, { recursive: true });
-  ensureGitignore(absoluteRoot);
-  ensureConfig(ctxDir);
-  const dbPath = path4.join(ctxDir, DB_FILENAME);
-  const db = createDatabase(dbPath);
-  try {
-    const discovered = await discoverFiles({
-      root: absoluteRoot,
-      extraIgnore: [".ctx/"]
-    });
-    const languageCounts = /* @__PURE__ */ new Map();
-    for (const file of discovered) {
-      languageCounts.set(
-        file.language,
-        (languageCounts.get(file.language) ?? 0) + 1
-      );
-    }
-    log(
-      `  Discovered ${discovered.length} files` + (discovered.length > 0 ? ` (${formatLanguageSummary(languageCounts)})` : "")
-    );
-    const changes = await computeChanges(discovered, db);
-    const filesToProcess = [
-      ...changes.added.map((p) => ({ path: p, reason: "added" })),
-      ...changes.modified.map((p) => ({ path: p, reason: "modified" }))
-    ];
-    if (changes.unchanged.length > 0) {
-      log(`  ${changes.unchanged.length} unchanged files skipped`);
+function getNestedValue(obj, key) {
+  const parts = key.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
     }
-    if (changes.deleted.length > 0) {
-      log(`  ${changes.deleted.length} deleted files removed`);
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, key, value) {
+  const parts = key.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (typeof current[part] !== "object" || current[part] === null) {
+      current[part] = {};
     }
-    if (changes.added.length > 0) {
-      log(`  ${changes.added.length} new files to index`);
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function hasNestedKey(obj, key) {
+  const parts = key.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return false;
     }
-    if (changes.modified.length > 0) {
-      log(`  ${changes.modified.length} modified files to re-index`);
+    if (!(part in current)) {
+      return false;
     }
-    for (const deletedPath of changes.deleted) {
-      db.deleteFile(deletedPath);
+    current = current[part];
+  }
+  return true;
+}
+function parseValue(rawValue) {
+  if (rawValue === "null") return null;
+  if (rawValue === "true") return true;
+  if (rawValue === "false") return false;
+  const num = Number(rawValue);
+  if (!Number.isNaN(num) && rawValue.trim() !== "") return num;
+  if (rawValue.startsWith("[") || rawValue.startsWith("{")) {
+    try {
+      return JSON.parse(rawValue);
+    } catch {
     }
-    await initParser();
-    const allChunksWithMeta = [];
-    let filesProcessed = 0;
-    for (const { path: relPath } of filesToProcess) {
-      const discovered_file = discovered.find((f) => f.path === relPath);
-      if (!discovered_file) continue;
-      const existingFile = db.getFile(relPath);
-      if (existingFile) {
-        db.deleteChunksByFile(existingFile.id);
-      }
-      let nodes;
+  }
+  return rawValue;
+}
+function runConfigShow(projectPath) {
+  const ctxDir = resolveCtxDir(projectPath);
+  const config = readConfig(ctxDir);
+  return {
+    config,
+    text: JSON.stringify(config, null, 2)
+  };
+}
+function runConfigGet(projectPath, key) {
+  const ctxDir = resolveCtxDir(projectPath);
+  const config = readConfig(ctxDir);
+  return getNestedValue(config, key);
+}
+function runConfigSet(projectPath, key, rawValue) {
+  const ctxDir = resolveCtxDir(projectPath);
+  const config = readConfig(ctxDir);
+  const value = parseValue(rawValue);
+  const rule = VALIDATION_RULES[key];
+  if (rule && !rule.validate(value)) {
+    throw new ConfigError(`Invalid value for "${key}": ${rule.message}`, ErrorCode.CONFIG_INVALID);
+  }
+  setNestedValue(config, key, value);
+  writeConfig(ctxDir, config);
+}
+function runConfigReset(projectPath, key) {
+  const ctxDir = resolveCtxDir(projectPath);
+  if (!key) {
+    writeConfig(ctxDir, structuredClone(DEFAULT_CONFIG));
+    return;
+  }
+  if (!hasNestedKey(DEFAULT_CONFIG, key)) {
+    throw new ConfigError(`Invalid config key: ${key}`, ErrorCode.CONFIG_INVALID);
+  }
+  const config = readConfig(ctxDir);
+  const defaultValue = getNestedValue(
+    DEFAULT_CONFIG,
+    key
+  );
+  setNestedValue(
+    config,
+    key,
+    structuredClone(defaultValue)
+  );
+  writeConfig(ctxDir, config);
+}
+function registerConfigCommand(program2) {
+  const cmd = program2.command("config").description("Show or modify configuration");
+  function configErrorHandler(err) {
+    const verbose = program2.opts()["verbose"] === true;
+    const logger = createLogger({ level: verbose ? LogLevel.DEBUG : LogLevel.INFO });
+    process.exitCode = handleCommandError(err, logger, verbose);
+  }
+  cmd.command("show").description("Show current configuration").action(() => {
+    try {
+      const output = runConfigShow(process.cwd());
+      console.log(output.text);
+    } catch (err) {
+      configErrorHandler(err);
+    }
+  });
+  cmd.command("get <key>").description("Get a configuration value (dot notation)").action((key) => {
+    try {
+      const value = runConfigGet(process.cwd(), key);
+      console.log(
+        typeof value === "object" ? JSON.stringify(value, null, 2) : String(value)
+      );
+    } catch (err) {
+      configErrorHandler(err);
+    }
+  });
+  cmd.command("set <key> <value>").description("Set a configuration value (dot notation)").action((key, value) => {
+    try {
+      runConfigSet(process.cwd(), key, value);
+      console.log(`Set ${key} = ${value}`);
+    } catch (err) {
+      configErrorHandler(err);
+    }
+  });
+  cmd.command("reset [key]").description("Reset configuration to defaults or reset a specific key").action((key) => {
+    try {
+      runConfigReset(process.cwd(), key);
+      if (key) {
+        console.log(`Reset ${key} to default.`);
+      } else {
+        console.log("Configuration reset to defaults.");
+      }
+    } catch (err) {
+      configErrorHandler(err);
+    }
+  });
+}
+
+// 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_DIR2 = ".ctx";
+var DB_FILENAME = "index.db";
+var CONFIG_FILENAME2 = "config.json";
+var GITIGNORE_ENTRY = ".ctx/";
+function ensureGitignore(projectRoot) {
+  const gitignorePath = path5.join(projectRoot, ".gitignore");
+  if (fs6.existsSync(gitignorePath)) {
+    const content = fs6.readFileSync(gitignorePath, "utf-8");
+    if (content.includes(GITIGNORE_ENTRY)) return;
+    const suffix = content.endsWith("\n") ? "" : "\n";
+    fs6.writeFileSync(gitignorePath, `${content}${suffix}${GITIGNORE_ENTRY}
+`);
+  } else {
+    fs6.writeFileSync(gitignorePath, `${GITIGNORE_ENTRY}
+`);
+  }
+}
+function ensureConfig(ctxDir) {
+  const configPath2 = path5.join(ctxDir, CONFIG_FILENAME2);
+  if (fs6.existsSync(configPath2)) return;
+  fs6.writeFileSync(
+    configPath2,
+    JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n"
+  );
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatLanguageSummary(counts) {
+  const entries = [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([lang, count]) => `${lang}: ${count}`);
+  return entries.join(", ");
+}
+async function runInit(projectPath, options = {}) {
+  const log = options.log ?? console.log;
+  const absoluteRoot = path5.resolve(projectPath);
+  const start = performance.now();
+  log(`Indexing ${absoluteRoot}...`);
+  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, embedderConfig.dimensions);
+  try {
+    const discovered = await discoverFiles({
+      root: absoluteRoot,
+      extraIgnore: [".ctx/"]
+    });
+    const languageCounts = /* @__PURE__ */ new Map();
+    for (const file of discovered) {
+      languageCounts.set(
+        file.language,
+        (languageCounts.get(file.language) ?? 0) + 1
+      );
+    }
+    log(
+      `  Discovered ${discovered.length} files` + (discovered.length > 0 ? ` (${formatLanguageSummary(languageCounts)})` : "")
+    );
+    const changes = await computeChanges(discovered, db);
+    const filesToProcess = [
+      ...changes.added.map((p) => ({ path: p, reason: "added" })),
+      ...changes.modified.map((p) => ({ path: p, reason: "modified" }))
+    ];
+    if (changes.unchanged.length > 0) {
+      log(`  ${changes.unchanged.length} unchanged files skipped`);
+    }
+    if (changes.deleted.length > 0) {
+      log(`  ${changes.deleted.length} deleted files removed`);
+    }
+    if (changes.added.length > 0) {
+      log(`  ${changes.added.length} new files to index`);
+    }
+    if (changes.modified.length > 0) {
+      log(`  ${changes.modified.length} modified files to re-index`);
+    }
+    for (const deletedPath of changes.deleted) {
+      db.deleteFile(deletedPath);
+    }
+    await initParser();
+    const allChunksWithMeta = [];
+    let filesProcessed = 0;
+    for (const { path: relPath } of filesToProcess) {
+      const discovered_file = discovered.find((f) => f.path === relPath);
+      if (!discovered_file) continue;
+      const existingFile = db.getFile(relPath);
+      if (existingFile) {
+        db.deleteChunksByFile(existingFile.id);
+      }
+      let nodes;
       try {
         nodes = await parseFile(discovered_file.absolutePath, discovered_file.language);
       } catch {
@@ -1475,7 +1926,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)
       );
@@ -1491,13 +1942,13 @@ async function runInit(projectPath, options = {}) {
       vectorsCreated = vectors.length;
     }
     const durationMs = performance.now() - start;
-    const dbSize = fs5.existsSync(dbPath) ? fs5.statSync(dbPath).size : 0;
+    const dbSize = fs6.existsSync(dbPath) ? fs6.statSync(dbPath).size : 0;
     log("");
     log(`\u2713 Indexed in ${formatDuration(durationMs)}`);
     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,
@@ -1513,8 +1964,8 @@ async function runInit(projectPath, options = {}) {
     db.close();
   }
 }
-async function createEmbedder() {
-  return createLocalEmbedder();
+async function createEmbedder(projectPath) {
+  return createProjectEmbedder(projectPath);
 }
 function registerInitCommand(program2) {
   program2.command("init [path]").description("Index current directory or specified path").action(async (inputPath) => {
@@ -1535,8 +1986,8 @@ function registerInitCommand(program2) {
 }
 
 // src/cli/commands/query.ts
-import fs6 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import path6 from "path";
 
 // src/search/vector.ts
 function distanceToScore(distance) {
@@ -1577,7 +2028,15 @@ async function vectorSearch(db, embedder, query, limit, filters) {
 
 // src/search/fts.ts
 function sanitizeFtsQuery(query) {
-  return query.replace(/[?()":^~{}!+\-\\]/g, " ").replace(/(?<!\w)\*/g, " ").replace(/\s+/g, " ").trim();
+  const tokenized = query.replace(/[^A-Za-z0-9_*]+/g, " ").trim();
+  if (tokenized.length === 0) return "";
+  const sanitizedTerms = tokenized.split(/\s+/).map((term) => {
+    const hasTrailingWildcard = /\*+$/.test(term);
+    const base = term.replace(/\*/g, "");
+    if (base.length === 0) return "";
+    return hasTrailingWildcard ? `${base}*` : base;
+  }).filter((term) => term.length > 0);
+  return sanitizedTerms.join(" ");
 }
 function bm25ToScore(rank) {
   return 1 / (1 + Math.abs(rank));
@@ -1722,27 +2181,56 @@ function pathKeywordSearch(db, query, limit) {
   }
   if (scoredPaths.length === 0) return [];
   scoredPaths.sort((a, b) => b.score - a.score);
-  const results = [];
+  const matchedFiles = [];
   for (const { filePath, score } of scoredPaths) {
-    if (results.length >= limit) break;
     const file = db.getFile(filePath);
     if (!file) continue;
     const chunks = db.getChunksByFile(file.id);
-    for (const chunk of chunks) {
+    if (chunks.length === 0) continue;
+    matchedFiles.push({
+      filePath: file.path,
+      language: file.language,
+      score,
+      chunks
+    });
+  }
+  if (matchedFiles.length === 0) return [];
+  const results = [];
+  const pushChunk = (filePath, language, score, chunk) => {
+    results.push({
+      chunkId: chunk.id,
+      filePath,
+      lineStart: chunk.lineStart,
+      lineEnd: chunk.lineEnd,
+      name: chunk.name,
+      type: chunk.type,
+      exported: chunk.exports,
+      text: chunk.text,
+      score,
+      language
+    });
+  };
+  for (const matched of matchedFiles) {
+    if (results.length >= limit) break;
+    pushChunk(
+      matched.filePath,
+      matched.language,
+      matched.score,
+      matched.chunks[0]
+    );
+  }
+  let offset = 1;
+  while (results.length < limit) {
+    let addedInRound = false;
+    for (const matched of matchedFiles) {
       if (results.length >= limit) break;
-      results.push({
-        chunkId: chunk.id,
-        filePath: file.path,
-        lineStart: chunk.lineStart,
-        lineEnd: chunk.lineEnd,
-        name: chunk.name,
-        type: chunk.type,
-        exported: chunk.exports,
-        text: chunk.text,
-        score,
-        language: file.language
-      });
+      const chunk = matched.chunks[offset];
+      if (!chunk) continue;
+      pushChunk(matched.filePath, matched.language, matched.score, chunk);
+      addedInRound = true;
     }
+    if (!addedInRound) break;
+    offset++;
   }
   return results;
 }
@@ -1941,8 +2429,91 @@ function renormalize(results) {
   }));
 }
 
+// src/steering/classify.ts
+var SYMBOL_CAMEL_RE = /^[a-z][a-zA-Z0-9]*$/;
+var SYMBOL_PASCAL_RE = /^[A-Z][a-zA-Z0-9]*$/;
+var SYMBOL_SNAKE_RE = /^[a-z]+(?:_[a-z]+)+$/;
+var SYMBOL_UPPER_RE = /^[A-Z]+(?:_[A-Z]+)*$/;
+var PATH_EXTENSION_RE = /\.(?:ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|swift|rb|php|cs|cpp|c|h|hpp|json|yaml|yml|toml|md|sql|sh|bash)$/i;
+var QUESTION_WORDS = /* @__PURE__ */ new Set([
+  "how",
+  "what",
+  "where",
+  "why",
+  "when",
+  "which",
+  "show",
+  "explain",
+  "find",
+  "list"
+]);
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "do",
+  "does",
+  "did",
+  "to",
+  "for",
+  "of",
+  "in",
+  "on",
+  "with",
+  "by",
+  "and",
+  "or"
+]);
+function defaultMultipliers() {
+  return {
+    vector: 1,
+    fts: 1,
+    ast: 1,
+    path: 1,
+    dependency: 1
+  };
+}
+function isSymbolQuery(query) {
+  return SYMBOL_CAMEL_RE.test(query) || SYMBOL_PASCAL_RE.test(query) || SYMBOL_SNAKE_RE.test(query) || SYMBOL_UPPER_RE.test(query);
+}
+function isPathQuery(query) {
+  return query.includes("/") || PATH_EXTENSION_RE.test(query);
+}
+function isNaturalLanguageQuery(query) {
+  const lower = query.toLowerCase();
+  const words = lower.split(/\s+/).filter((w) => w.length > 0);
+  const hasQuestionWord = words.some((w) => QUESTION_WORDS.has(w));
+  const hasStopWord = words.some((w) => STOP_WORDS.has(w));
+  return hasQuestionWord || words.length >= 4 && hasStopWord;
+}
+function classifyQuery(query) {
+  const trimmed = query.trim();
+  const multipliers = defaultMultipliers();
+  if (isPathQuery(trimmed)) {
+    multipliers.path = 2;
+    multipliers.ast = 0.5;
+    return { kind: "path", multipliers };
+  }
+  if (isSymbolQuery(trimmed)) {
+    multipliers.ast = 1.5;
+    multipliers.vector = 0.5;
+    return { kind: "symbol", multipliers };
+  }
+  if (isNaturalLanguageQuery(trimmed)) {
+    multipliers.vector = 1.5;
+    multipliers.path = 1.2;
+    multipliers.ast = 0.7;
+    return { kind: "natural_language", multipliers };
+  }
+  return { kind: "keyword", multipliers };
+}
+
 // src/cli/commands/query.ts
-var CTX_DIR2 = ".ctx";
+var CTX_DIR3 = ".ctx";
 var DB_FILENAME2 = "index.db";
 var SNIPPET_MAX_LENGTH = 200;
 var STRATEGY_WEIGHTS = {
@@ -1952,6 +2523,26 @@ var STRATEGY_WEIGHTS = {
   path: 0.7,
   dependency: 0.6
 };
+function getEffectiveStrategyWeights(query) {
+  const { multipliers } = classifyQuery(query);
+  return {
+    vector: STRATEGY_WEIGHTS.vector * multipliers.vector,
+    fts: STRATEGY_WEIGHTS.fts * multipliers.fts,
+    ast: STRATEGY_WEIGHTS.ast * multipliers.ast,
+    path: STRATEGY_WEIGHTS.path * multipliers.path,
+    dependency: STRATEGY_WEIGHTS.dependency * multipliers.dependency
+  };
+}
+function normalizeLimit(limit) {
+  if (!Number.isFinite(limit)) return 0;
+  return Math.max(0, Math.trunc(limit));
+}
+function resolveQueryStrategies(query, strategies, source) {
+  if (source !== "default") return strategies;
+  if (classifyQuery(query).kind !== "natural_language") return strategies;
+  if (strategies.includes("vector")) return strategies;
+  return [...strategies, "vector"];
+}
 function truncateSnippet(text) {
   const oneLine = text.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
   if (oneLine.length <= SNIPPET_MAX_LENGTH) return oneLine;
@@ -1992,20 +2583,25 @@ function isPathLike(query) {
   return query.includes("/") || query.includes("*") || query.includes(".");
 }
 async function runQuery(projectPath, query, options) {
-  const absoluteRoot = path5.resolve(projectPath);
-  const dbPath = path5.join(absoluteRoot, CTX_DIR2, DB_FILENAME2);
-  if (!fs6.existsSync(dbPath)) {
+  const limit = normalizeLimit(options.limit);
+  const absoluteRoot = path6.resolve(projectPath);
+  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);
+    const strategyResults = await runStrategies(db, absoluteRoot, query, {
+      ...options,
+      limit
+    });
     const pathBoostTerms = extractPathBoostTerms(query);
-    const fused = fusionMergeWithPathBoost(strategyResults, options.limit, pathBoostTerms);
+    const fused = fusionMergeWithPathBoost(strategyResults, limit, pathBoostTerms);
     const outputResults = fused.map(toOutputResult);
     const searchTimeMs = Math.round(performance.now() - start);
     const text = options.format === "text" ? formatTextOutput(query, outputResults) : void 0;
@@ -2023,14 +2619,16 @@ 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;
+  const effectiveWeights = getEffectiveStrategyWeights(query);
   for (const strategy of options.strategies) {
-    const weight = STRATEGY_WEIGHTS[strategy];
+    const weight = effectiveWeights[strategy];
     const searchResults = await executeStrategy(
       db,
+      projectPath,
       strategy,
       query,
       limit,
@@ -2042,10 +2640,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":
@@ -2078,24 +2676,38 @@ 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;
 }
 function registerQueryCommand(program2) {
-  program2.command("query <query>").description("Multi-strategy code search").option("-l, --limit <n>", "Max results", "10").option(
+  program2.command("query <query>").alias("find").description("Multi-strategy code search").option("-l, --limit <n>", "Max results", "10").option(
     "-s, --strategy <list>",
     "Comma-separated strategies: vector,fts,ast,path",
     "fts,ast,path"
-  ).option("--language <lang>", "Filter by language").option("-f, --format <fmt>", "Output format: json|text", "json").option("--no-vectors", "Skip vector search").action(async (query, opts) => {
+  ).option("--language <lang>", "Filter by language").option("-f, --format <fmt>", "Output format: json|text", "json").option("--no-vectors", "Skip vector search").action(async (query, opts, command) => {
     const projectPath = process.cwd();
     const verbose = program2.opts()["verbose"] === true;
     const logger = createLogger({ level: verbose ? LogLevel.DEBUG : LogLevel.INFO });
-    const strategies = (opts["strategy"] ?? "fts,ast,path").split(",").map((s) => s.trim());
+    const strategySource = command.getOptionValueSource("strategy");
+    const parsedStrategies = (opts["strategy"] ?? "fts,ast,path").split(",").map((s) => s.trim());
+    const strategies = resolveQueryStrategies(
+      query,
+      parsedStrategies,
+      strategySource === "default" ? "default" : strategySource ? "cli" : "unknown"
+    );
+    const limit = normalizeLimit(parseInt(opts["limit"] ?? "10", 10));
     try {
       const output = await runQuery(projectPath, query, {
-        limit: parseInt(opts["limit"] ?? "10", 10),
+        limit,
         strategies,
         language: opts["language"],
         format: opts["format"] ?? "json"
@@ -2117,8 +2729,8 @@ function registerQueryCommand(program2) {
 }
 
 // src/cli/commands/ask.ts
-import fs7 from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import path7 from "path";
 
 // src/steering/prompts.ts
 var PLAN_SYSTEM_PROMPT = `You are a code-search strategy planner for a TypeScript/JavaScript codebase.
@@ -2348,7 +2960,7 @@ function createAnthropicProvider(apiKey) {
     }
   };
 }
-var STOP_WORDS = /* @__PURE__ */ new Set([
+var STOP_WORDS2 = /* @__PURE__ */ new Set([
   // Interrogatives & conjunctions
   "how",
   "does",
@@ -2459,6 +3071,83 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
 ]);
 var CODE_IDENT_RE = /^(?:[a-z]+(?:[A-Z][a-z]*)+|[A-Z][a-zA-Z]+|[a-z]+(?:_[a-z]+)+|[A-Z]+(?:_[A-Z]+)+)$/;
 var DOTTED_IDENT_RE = /[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)+/g;
+var COMMON_STEMS = {
+  authentication: "auth",
+  authorization: "auth",
+  configuration: "config",
+  initialization: "init",
+  initialize: "init",
+  initializing: "init",
+  implementation: "impl",
+  implements: "impl",
+  implementing: "impl",
+  dependency: "dep",
+  dependencies: "dep",
+  middleware: "middleware",
+  validation: "valid",
+  validator: "valid",
+  serialize: "serial",
+  serialization: "serial",
+  deserialize: "deserial",
+  database: "db",
+  logging: "log",
+  logger: "log",
+  testing: "test",
+  handler: "handle",
+  handling: "handle",
+  callback: "callback",
+  subscriber: "subscribe",
+  subscription: "subscribe",
+  rendering: "render",
+  renderer: "render",
+  transformer: "transform",
+  transformation: "transform",
+  connection: "connect",
+  connecting: "connect",
+  connector: "connect",
+  migrating: "migrate",
+  migration: "migrate",
+  scheduling: "schedule",
+  scheduler: "schedule",
+  parsing: "parse",
+  parser: "parse",
+  routing: "route",
+  router: "route",
+  indexing: "index",
+  indexer: "index",
+  subscribing: "subscribe"
+};
+var STEM_SUFFIXES = [
+  "tion",
+  "sion",
+  "ment",
+  "ness",
+  "ing",
+  "er",
+  "or",
+  "able",
+  "ible",
+  "ity",
+  "ous",
+  "ive",
+  "ful",
+  "less",
+  "ly"
+];
+function getStemVariant(term) {
+  const lower = term.toLowerCase();
+  const mapped = COMMON_STEMS[lower];
+  if (mapped && mapped !== lower) return mapped;
+  if (!/^[a-z][a-z0-9_]*$/.test(lower)) return null;
+  for (const suffix of STEM_SUFFIXES) {
+    if (!lower.endsWith(suffix)) continue;
+    const stem = lower.slice(0, -suffix.length);
+    if (stem.length >= 4 && stem !== lower) {
+      return stem;
+    }
+  }
+  return null;
+}
 function extractSearchTerms(query) {
   const terms = [];
   const seen = /* @__PURE__ */ new Set();
@@ -2469,16 +3158,23 @@ function extractSearchTerms(query) {
       terms.push(term);
     }
   };
+  const addTermAndVariants = (term) => {
+    addUnique(term);
+    const variant = getStemVariant(term);
+    if (variant && variant !== term.toLowerCase()) {
+      addUnique(variant);
+    }
+  };
   const dottedMatches = query.match(DOTTED_IDENT_RE) ?? [];
-  for (const m of dottedMatches) addUnique(m);
+  for (const m of dottedMatches) addTermAndVariants(m);
   const pathTokens = query.split(/\s+/).filter((t) => t.includes("/"));
-  for (const p of pathTokens) addUnique(p.replace(/[?!,;]+$/g, ""));
+  for (const p of pathTokens) addTermAndVariants(p.replace(/[?!,;]+$/g, ""));
   const words = query.replace(/[^a-zA-Z0-9_.\s/-]/g, " ").split(/\s+/).filter((w) => w.length >= 2);
   for (const w of words) {
     const lower = w.toLowerCase();
     if (seen.has(lower)) continue;
-    if (STOP_WORDS.has(lower) && !CODE_IDENT_RE.test(w)) continue;
-    addUnique(w);
+    if (STOP_WORDS2.has(lower) && !CODE_IDENT_RE.test(w)) continue;
+    addTermAndVariants(w);
   }
   if (terms.length === 0) {
     const allWords = query.replace(/[^a-zA-Z0-9_\s]/g, " ").split(/\s+/).filter((w) => w.length >= 2);
@@ -2495,17 +3191,42 @@ var VALID_STRATEGIES = /* @__PURE__ */ new Set([
   "dependency"
 ]);
 function buildFallbackPlan(query) {
-  const keywords = extractSearchTerms(query);
-  const strategies = [
-    { strategy: "fts", query: keywords, weight: 0.8, reason: "Full-text keyword search" },
-    { strategy: "ast", query: keywords, weight: 0.9, reason: "Structural symbol search" },
-    { strategy: "path", query: keywords, weight: 0.7, reason: "Path keyword search" }
-  ];
+  const strategies = buildFallbackStrategies(query);
   return {
     interpretation: `Searching for: ${query}`,
     strategies
   };
 }
+function buildFallbackStrategies(query) {
+  const keywords = extractSearchTerms(query);
+  const { multipliers } = classifyQuery(query);
+  return [
+    {
+      strategy: "vector",
+      query,
+      weight: 1 * multipliers.vector,
+      reason: "Semantic search over natural language intent"
+    },
+    {
+      strategy: "fts",
+      query: keywords,
+      weight: 0.8 * multipliers.fts,
+      reason: "Full-text keyword search"
+    },
+    {
+      strategy: "ast",
+      query: keywords,
+      weight: 0.9 * multipliers.ast,
+      reason: "Structural symbol search"
+    },
+    {
+      strategy: "path",
+      query: keywords,
+      weight: 0.7 * multipliers.path,
+      reason: "Path keyword search"
+    }
+  ];
+}
 function parseSearchPlan(raw, query) {
   const jsonMatch = raw.match(/\{[\s\S]*\}/);
   if (!jsonMatch) return buildFallbackPlan(query);
@@ -2585,10 +3306,14 @@ async function steer(provider, query, limit, searchExecutor) {
 }
 
 // src/cli/commands/ask.ts
-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.";
+function normalizeLimit2(limit) {
+  if (!Number.isFinite(limit)) return 0;
+  return Math.max(0, Math.trunc(limit));
+}
 var PROVIDER_ENV_MAP = {
   gemini: "CTX_GEMINI_KEY",
   openai: "CTX_OPENAI_KEY",
@@ -2670,13 +3395,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,
@@ -2695,10 +3420,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":
@@ -2727,19 +3452,21 @@ 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);
-  const keywords = extractSearchTerms(query);
-  const fallbackStrategies = [
-    { strategy: "fts", query: keywords, weight: 0.8, reason: "fallback keyword search" },
-    { strategy: "ast", query: keywords, weight: 0.9, reason: "fallback structural search" },
-    { strategy: "path", query: keywords, weight: 0.7, reason: "fallback path search" }
-  ];
+async function fallbackSearch(db, projectPath, query, limit) {
+  const executor = createSearchExecutor(db, projectPath, query);
+  const fallbackStrategies = buildFallbackStrategies(query);
   const results = await executor(fallbackStrategies, limit);
   return {
     query,
@@ -2756,37 +3483,39 @@ async function fallbackSearch(db, query, limit) {
   };
 }
 async function runAsk(projectPath, query, options) {
-  const absoluteRoot = path6.resolve(projectPath);
-  const dbPath = path6.join(absoluteRoot, CTX_DIR3, DB_FILENAME3);
-  if (!fs7.existsSync(dbPath)) {
+  const limit = normalizeLimit2(options.limit);
+  const absoluteRoot = path7.resolve(projectPath);
+  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, options.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, options, executor);
+      return await runNoExplain(provider, query, limit, options, executor);
     }
-    return await runWithSteering(provider, query, options, executor);
+    return await runWithSteering(provider, query, limit, options, executor);
   } finally {
     db.close();
   }
 }
-async function runNoExplain(provider, query, options, executor) {
+async function runNoExplain(provider, query, limit, options, executor) {
   const plan = await planSearch(provider, query);
-  const results = await executor(plan.strategies, options.limit);
+  const results = await executor(plan.strategies, limit);
   const output = {
     query,
     interpretation: plan.interpretation,
@@ -2804,8 +3533,8 @@ async function runNoExplain(provider, query, options, executor) {
   }
   return output;
 }
-async function runWithSteering(provider, query, options, executor) {
-  const result = await steer(provider, query, options.limit, executor);
+async function runWithSteering(provider, query, limit, options, executor) {
+  const result = await steer(provider, query, limit, executor);
   const output = {
     query,
     interpretation: result.interpretation,
@@ -2830,9 +3559,10 @@ function registerAskCommand(program2) {
     const logger = createLogger({ level: verbose ? LogLevel.DEBUG : LogLevel.INFO });
     const providerName = opts["provider"];
     const provider = detectProvider(providerName);
+    const limit = normalizeLimit2(parseInt(String(opts["limit"] ?? "10"), 10));
     try {
       const output = await runAsk(projectPath, query, {
-        limit: parseInt(String(opts["limit"] ?? "10"), 10),
+        limit,
         format: opts["format"] ?? "text",
         provider: provider ?? void 0,
         noExplain: opts["explain"] === false
@@ -2856,13 +3586,6 @@ function registerAskCommand(program2) {
   });
 }
 
-// src/cli/commands/find.ts
-function registerFindCommand(program2) {
-  program2.command("find <query>").description("Natural language code search").option("--full", "Include source code in output").option("--json", "Machine-readable JSON output").option("--no-llm", "Skip steering LLM, raw vector search only").option("-l, --limit <n>", "Max results", "5").option("--language <lang>", "Filter by language").action((_query, _options) => {
-    console.log("ctx find \u2014 not yet implemented");
-  });
-}
-
 // src/cli/commands/update.ts
 function registerUpdateCommand(program2) {
   program2.command("update").description("Incremental re-index of changed files").action(() => {
@@ -2871,12 +3594,12 @@ function registerUpdateCommand(program2) {
 }
 
 // src/cli/commands/watch.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 
 // src/watcher/watcher.ts
 import { watch } from "chokidar";
-import path7 from "path";
+import path8 from "path";
 var DEFAULT_DEBOUNCE_MS = 500;
 var ALWAYS_IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -2888,15 +3611,15 @@ var ALWAYS_IGNORED_DIRS = /* @__PURE__ */ new Set([
 ]);
 var WATCHED_EXTENSIONS = new Set(Object.keys(LANGUAGE_MAP));
 function isWatchedFile(filePath) {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path8.extname(filePath).toLowerCase();
   return WATCHED_EXTENSIONS.has(ext);
 }
 function createWatcher(options, events) {
   const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
-  const projectPath = path7.resolve(options.projectPath);
+  const projectPath = path8.resolve(options.projectPath);
   const extraIgnored = new Set(options.ignored ?? []);
   function isIgnored(filePath) {
-    const segments = filePath.split(path7.sep);
+    const segments = filePath.split(path8.sep);
     for (const seg of segments) {
       if (ALWAYS_IGNORED_DIRS.has(seg)) return true;
       if (extraIgnored.has(seg)) return true;
@@ -2954,13 +3677,13 @@ function createWatcher(options, events) {
 }
 
 // src/cli/commands/watch.ts
-var CTX_DIR4 = ".ctx";
+var CTX_DIR5 = ".ctx";
 var DB_FILENAME4 = "index.db";
 function timestamp() {
   return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", { hour12: false });
 }
 function detectLanguage(filePath) {
-  const ext = path8.extname(filePath).toLowerCase();
+  const ext = path9.extname(filePath).toLowerCase();
   return LANGUAGE_MAP[ext] ?? null;
 }
 function formatDuration2(ms) {
@@ -2969,7 +3692,7 @@ function formatDuration2(ms) {
 }
 async function hashFile(absolutePath) {
   const { createHash: createHash3 } = await import("crypto");
-  const content = fs8.readFileSync(absolutePath);
+  const content = fs9.readFileSync(absolutePath);
   return createHash3("sha256").update(content).digest("hex");
 }
 async function reindexChanges(db, changes, projectPath, options) {
@@ -2979,25 +3702,21 @@ async function reindexChanges(db, changes, projectPath, options) {
   let chunksUpdated = 0;
   const allChunksWithMeta = [];
   for (const change of changes) {
-    const absolutePath = path8.join(projectPath, change.path);
+    const absolutePath = path9.join(projectPath, change.path);
     const language = detectLanguage(change.path);
     if (change.type === "unlink") {
       log(`[${timestamp()}] Deleted: ${change.path}`);
-      const existingFile2 = db.getFile(change.path);
-      if (existingFile2) {
+      const existingFile = db.getFile(change.path);
+      if (existingFile) {
         db.deleteFile(change.path);
       }
       filesProcessed++;
       continue;
     }
     if (!language) continue;
-    if (!fs8.existsSync(absolutePath)) continue;
+    if (!fs9.existsSync(absolutePath)) continue;
     const label = change.type === "add" ? "Added" : "Changed";
     log(`[${timestamp()}] ${label}: ${change.path}`);
-    const existingFile = db.getFile(change.path);
-    if (existingFile) {
-      db.deleteChunksByFile(existingFile.id);
-    }
     let nodes;
     try {
       nodes = await parseFile(absolutePath, language);
@@ -3007,27 +3726,32 @@ async function reindexChanges(db, changes, projectPath, options) {
     }
     const chunks = chunkFile(nodes, change.path);
     const hash = await hashFile(absolutePath);
-    const size = fs8.statSync(absolutePath).size;
-    const fileId = db.upsertFile({
-      path: change.path,
-      language,
-      hash,
-      size
+    const size = fs9.statSync(absolutePath).size;
+    const chunkRows = chunks.map((c) => ({
+      lineStart: c.lineStart,
+      lineEnd: c.lineEnd,
+      type: c.type,
+      name: c.name,
+      parent: c.parent,
+      text: c.text,
+      imports: c.imports,
+      exports: c.exports,
+      hash: c.hash
+    }));
+    let chunkIds = [];
+    db.transaction(() => {
+      const existingFile = db.getFile(change.path);
+      if (existingFile) {
+        db.deleteChunksByFile(existingFile.id);
+      }
+      const fileId = db.upsertFile({
+        path: change.path,
+        language,
+        hash,
+        size
+      });
+      chunkIds = db.insertChunks(fileId, chunkRows);
     });
-    const chunkIds = db.insertChunks(
-      fileId,
-      chunks.map((c) => ({
-        lineStart: c.lineStart,
-        lineEnd: c.lineEnd,
-        type: c.type,
-        name: c.name,
-        parent: c.parent,
-        text: c.text,
-        imports: c.imports,
-        exports: c.exports,
-        hash: c.hash
-      }))
-    );
     for (let i = 0; i < chunks.length; i++) {
       allChunksWithMeta.push({
         fileRelPath: change.path,
@@ -3038,7 +3762,7 @@ async function reindexChanges(db, changes, projectPath, options) {
     filesProcessed++;
   }
   if (!options.skipEmbedding && allChunksWithMeta.length > 0) {
-    const embedder = await loadEmbedder3();
+    const embedder = await loadEmbedder3(projectPath);
     const texts = allChunksWithMeta.map(
       (cm) => prepareChunkText(cm.fileRelPath, cm.chunk.parent, cm.chunk.text)
     );
@@ -3054,27 +3778,36 @@ async function reindexChanges(db, changes, projectPath, options) {
   return { filesProcessed, chunksUpdated, durationMs };
 }
 var embedderInstance3 = null;
-async function loadEmbedder3() {
-  if (embedderInstance3) return embedderInstance3;
-  embedderInstance3 = await createLocalEmbedder();
+var embedderKey3 = null;
+function getCacheKey3(projectPath) {
+  const config = getProjectEmbedderConfig(projectPath);
+  return `${projectPath}:${config.provider}:${config.model}:${config.dimensions}`;
+}
+async function loadEmbedder3(projectPath) {
+  const cacheKey = getCacheKey3(projectPath);
+  if (embedderInstance3 && embedderKey3 === cacheKey) return embedderInstance3;
+  embedderInstance3 = await createProjectEmbedder(projectPath);
+  embedderKey3 = cacheKey;
   return embedderInstance3;
 }
 async function runWatch(projectPath, options = {}) {
-  const absoluteRoot = path8.resolve(projectPath);
-  const dbPath = path8.join(absoluteRoot, CTX_DIR4, DB_FILENAME4);
+  const absoluteRoot = path9.resolve(projectPath);
+  const dbPath = path9.join(absoluteRoot, CTX_DIR5, DB_FILENAME4);
   const log = options.log ?? console.log;
   if (options.init) {
     await runInit(absoluteRoot, { log, skipEmbedding: options.skipEmbedding });
   }
-  if (!fs8.existsSync(dbPath)) {
+  if (!fs9.existsSync(dbPath)) {
     throw new KontextError(
-      `Project not initialized. Run "ctx init" first or use --init flag. (${CTX_DIR4}/${DB_FILENAME4} not found)`,
+      `Project not initialized. Run "ctx init" first or use --init flag. (${CTX_DIR5}/${DB_FILENAME4} not found)`,
       ErrorCode.NOT_INITIALIZED
     );
   }
   await initParser();
-  const db = createDatabase(dbPath);
+  const embedderConfig = getProjectEmbedderConfig(absoluteRoot);
+  const db = createDatabase(dbPath, embedderConfig.dimensions);
   let watcherHandle = null;
+  let reindexQueue = Promise.resolve();
   const watcher = createWatcher(
     {
       projectPath: absoluteRoot,
@@ -3083,7 +3816,7 @@ async function runWatch(projectPath, options = {}) {
     },
     {
       onChange: (changes) => {
-        void (async () => {
+        reindexQueue = reindexQueue.then(async () => {
           try {
             const result = await reindexChanges(db, changes, absoluteRoot, {
               skipEmbedding: options.skipEmbedding,
@@ -3099,7 +3832,7 @@ async function runWatch(projectPath, options = {}) {
               `[${timestamp()}] Error: ${err instanceof Error ? err.message : String(err)}`
             );
           }
-        })();
+        });
       },
       onError: (err) => {
         log(`[${timestamp()}] Watcher error: ${err.message}`);
@@ -3115,6 +3848,7 @@ async function runWatch(projectPath, options = {}) {
         await watcherHandle.stop();
         watcherHandle = null;
       }
+      await reindexQueue;
       db.close();
       log("Stopped watching. Database saved.");
     }
@@ -3149,11 +3883,11 @@ function registerWatchCommand(program2) {
 }
 
 // src/cli/commands/status.ts
-import fs9 from "fs";
-import path9 from "path";
-var CTX_DIR5 = ".ctx";
+import fs10 from "fs";
+import path10 from "path";
+var CTX_DIR6 = ".ctx";
 var DB_FILENAME5 = "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`;
@@ -3168,15 +3902,17 @@ function formatTimestamp(raw) {
 function capitalize(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
-function readConfig(ctxDir) {
-  const configPath2 = path9.join(ctxDir, CONFIG_FILENAME2);
-  if (!fs9.existsSync(configPath2)) return null;
+function readConfig2(ctxDir) {
+  const configPath2 = path10.join(ctxDir, CONFIG_FILENAME3);
+  if (!fs10.existsSync(configPath2)) return null;
   try {
-    const raw = fs9.readFileSync(configPath2, "utf-8");
+    const raw = fs10.readFileSync(configPath2, "utf-8");
     const parsed = JSON.parse(raw);
+    const embedder = parsed.embedder;
     return {
-      model: parsed.model ?? "unknown",
-      dimensions: parsed.dimensions ?? 0
+      provider: embedder?.provider ?? parsed.provider ?? "unknown",
+      model: embedder?.model ?? parsed.model ?? "unknown",
+      dimensions: embedder?.dimensions ?? parsed.dimensions ?? 0
     };
   } catch {
     return null;
@@ -3195,7 +3931,7 @@ function formatStatus(projectPath, output) {
     `Kontext Status \u2014 ${projectPath}`,
     "",
     `  Initialized:  Yes`,
-    `  Database:     ${CTX_DIR5}/${DB_FILENAME5} (${formatBytes2(output.dbSizeBytes)})`
+    `  Database:     ${CTX_DIR6}/${DB_FILENAME5} (${formatBytes2(output.dbSizeBytes)})`
   ];
   if (output.lastIndexed) {
     lines.push(`  Last indexed: ${formatTimestamp(output.lastIndexed)}`);
@@ -3218,17 +3954,17 @@ 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("");
   return lines.join("\n");
 }
 async function runStatus(projectPath) {
-  const absoluteRoot = path9.resolve(projectPath);
-  const ctxDir = path9.join(absoluteRoot, CTX_DIR5);
-  const dbPath = path9.join(ctxDir, DB_FILENAME5);
-  if (!fs9.existsSync(dbPath)) {
+  const absoluteRoot = path10.resolve(projectPath);
+  const ctxDir = path10.join(absoluteRoot, CTX_DIR6);
+  const dbPath = path10.join(ctxDir, DB_FILENAME5);
+  if (!fs10.existsSync(dbPath)) {
     const output = {
       initialized: false,
       fileCount: 0,
@@ -3249,8 +3985,8 @@ async function runStatus(projectPath) {
     const vectorCount = db.getVectorCount();
     const languages = db.getLanguageBreakdown();
     const lastIndexed = db.getLastIndexed();
-    const config = readConfig(ctxDir);
-    const dbSizeBytes = fs9.statSync(dbPath).size;
+    const config = readConfig2(ctxDir);
+    const dbSizeBytes = fs10.statSync(dbPath).size;
     const output = {
       initialized: true,
       fileCount,
@@ -3303,205 +4039,6 @@ function registerChunkCommand(program2) {
   });
 }
 
-// src/cli/commands/config.ts
-import fs10 from "fs";
-import path10 from "path";
-var CTX_DIR6 = ".ctx";
-var CONFIG_FILENAME3 = "config.json";
-var DEFAULT_CONFIG = {
-  embedder: {
-    provider: "local",
-    model: "Xenova/all-MiniLM-L6-v2",
-    dimensions: 384
-  },
-  search: {
-    defaultLimit: 10,
-    strategies: ["vector", "fts", "ast", "path"],
-    weights: { vector: 1, fts: 0.8, ast: 0.9, path: 0.7, dependency: 0.6 }
-  },
-  watch: {
-    debounceMs: 500,
-    ignored: []
-  },
-  llm: {
-    provider: null,
-    model: null
-  }
-};
-var VALID_EMBEDDER_PROVIDERS = /* @__PURE__ */ new Set(["local", "voyage", "openai"]);
-var VALID_LLM_PROVIDERS = /* @__PURE__ */ new Set(["gemini", "openai", "anthropic"]);
-var VALIDATION_RULES = {
-  "embedder.provider": {
-    validate: (v) => typeof v === "string" && VALID_EMBEDDER_PROVIDERS.has(v),
-    message: `Must be one of: ${[...VALID_EMBEDDER_PROVIDERS].join(", ")}`
-  },
-  "embedder.dimensions": {
-    validate: (v) => typeof v === "number" && v > 0 && Number.isInteger(v),
-    message: "Must be a positive integer"
-  },
-  "search.defaultLimit": {
-    validate: (v) => typeof v === "number" && v > 0 && Number.isInteger(v),
-    message: "Must be a positive integer"
-  },
-  "watch.debounceMs": {
-    validate: (v) => typeof v === "number" && v >= 0 && Number.isInteger(v),
-    message: "Must be a non-negative integer"
-  },
-  "llm.provider": {
-    validate: (v) => v === null || typeof v === "string" && VALID_LLM_PROVIDERS.has(v),
-    message: `Must be null or one of: ${[...VALID_LLM_PROVIDERS].join(", ")}`
-  }
-};
-function resolveCtxDir(projectPath) {
-  const absoluteRoot = path10.resolve(projectPath);
-  const ctxDir = path10.join(absoluteRoot, CTX_DIR6);
-  if (!fs10.existsSync(ctxDir)) {
-    throw new ConfigError(
-      `Project not initialized. Run "ctx init" first. (${CTX_DIR6}/ not found)`,
-      ErrorCode.NOT_INITIALIZED
-    );
-  }
-  return ctxDir;
-}
-function configPath(ctxDir) {
-  return path10.join(ctxDir, CONFIG_FILENAME3);
-}
-function readConfig2(ctxDir) {
-  const filePath = configPath(ctxDir);
-  if (!fs10.existsSync(filePath)) {
-    writeConfig(ctxDir, DEFAULT_CONFIG);
-    return structuredClone(DEFAULT_CONFIG);
-  }
-  const raw = fs10.readFileSync(filePath, "utf-8");
-  const parsed = JSON.parse(raw);
-  return mergeWithDefaults(parsed);
-}
-function writeConfig(ctxDir, config) {
-  fs10.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 getNestedValue(obj, key) {
-  const parts = key.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return void 0;
-    }
-    current = current[part];
-  }
-  return current;
-}
-function setNestedValue(obj, key, value) {
-  const parts = key.split(".");
-  let current = obj;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (typeof current[part] !== "object" || current[part] === null) {
-      current[part] = {};
-    }
-    current = current[part];
-  }
-  current[parts[parts.length - 1]] = value;
-}
-function parseValue(rawValue) {
-  if (rawValue === "null") return null;
-  if (rawValue === "true") return true;
-  if (rawValue === "false") return false;
-  const num = Number(rawValue);
-  if (!Number.isNaN(num) && rawValue.trim() !== "") return num;
-  if (rawValue.startsWith("[") || rawValue.startsWith("{")) {
-    try {
-      return JSON.parse(rawValue);
-    } catch {
-    }
-  }
-  return rawValue;
-}
-function runConfigShow(projectPath) {
-  const ctxDir = resolveCtxDir(projectPath);
-  const config = readConfig2(ctxDir);
-  return {
-    config,
-    text: JSON.stringify(config, null, 2)
-  };
-}
-function runConfigGet(projectPath, key) {
-  const ctxDir = resolveCtxDir(projectPath);
-  const config = readConfig2(ctxDir);
-  return getNestedValue(config, key);
-}
-function runConfigSet(projectPath, key, rawValue) {
-  const ctxDir = resolveCtxDir(projectPath);
-  const config = readConfig2(ctxDir);
-  const value = parseValue(rawValue);
-  const rule = VALIDATION_RULES[key];
-  if (rule && !rule.validate(value)) {
-    throw new ConfigError(`Invalid value for "${key}": ${rule.message}`, ErrorCode.CONFIG_INVALID);
-  }
-  setNestedValue(config, key, value);
-  writeConfig(ctxDir, config);
-}
-function runConfigReset(projectPath) {
-  const ctxDir = resolveCtxDir(projectPath);
-  writeConfig(ctxDir, structuredClone(DEFAULT_CONFIG));
-}
-function registerConfigCommand(program2) {
-  const cmd = program2.command("config").description("Show or modify configuration");
-  function configErrorHandler(err) {
-    const verbose = program2.opts()["verbose"] === true;
-    const logger = createLogger({ level: verbose ? LogLevel.DEBUG : LogLevel.INFO });
-    process.exitCode = handleCommandError(err, logger, verbose);
-  }
-  cmd.command("show").description("Show current configuration").action(() => {
-    try {
-      const output = runConfigShow(process.cwd());
-      console.log(output.text);
-    } catch (err) {
-      configErrorHandler(err);
-    }
-  });
-  cmd.command("get <key>").description("Get a configuration value (dot notation)").action((key) => {
-    try {
-      const value = runConfigGet(process.cwd(), key);
-      console.log(
-        typeof value === "object" ? JSON.stringify(value, null, 2) : String(value)
-      );
-    } catch (err) {
-      configErrorHandler(err);
-    }
-  });
-  cmd.command("set <key> <value>").description("Set a configuration value (dot notation)").action((key, value) => {
-    try {
-      runConfigSet(process.cwd(), key, value);
-      console.log(`Set ${key} = ${value}`);
-    } catch (err) {
-      configErrorHandler(err);
-    }
-  });
-  cmd.command("reset").description("Reset configuration to defaults").action(() => {
-    try {
-      runConfigReset(process.cwd());
-      console.log("Configuration reset to defaults.");
-    } catch (err) {
-      configErrorHandler(err);
-    }
-  });
-}
-
 // src/cli/commands/auth.ts
 function registerAuthCommand(program2) {
   program2.command("auth").description("Set API keys for LLM and embedding providers").action(() => {
@@ -3510,12 +4047,13 @@ function registerAuthCommand(program2) {
 }
 
 // src/cli/index.ts
+var require3 = createRequire2(import.meta.url);
+var packageJson = require3("../../package.json");
 var program = new Command();
-program.name("ctx").description("Kontext \u2014 Context engine for AI coding agents").version("0.1.0").option("--verbose", "Enable verbose/debug output");
+program.name("ctx").description("Kontext \u2014 Context engine for AI coding agents").version(packageJson.version ?? "0.0.0").option("--verbose", "Enable verbose/debug output");
 registerInitCommand(program);
 registerQueryCommand(program);
 registerAskCommand(program);
-registerFindCommand(program);
 registerUpdateCommand(program);
 registerWatchCommand(program);
 registerStatusCommand(program);