kontext-engine 0.1.0

package/dist/index.js

@@ -0,0 +1,2422 @@
+// src/indexer/discovery.ts
+import fs from "fs/promises";
+import path from "path";
+import ignore from "ignore";
+var LANGUAGE_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".rb": "ruby",
+  ".php": "php",
+  ".swift": "swift",
+  ".kt": "kotlin",
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".hpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".md": "markdown",
+  ".mdx": "markdown",
+  ".env": "env"
+};
+var BUILTIN_IGNORE = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "*.lock",
+  "package-lock.json",
+  "*.png",
+  "*.jpg",
+  "*.jpeg",
+  "*.gif",
+  "*.webp",
+  "*.ico",
+  "*.bmp",
+  "*.svg",
+  "*.woff",
+  "*.woff2",
+  "*.ttf",
+  "*.eot",
+  "*.mp3",
+  "*.mp4",
+  "*.wav",
+  "*.avi",
+  "*.mov",
+  "*.zip",
+  "*.tar",
+  "*.gz",
+  "*.rar",
+  "*.7z",
+  "*.pdf",
+  "*.exe",
+  "*.dll",
+  "*.so",
+  "*.dylib",
+  "*.o",
+  "*.a",
+  "*.wasm",
+  "*.pyc",
+  "*.class"
+];
+function getLanguage(filePath) {
+  const basename = path.basename(filePath);
+  if (basename.startsWith(".") && !basename.includes(".", 1)) {
+    const dotExt = basename;
+    return LANGUAGE_MAP[dotExt] ?? null;
+  }
+  const ext = path.extname(filePath).toLowerCase();
+  return LANGUAGE_MAP[ext] ?? null;
+}
+async function readIgnoreFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
+async function statSafe(filePath, followSymlinks) {
+  try {
+    return followSymlinks ? await fs.stat(filePath) : await fs.lstat(filePath);
+  } catch {
+    return null;
+  }
+}
+async function discoverFiles(options) {
+  const { root, extraIgnore = [], followSymlinks = true } = options;
+  const absoluteRoot = path.resolve(root);
+  const ig = ignore();
+  ig.add(BUILTIN_IGNORE);
+  const gitignoreRules = await readIgnoreFile(
+    path.join(absoluteRoot, ".gitignore")
+  );
+  ig.add(gitignoreRules);
+  const ctxignoreRules = await readIgnoreFile(
+    path.join(absoluteRoot, ".ctxignore")
+  );
+  ig.add(ctxignoreRules);
+  ig.add(extraIgnore);
+  const results = [];
+  await walkDirectory(absoluteRoot, absoluteRoot, ig, followSymlinks, results);
+  return results.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function walkDirectory(dir, root, ig, followSymlinks, results) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const absolutePath = path.join(dir, entry.name);
+    const relativePath = path.relative(root, absolutePath);
+    const normalizedRelative = relativePath.split(path.sep).join("/");
+    if (entry.isDirectory() || entry.isSymbolicLink()) {
+      const stat2 = await statSafe(absolutePath, followSymlinks);
+      if (!stat2) continue;
+      if (stat2.isDirectory()) {
+        if (ig.ignores(normalizedRelative + "/") || ig.ignores(normalizedRelative)) {
+          continue;
+        }
+        await walkDirectory(absolutePath, root, ig, followSymlinks, results);
+        continue;
+      }
+      if (!stat2.isFile()) continue;
+    }
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+    if (ig.ignores(normalizedRelative)) continue;
+    const language = getLanguage(relativePath);
+    if (language === null) continue;
+    const stat = await statSafe(absolutePath, followSymlinks);
+    if (!stat || !stat.isFile()) continue;
+    results.push({
+      path: normalizedRelative,
+      absolutePath,
+      language,
+      size: stat.size,
+      lastModified: stat.mtimeMs
+    });
+  }
+}
+
+// src/indexer/parser.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import { createRequire } from "module";
+import Parser from "web-tree-sitter";
+var GRAMMAR_FILES = {
+  typescript: "tree-sitter-typescript.wasm",
+  javascript: "tree-sitter-javascript.wasm",
+  python: "tree-sitter-python.wasm"
+};
+var require2 = createRequire(import.meta.url);
+var initialized = false;
+var languageCache = /* @__PURE__ */ new Map();
+function resolveWasmPath(filename) {
+  if (filename === "tree-sitter.wasm") {
+    return path2.join(path2.dirname(require2.resolve("web-tree-sitter")), filename);
+  }
+  return path2.join(path2.dirname(require2.resolve("tree-sitter-wasms/package.json")), "out", filename);
+}
+async function initParser() {
+  if (initialized) return;
+  await Parser.init({
+    locateFile: (scriptName) => resolveWasmPath(scriptName)
+  });
+  initialized = true;
+}
+async function getLanguage2(language) {
+  const grammarFile = GRAMMAR_FILES[language];
+  if (!grammarFile) return null;
+  const cached = languageCache.get(language);
+  if (cached) return cached;
+  const wasmPath = resolveWasmPath(grammarFile);
+  const lang = await Parser.Language.load(wasmPath);
+  languageCache.set(language, lang);
+  return lang;
+}
+function extractDocstring(node, language) {
+  if (language === "python") {
+    const body = node.childForFieldName("body");
+    if (body) {
+      const firstStmt = body.namedChildren[0];
+      if (firstStmt?.type === "expression_statement") {
+        const strNode = firstStmt.namedChildren[0];
+        if (strNode?.type === "string") {
+          const raw = strNode.text;
+          return raw.replace(/^["']{1,3}|["']{1,3}$/g, "").trim();
+        }
+      }
+    }
+    return void 0;
+  }
+  const prev = findPrecedingComment(node);
+  if (prev) return cleanJSDocComment(prev.text);
+  return void 0;
+}
+function findPrecedingComment(node) {
+  let candidate = node.previousNamedSibling;
+  if (node.parent?.type === "export_statement") {
+    candidate = node.parent.previousNamedSibling;
+  }
+  if (candidate?.type === "comment") return candidate;
+  return null;
+}
+function cleanJSDocComment(text) {
+  return text.replace(/^\/\*\*?\s*/, "").replace(/\s*\*\/$/, "").replace(/^\s*\* ?/gm, "").trim();
+}
+function extractParams(node, language) {
+  const paramsNode = node.childForFieldName("parameters") ?? node.childForFieldName("formal_parameters");
+  if (!paramsNode) return void 0;
+  if (language === "python") {
+    return paramsNode.namedChildren.filter((c) => c.type !== "comment").map((c) => c.text).filter((t) => t !== "self" && t !== "cls");
+  }
+  return paramsNode.namedChildren.filter((c) => c.type !== "comment").map((c) => c.text);
+}
+function extractReturnType(node, language) {
+  if (language === "python") {
+    const retType2 = node.childForFieldName("return_type");
+    return retType2?.text;
+  }
+  const retType = node.childForFieldName("return_type");
+  if (retType) {
+    const text = retType.text;
+    return text.startsWith(":") ? text.slice(1).trim() : text;
+  }
+  return void 0;
+}
+function isExported(node) {
+  return node.parent?.type === "export_statement";
+}
+function extractTopLevelNode(node) {
+  if (node.parent?.type === "export_statement") return node.parent;
+  return node;
+}
+function extractTypeScript(rootNode, source, language) {
+  const nodes = [];
+  function walk(node, parentClassName) {
+    for (const child of node.namedChildren) {
+      const inner = child.type === "export_statement" ? child.namedChildren.find(
+        (c) => c.type === "function_declaration" || c.type === "class_declaration" || c.type === "lexical_declaration" || c.type === "interface_declaration" || c.type === "type_alias_declaration" || c.type === "abstract_class_declaration"
+      ) ?? child : child;
+      switch (inner.type) {
+        case "import_statement": {
+          nodes.push({
+            type: "import",
+            name: null,
+            lineStart: inner.startPosition.row + 1,
+            lineEnd: inner.endPosition.row + 1,
+            language,
+            parent: null,
+            text: inner.text
+          });
+          break;
+        }
+        case "function_declaration": {
+          const topNode = extractTopLevelNode(inner);
+          const name = inner.childForFieldName("name")?.text ?? null;
+          nodes.push({
+            type: parentClassName ? "method" : "function",
+            name,
+            lineStart: topNode.startPosition.row + 1,
+            lineEnd: topNode.endPosition.row + 1,
+            language,
+            parent: parentClassName,
+            params: extractParams(inner, language),
+            returnType: extractReturnType(inner, language),
+            docstring: extractDocstring(inner, language),
+            exports: isExported(inner),
+            text: topNode.text
+          });
+          break;
+        }
+        case "class_declaration":
+        case "abstract_class_declaration": {
+          const topNode = extractTopLevelNode(inner);
+          const className = inner.childForFieldName("name")?.text ?? null;
+          nodes.push({
+            type: "class",
+            name: className,
+            lineStart: topNode.startPosition.row + 1,
+            lineEnd: topNode.endPosition.row + 1,
+            language,
+            parent: null,
+            docstring: extractDocstring(inner, language),
+            exports: isExported(inner),
+            text: topNode.text
+          });
+          const classBody = inner.childForFieldName("body");
+          if (classBody) {
+            for (const member of classBody.namedChildren) {
+              if (member.type === "method_definition") {
+                const methodName = member.childForFieldName("name")?.text ?? null;
+                nodes.push({
+                  type: "method",
+                  name: methodName,
+                  lineStart: member.startPosition.row + 1,
+                  lineEnd: member.endPosition.row + 1,
+                  language,
+                  parent: className,
+                  params: extractParams(member, language),
+                  returnType: extractReturnType(member, language),
+                  docstring: extractDocstring(member, language),
+                  exports: isExported(inner),
+                  text: member.text
+                });
+              }
+            }
+          }
+          break;
+        }
+        case "interface_declaration": {
+          const topNode = extractTopLevelNode(inner);
+          const name = inner.childForFieldName("name")?.text ?? null;
+          nodes.push({
+            type: "type",
+            name,
+            lineStart: topNode.startPosition.row + 1,
+            lineEnd: topNode.endPosition.row + 1,
+            language,
+            parent: null,
+            docstring: extractDocstring(inner, language),
+            exports: isExported(inner),
+            text: topNode.text
+          });
+          break;
+        }
+        case "type_alias_declaration": {
+          const topNode = extractTopLevelNode(inner);
+          const name = inner.childForFieldName("name")?.text ?? null;
+          nodes.push({
+            type: "type",
+            name,
+            lineStart: topNode.startPosition.row + 1,
+            lineEnd: topNode.endPosition.row + 1,
+            language,
+            parent: null,
+            docstring: extractDocstring(inner, language),
+            exports: isExported(inner),
+            text: topNode.text
+          });
+          break;
+        }
+        case "lexical_declaration": {
+          const topNode = extractTopLevelNode(inner);
+          const declarator = inner.namedChildren.find(
+            (c) => c.type === "variable_declarator"
+          );
+          const name = declarator?.childForFieldName("name")?.text ?? null;
+          nodes.push({
+            type: "constant",
+            name,
+            lineStart: topNode.startPosition.row + 1,
+            lineEnd: topNode.endPosition.row + 1,
+            language,
+            parent: parentClassName,
+            docstring: extractDocstring(inner, language),
+            exports: isExported(inner),
+            text: topNode.text
+          });
+          break;
+        }
+        default:
+          if (child.type !== "export_statement") {
+          }
+          break;
+      }
+    }
+  }
+  walk(rootNode, null);
+  return nodes;
+}
+function extractPython(rootNode, _source, language) {
+  const nodes = [];
+  function walk(node, parentClassName) {
+    for (const child of node.namedChildren) {
+      switch (child.type) {
+        case "import_statement":
+        case "import_from_statement": {
+          nodes.push({
+            type: "import",
+            name: null,
+            lineStart: child.startPosition.row + 1,
+            lineEnd: child.endPosition.row + 1,
+            language,
+            parent: null,
+            text: child.text
+          });
+          break;
+        }
+        case "function_definition": {
+          const name = child.childForFieldName("name")?.text ?? null;
+          nodes.push({
+            type: parentClassName ? "method" : "function",
+            name,
+            lineStart: child.startPosition.row + 1,
+            lineEnd: child.endPosition.row + 1,
+            language,
+            parent: parentClassName,
+            params: extractParams(child, language),
+            returnType: extractReturnType(child, language),
+            docstring: extractDocstring(child, language),
+            text: child.text
+          });
+          break;
+        }
+        case "decorated_definition": {
+          const innerDef = child.namedChildren.find(
+            (c) => c.type === "function_definition" || c.type === "class_definition"
+          );
+          if (innerDef) {
+            const name = innerDef.childForFieldName("name")?.text ?? null;
+            if (innerDef.type === "function_definition") {
+              nodes.push({
+                type: parentClassName ? "method" : "function",
+                name,
+                lineStart: child.startPosition.row + 1,
+                lineEnd: child.endPosition.row + 1,
+                language,
+                parent: parentClassName,
+                params: extractParams(innerDef, language),
+                returnType: extractReturnType(innerDef, language),
+                docstring: extractDocstring(innerDef, language),
+                text: child.text
+              });
+            } else if (innerDef.type === "class_definition") {
+              nodes.push({
+                type: "class",
+                name,
+                lineStart: child.startPosition.row + 1,
+                lineEnd: child.endPosition.row + 1,
+                language,
+                parent: null,
+                docstring: extractDocstring(innerDef, language),
+                text: child.text
+              });
+              const body = innerDef.childForFieldName("body");
+              if (body) walk(body, name);
+            }
+          }
+          break;
+        }
+        case "class_definition": {
+          const name = child.childForFieldName("name")?.text ?? null;
+          nodes.push({
+            type: "class",
+            name,
+            lineStart: child.startPosition.row + 1,
+            lineEnd: child.endPosition.row + 1,
+            language,
+            parent: null,
+            docstring: extractDocstring(child, language),
+            text: child.text
+          });
+          const body = child.childForFieldName("body");
+          if (body) walk(body, name);
+          break;
+        }
+        case "expression_statement": {
+          const assignment = child.namedChildren.find(
+            (c) => c.type === "assignment"
+          );
+          if (assignment && parentClassName === null) {
+            const left = assignment.childForFieldName("left");
+            if (left?.type === "identifier") {
+              nodes.push({
+                type: "constant",
+                name: left.text,
+                lineStart: child.startPosition.row + 1,
+                lineEnd: child.endPosition.row + 1,
+                language,
+                parent: null,
+                text: child.text
+              });
+            }
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  walk(rootNode, null);
+  return nodes;
+}
+async function parseFile(filePath, language) {
+  await initParser();
+  const lang = await getLanguage2(language);
+  if (!lang) return [];
+  let source;
+  try {
+    source = await fs2.readFile(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const parser = new Parser();
+  parser.setLanguage(lang);
+  const tree = parser.parse(source);
+  if (!tree) return [];
+  try {
+    if (language === "python") {
+      return extractPython(tree.rootNode, source, language);
+    }
+    return extractTypeScript(tree.rootNode, source, language);
+  } finally {
+    tree.delete();
+    parser.delete();
+  }
+}
+
+// src/indexer/chunker.ts
+import { createHash } from "crypto";
+var DEFAULT_MAX_TOKENS = 500;
+var MERGE_THRESHOLD = 50;
+var TOKEN_MULTIPLIER = 1.3;
+function estimateTokens(text) {
+  const wordCount = text.split(/\s+/).filter((w) => w.length > 0).length;
+  return Math.ceil(wordCount * TOKEN_MULTIPLIER);
+}
+function makeChunkId(filePath, lineStart, lineEnd) {
+  const input = `${filePath}:${lineStart}:${lineEnd}`;
+  return createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+function makeContentHash(text) {
+  return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+function splitLargeNode(node, maxTokens) {
+  const lines = node.text.split("\n");
+  const chunks = [];
+  let currentLines = [];
+  let currentStartOffset = 0;
+  for (let i = 0; i < lines.length; i++) {
+    currentLines.push(lines[i]);
+    const currentText = currentLines.join("\n");
+    const tokens = estimateTokens(currentText);
+    if (tokens >= maxTokens && currentLines.length > 1) {
+      currentLines.pop();
+      chunks.push({
+        lineStart: node.lineStart + currentStartOffset,
+        lineEnd: node.lineStart + currentStartOffset + currentLines.length - 1,
+        text: currentLines.join("\n")
+      });
+      currentStartOffset = i;
+      currentLines = [lines[i]];
+    }
+  }
+  if (currentLines.length > 0) {
+    chunks.push({
+      lineStart: node.lineStart + currentStartOffset,
+      lineEnd: node.lineStart + currentStartOffset + currentLines.length - 1,
+      text: currentLines.join("\n")
+    });
+  }
+  return chunks;
+}
+function groupImports(imports) {
+  if (imports.length === 0) return null;
+  const sorted = [...imports].sort((a, b) => a.lineStart - b.lineStart);
+  return {
+    type: "import",
+    name: null,
+    lineStart: sorted[0].lineStart,
+    lineEnd: sorted[sorted.length - 1].lineEnd,
+    language: sorted[0].language,
+    parent: null,
+    text: sorted.map((n) => n.text).join("\n")
+  };
+}
+var UNMERGEABLE_TYPES = /* @__PURE__ */ new Set([
+  "function",
+  "method",
+  "class",
+  "type",
+  "import"
+]);
+function canMerge(a, b) {
+  if (UNMERGEABLE_TYPES.has(a.type) || UNMERGEABLE_TYPES.has(b.type)) return false;
+  if (a.type !== b.type) return false;
+  return true;
+}
+function mergeSmallChunks(chunks, maxTokens) {
+  if (chunks.length <= 1) return chunks;
+  const merged = [];
+  let accumulator = null;
+  for (const chunk of chunks) {
+    const chunkTokens = estimateTokens(chunk.text);
+    if (accumulator === null) {
+      if (chunkTokens < MERGE_THRESHOLD && !UNMERGEABLE_TYPES.has(chunk.type)) {
+        accumulator = { ...chunk };
+      } else {
+        merged.push(chunk);
+      }
+      continue;
+    }
+    const accTokens = estimateTokens(accumulator.text);
+    const combinedTokens = accTokens + chunkTokens;
+    if (chunkTokens < MERGE_THRESHOLD && combinedTokens <= maxTokens && canMerge(accumulator, chunk)) {
+      const combinedText = accumulator.text + "\n" + chunk.text;
+      accumulator = {
+        ...accumulator,
+        lineEnd: chunk.lineEnd,
+        text: combinedText,
+        name: accumulator.name ?? chunk.name,
+        id: makeChunkId(accumulator.filePath, accumulator.lineStart, chunk.lineEnd),
+        hash: makeContentHash(combinedText)
+      };
+    } else {
+      merged.push(accumulator);
+      accumulator = chunkTokens < MERGE_THRESHOLD && !UNMERGEABLE_TYPES.has(chunk.type) ? { ...chunk } : null;
+      if (accumulator === null) {
+        merged.push(chunk);
+      }
+    }
+  }
+  if (accumulator) {
+    merged.push(accumulator);
+  }
+  return merged;
+}
+function collectImportTexts(nodes) {
+  return nodes.filter((n) => n.type === "import").map((n) => n.text);
+}
+function chunkFile(nodes, filePath, options) {
+  if (nodes.length === 0) return [];
+  const maxTokens = options?.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const language = nodes[0].language;
+  const importTexts = collectImportTexts(nodes);
+  const sorted = [...nodes].sort((a, b) => a.lineStart - b.lineStart);
+  const importNodes = sorted.filter((n) => n.type === "import");
+  const nonImportNodes = sorted.filter((n) => n.type !== "import");
+  const classesWithMethods = /* @__PURE__ */ new Set();
+  for (const node of nonImportNodes) {
+    if (node.type === "method" && node.parent) {
+      classesWithMethods.add(node.parent);
+    }
+  }
+  const rawChunks = [];
+  const groupedImport = groupImports(importNodes);
+  if (groupedImport) {
+    rawChunks.push({
+      id: makeChunkId(filePath, groupedImport.lineStart, groupedImport.lineEnd),
+      filePath,
+      lineStart: groupedImport.lineStart,
+      lineEnd: groupedImport.lineEnd,
+      language,
+      type: "import",
+      name: null,
+      parent: null,
+      text: groupedImport.text,
+      imports: [],
+      exports: false,
+      hash: makeContentHash(groupedImport.text)
+    });
+  }
+  for (const node of nonImportNodes) {
+    if (node.type === "class" && node.name && classesWithMethods.has(node.name)) {
+      continue;
+    }
+    const tokenCount = estimateTokens(node.text);
+    const nodeExports = node.exports ?? false;
+    if (tokenCount <= maxTokens) {
+      rawChunks.push({
+        id: makeChunkId(filePath, node.lineStart, node.lineEnd),
+        filePath,
+        lineStart: node.lineStart,
+        lineEnd: node.lineEnd,
+        language,
+        type: node.type === "export" ? "constant" : node.type,
+        name: node.name,
+        parent: node.parent,
+        text: node.text,
+        imports: node.type !== "import" ? importTexts : [],
+        exports: nodeExports,
+        hash: makeContentHash(node.text)
+      });
+    } else {
+      const subChunks = splitLargeNode(node, maxTokens);
+      for (const sub of subChunks) {
+        rawChunks.push({
+          id: makeChunkId(filePath, sub.lineStart, sub.lineEnd),
+          filePath,
+          lineStart: sub.lineStart,
+          lineEnd: sub.lineEnd,
+          language,
+          type: node.type === "export" ? "constant" : node.type,
+          name: node.name,
+          parent: node.parent,
+          text: sub.text,
+          imports: importTexts,
+          exports: nodeExports,
+          hash: makeContentHash(sub.text)
+        });
+      }
+    }
+  }
+  rawChunks.sort((a, b) => a.lineStart - b.lineStart);
+  return mergeSmallChunks(rawChunks, maxTokens);
+}
+
+// src/indexer/embedder.ts
+function normalizeVector(vec) {
+  let sumSq = 0;
+  for (const v of vec) sumSq += v * v;
+  const norm = Math.sqrt(sumSq);
+  if (norm === 0) return vec;
+  return vec.map((v) => v / norm);
+}
+function prepareChunkText(filePath, parent, text) {
+  const parts = [filePath];
+  if (parent) parts.push(parent);
+  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;
+var pipelineInstance = null;
+async function getLocalPipeline() {
+  if (pipelineInstance) return pipelineInstance;
+  const { pipeline, env } = await import("@huggingface/transformers");
+  env.cacheDir = getCacheDir();
+  pipelineInstance = await pipeline("feature-extraction", LOCAL_MODEL_ID, {
+    dtype: "fp32"
+  });
+  return pipelineInstance;
+}
+function getCacheDir() {
+  const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "/tmp";
+  return `${home}/.cache/kontext/models`;
+}
+async function createLocalEmbedder() {
+  const pipe = await getLocalPipeline();
+  return {
+    name: "all-MiniLM-L6-v2",
+    dimensions: LOCAL_DIMENSIONS,
+    async embed(texts, onProgress) {
+      const results = [];
+      for (let i = 0; i < texts.length; i += LOCAL_BATCH_SIZE) {
+        const batch = texts.slice(i, i + LOCAL_BATCH_SIZE);
+        const output = await pipe(batch, {
+          pooling: "mean",
+          normalize: true
+        });
+        for (let j = 0; j < batch.length; j++) {
+          const offset = j * LOCAL_DIMENSIONS;
+          const vec = new Float32Array(
+            output.data.buffer,
+            output.data.byteOffset + offset * 4,
+            LOCAL_DIMENSIONS
+          );
+          results.push(normalizeVector(vec));
+        }
+        onProgress?.(Math.min(i + batch.length, texts.length), texts.length);
+      }
+      return results;
+    },
+    async embedSingle(text) {
+      const output = await pipe(text, {
+        pooling: "mean",
+        normalize: true
+      });
+      const vec = new Float32Array(
+        output.data.buffer,
+        output.data.byteOffset,
+        LOCAL_DIMENSIONS
+      );
+      return normalizeVector(vec);
+    }
+  };
+}
+var VOYAGE_API_URL = "https://api.voyageai.com/v1/embeddings";
+var VOYAGE_MODEL = "voyage-code-3";
+var VOYAGE_DIMENSIONS = 1024;
+var VOYAGE_BATCH_SIZE = 128;
+function createVoyageEmbedder(apiKey) {
+  return {
+    name: VOYAGE_MODEL,
+    dimensions: VOYAGE_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);
+        results.push(...vectors);
+        onProgress?.(Math.min(i + batch.length, texts.length), texts.length);
+      }
+      return results;
+    },
+    async embedSingle(text) {
+      const vectors = await callVoyageAPI(apiKey, [text]);
+      return vectors[0];
+    }
+  };
+}
+async function callVoyageAPI(apiKey, texts) {
+  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: "document"
+    })
+  });
+  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_DIMENSIONS = 1024;
+var OPENAI_BATCH_SIZE = 128;
+function createOpenAIEmbedder(apiKey) {
+  return {
+    name: OPENAI_MODEL,
+    dimensions: OPENAI_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);
+        results.push(...vectors);
+        onProgress?.(Math.min(i + batch.length, texts.length), texts.length);
+      }
+      return results;
+    },
+    async embedSingle(text) {
+      const vectors = await callOpenAIAPI(apiKey, [text]);
+      return vectors[0];
+    }
+  };
+}
+async function callOpenAIAPI(apiKey, texts) {
+  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: OPENAI_DIMENSIONS
+    })
+  });
+  const json = await response.json();
+  return json.data.map((d) => normalizeVector(new Float32Array(d.embedding)));
+}
+
+// src/indexer/incremental.ts
+import { createHash as createHash2 } from "crypto";
+import fs3 from "fs/promises";
+async function hashFileContent(absolutePath) {
+  const content = await fs3.readFile(absolutePath);
+  return createHash2("sha256").update(content).digest("hex");
+}
+async function computeChanges(discovered, db) {
+  const start = performance.now();
+  const added = [];
+  const modified = [];
+  const unchanged = [];
+  const hashes = /* @__PURE__ */ new Map();
+  const discoveredPaths = new Set(discovered.map((f) => f.path));
+  await Promise.all(
+    discovered.map(async (file) => {
+      const contentHash = await hashFileContent(file.absolutePath);
+      const existing = db.getFile(file.path);
+      if (!existing) {
+        added.push(file.path);
+        hashes.set(file.path, contentHash);
+      } else if (existing.hash !== contentHash) {
+        modified.push(file.path);
+        hashes.set(file.path, contentHash);
+      } else {
+        unchanged.push(file.path);
+      }
+    })
+  );
+  const dbPaths = db.getAllFilePaths();
+  const deleted = dbPaths.filter((p) => !discoveredPaths.has(p));
+  added.sort();
+  modified.sort();
+  deleted.sort();
+  unchanged.sort();
+  return {
+    added,
+    modified,
+    deleted,
+    unchanged,
+    hashes,
+    duration: performance.now() - start
+  };
+}
+
+// src/storage/db.ts
+import path3 from "path";
+import fs4 from "fs";
+import BetterSqlite3 from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+
+// src/storage/schema.ts
+var SCHEMA_VERSION = 1;
+var SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS meta (
+    key TEXT PRIMARY KEY,
+    value TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS files (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    path TEXT UNIQUE NOT NULL,
+    language TEXT NOT NULL,
+    hash TEXT NOT NULL,
+    last_indexed INTEGER NOT NULL,
+    size INTEGER NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS chunks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    line_start INTEGER NOT NULL,
+    line_end INTEGER NOT NULL,
+    type TEXT NOT NULL,
+    name TEXT,
+    parent TEXT,
+    text TEXT NOT NULL,
+    imports JSON,
+    exports INTEGER DEFAULT 0,
+    hash TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS dependencies (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    source_chunk_id INTEGER NOT NULL REFERENCES chunks(id) ON DELETE CASCADE,
+    target_chunk_id INTEGER NOT NULL REFERENCES chunks(id) ON DELETE CASCADE,
+    type TEXT NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_chunks_file ON chunks(file_id);
+  CREATE INDEX IF NOT EXISTS idx_chunks_name ON chunks(name);
+  CREATE INDEX IF NOT EXISTS idx_deps_source ON dependencies(source_chunk_id);
+  CREATE INDEX IF NOT EXISTS idx_deps_target ON dependencies(target_chunk_id);
+`;
+var FTS_SQL = `
+  CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+    name, text, parent,
+    content=chunks,
+    content_rowid=id
+  );
+`;
+var FTS_TRIGGERS_SQL = `
+  CREATE TRIGGER IF NOT EXISTS chunks_fts_ai AFTER INSERT ON chunks BEGIN
+    INSERT INTO chunks_fts(rowid, name, text, parent)
+    VALUES (new.id, new.name, new.text, new.parent);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS chunks_fts_ad AFTER DELETE ON chunks BEGIN
+    INSERT INTO chunks_fts(chunks_fts, rowid, name, text, parent)
+    VALUES ('delete', old.id, old.name, old.text, old.parent);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS chunks_fts_au AFTER UPDATE ON chunks BEGIN
+    INSERT INTO chunks_fts(chunks_fts, rowid, name, text, parent)
+    VALUES ('delete', old.id, old.name, old.text, old.parent);
+    INSERT INTO chunks_fts(rowid, name, text, parent)
+    VALUES (new.id, new.name, new.text, new.parent);
+  END;
+`;
+var VECTOR_TABLE_SQL = (dimensions) => `CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vectors USING vec0(
+    embedding float[${dimensions}]
+  );`;
+
+// src/storage/vectors.ts
+function vecToBuffer(vec) {
+  return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+function insertVector(db, chunkId, vector) {
+  db.prepare(
+    `INSERT INTO chunk_vectors(rowid, embedding) VALUES (${chunkId}, ?)`
+  ).run(vecToBuffer(vector));
+}
+function deleteVectorsByChunkIds(db, chunkIds) {
+  if (chunkIds.length === 0) return;
+  const placeholders = chunkIds.map(() => "?").join(",");
+  db.prepare(
+    `DELETE FROM chunk_vectors WHERE rowid IN (${placeholders})`
+  ).run(...chunkIds);
+}
+function getVectorCount(db) {
+  const row = db.prepare("SELECT COUNT(*) as count FROM chunk_vectors").get();
+  return row.count;
+}
+function searchVectors(db, query, limit) {
+  const rows = db.prepare(
+    `SELECT rowid, distance
+       FROM chunk_vectors
+       WHERE embedding MATCH ?
+         AND k = ${limit}
+       ORDER BY distance`
+  ).all(vecToBuffer(query));
+  return rows.map((r) => ({
+    chunkId: r.rowid,
+    distance: r.distance
+  }));
+}
+
+// src/storage/db.ts
+var DEFAULT_DIMENSIONS = 384;
+function createDatabase(dbPath, dimensions = DEFAULT_DIMENSIONS) {
+  const dir = path3.dirname(dbPath);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+  const db = new BetterSqlite3(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  sqliteVec.load(db);
+  initializeSchema(db, dimensions);
+  const stmtUpsertFile = db.prepare(`
+    INSERT INTO files (path, language, hash, last_indexed, size)
+    VALUES (@path, @language, @hash, @lastIndexed, @size)
+    ON CONFLICT(path) DO UPDATE SET
+      language = excluded.language,
+      hash = excluded.hash,
+      last_indexed = excluded.last_indexed,
+      size = excluded.size
+  `);
+  const stmtGetFile = db.prepare(
+    "SELECT id, path, language, hash, last_indexed as lastIndexed, size FROM files WHERE path = ?"
+  );
+  const stmtDeleteFile = db.prepare("DELETE FROM files WHERE path = ?");
+  const stmtInsertChunk = db.prepare(`
+    INSERT INTO chunks (file_id, line_start, line_end, type, name, parent, text, imports, exports, hash)
+    VALUES (@fileId, @lineStart, @lineEnd, @type, @name, @parent, @text, @imports, @exports, @hash)
+  `);
+  const stmtGetChunksByFile = db.prepare(
+    "SELECT id, file_id as fileId, line_start as lineStart, line_end as lineEnd, type, name, parent, text, imports, exports, hash FROM chunks WHERE file_id = ? ORDER BY line_start"
+  );
+  const stmtGetChunkIdsByFile = db.prepare(
+    "SELECT id FROM chunks WHERE file_id = ?"
+  );
+  const stmtDeleteChunksByFile = db.prepare(
+    "DELETE FROM chunks WHERE file_id = ?"
+  );
+  const stmtSearchFTS = db.prepare(
+    "SELECT rowid as chunkId, name, rank FROM chunks_fts WHERE chunks_fts MATCH ? ORDER BY rank LIMIT ?"
+  );
+  const stmtGetAllFiles = db.prepare(
+    "SELECT id, path, language, hash, last_indexed as lastIndexed, size FROM files"
+  );
+  const stmtInsertDep = db.prepare(
+    "INSERT INTO dependencies (source_chunk_id, target_chunk_id, type) VALUES (?, ?, ?)"
+  );
+  const stmtGetDeps = db.prepare(
+    "SELECT target_chunk_id as targetChunkId, type FROM dependencies WHERE source_chunk_id = ?"
+  );
+  const stmtGetReverseDeps = db.prepare(
+    "SELECT source_chunk_id as sourceChunkId, type FROM dependencies WHERE target_chunk_id = ?"
+  );
+  const stmtFileCount = db.prepare("SELECT COUNT(*) as count FROM files");
+  const stmtChunkCount = db.prepare("SELECT COUNT(*) as count FROM chunks");
+  const stmtLanguageBreakdown = db.prepare(
+    "SELECT language, COUNT(*) as count FROM files GROUP BY language ORDER BY count DESC"
+  );
+  const stmtLastIndexed = db.prepare(
+    "SELECT MAX(last_indexed) as lastIndexed FROM files"
+  );
+  return {
+    upsertFile(file) {
+      const result = stmtUpsertFile.run({
+        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);
+      }
+      const existing = stmtGetFile.get(file.path);
+      return existing?.id ?? 0;
+    },
+    getFile(filePath) {
+      const row = stmtGetFile.get(filePath);
+      return row ?? null;
+    },
+    getFilesByHash(hashes) {
+      const result = /* @__PURE__ */ new Map();
+      const allFiles = stmtGetAllFiles.all();
+      for (const file of allFiles) {
+        const expectedHash = hashes.get(file.path);
+        if (expectedHash !== void 0 && expectedHash === file.hash) {
+          result.set(file.path, file);
+        }
+      }
+      return result;
+    },
+    getAllFilePaths() {
+      const rows = stmtGetAllFiles.all();
+      return rows.map((r) => r.path);
+    },
+    getFileCount() {
+      return stmtFileCount.get().count;
+    },
+    getChunkCount() {
+      return stmtChunkCount.get().count;
+    },
+    getVectorCount() {
+      return getVectorCount(db);
+    },
+    getLanguageBreakdown() {
+      const rows = stmtLanguageBreakdown.all();
+      const map = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        map.set(row.language, row.count);
+      }
+      return map;
+    },
+    getLastIndexed() {
+      const row = stmtLastIndexed.get();
+      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);
+        }
+      }
+      stmtDeleteFile.run(filePath);
+    },
+    insertChunks(fileId, chunks) {
+      const ids = [];
+      for (const chunk of chunks) {
+        const result = stmtInsertChunk.run({
+          fileId,
+          lineStart: chunk.lineStart,
+          lineEnd: chunk.lineEnd,
+          type: chunk.type,
+          name: chunk.name,
+          parent: chunk.parent,
+          text: chunk.text,
+          imports: JSON.stringify(chunk.imports),
+          exports: chunk.exports ? 1 : 0,
+          hash: chunk.hash
+        });
+        ids.push(Number(result.lastInsertRowid));
+      }
+      return ids;
+    },
+    getChunksByFile(fileId) {
+      const rows = stmtGetChunksByFile.all(fileId);
+      return rows.map((r) => ({
+        ...r,
+        imports: JSON.parse(r.imports),
+        exports: r.exports === 1
+      }));
+    },
+    getChunksByIds(ids) {
+      if (ids.length === 0) return [];
+      const placeholders = ids.map(() => "?").join(",");
+      const rows = db.prepare(
+        `SELECT c.id, c.file_id as fileId, f.path as filePath, f.language,
+                  c.line_start as lineStart, c.line_end as lineEnd,
+                  c.type, c.name, c.parent, c.text
+           FROM chunks c
+           JOIN files f ON f.id = c.file_id
+           WHERE c.id IN (${placeholders})`
+      ).all(...ids);
+      return rows;
+    },
+    searchChunks(filters, limit) {
+      const conditions = [];
+      const params = [];
+      if (filters.name) {
+        switch (filters.nameMode ?? "contains") {
+          case "exact":
+            conditions.push("c.name = ?");
+            params.push(filters.name);
+            break;
+          case "prefix":
+            conditions.push("c.name LIKE ? || '%'");
+            params.push(filters.name);
+            break;
+          case "contains":
+            conditions.push("c.name LIKE '%' || ? || '%'");
+            params.push(filters.name);
+            break;
+        }
+      }
+      if (filters.type) {
+        conditions.push("c.type = ?");
+        params.push(filters.type);
+      }
+      if (filters.parent) {
+        conditions.push("c.parent = ?");
+        params.push(filters.parent);
+      }
+      if (filters.language) {
+        conditions.push("f.language = ?");
+        params.push(filters.language);
+      }
+      const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const sql = `
+        SELECT c.id, c.file_id as fileId, f.path as filePath, f.language,
+               c.line_start as lineStart, c.line_end as lineEnd,
+               c.type, c.name, c.parent, c.text
+        FROM chunks c
+        JOIN files f ON f.id = c.file_id
+        ${where}
+        ORDER BY c.name, c.line_start
+        LIMIT ?
+      `;
+      params.push(limit);
+      return db.prepare(sql).all(...params);
+    },
+    deleteChunksByFile(fileId) {
+      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);
+    },
+    getDependencies(chunkId) {
+      return stmtGetDeps.all(chunkId);
+    },
+    getReverseDependencies(chunkId) {
+      return stmtGetReverseDeps.all(chunkId);
+    },
+    insertVector(chunkId, vector) {
+      insertVector(db, chunkId, vector);
+    },
+    searchVectors(query, limit) {
+      return searchVectors(db, query, limit);
+    },
+    searchFTS(query, limit) {
+      const rows = stmtSearchFTS.all(query, limit);
+      return rows;
+    },
+    transaction(fn) {
+      return db.transaction(fn)();
+    },
+    vacuum() {
+      db.exec("VACUUM");
+    },
+    close() {
+      db.close();
+    },
+    getSchemaVersion() {
+      const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+      return row ? parseInt(row.value, 10) : 0;
+    },
+    pragma(key) {
+      const result = db.pragma(key);
+      if (Array.isArray(result) && result.length > 0) {
+        return Object.values(result[0])[0];
+      }
+      return String(result);
+    }
+  };
+}
+function initializeSchema(db, dimensions) {
+  const currentVersion = getMetaVersion(db);
+  if (currentVersion >= SCHEMA_VERSION) return;
+  db.exec(SCHEMA_SQL);
+  db.exec(VECTOR_TABLE_SQL(dimensions));
+  db.exec(FTS_SQL);
+  db.exec(FTS_TRIGGERS_SQL);
+  db.prepare(
+    "INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', ?)"
+  ).run(String(SCHEMA_VERSION));
+}
+function getMetaVersion(db) {
+  try {
+    const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+    return row ? parseInt(row.value, 10) : 0;
+  } catch {
+    return 0;
+  }
+}
+
+// src/search/vector.ts
+function distanceToScore(distance) {
+  return 1 / (1 + distance);
+}
+async function vectorSearch(db, embedder, query, limit, filters) {
+  const queryVec = await embedder.embedSingle(query);
+  const fetchLimit = filters?.language ? limit * 3 : limit;
+  const vectorResults = db.searchVectors(queryVec, fetchLimit);
+  if (vectorResults.length === 0) return [];
+  const chunkIds = vectorResults.map((r) => r.chunkId);
+  const chunks = db.getChunksByIds(chunkIds);
+  const chunkMap = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    chunkMap.set(chunk.id, chunk);
+  }
+  const results = [];
+  for (const vr of vectorResults) {
+    const chunk = chunkMap.get(vr.chunkId);
+    if (!chunk) continue;
+    if (filters?.language && chunk.language !== filters.language) continue;
+    results.push({
+      chunkId: vr.chunkId,
+      filePath: chunk.filePath,
+      lineStart: chunk.lineStart,
+      lineEnd: chunk.lineEnd,
+      name: chunk.name,
+      type: chunk.type,
+      text: chunk.text,
+      score: distanceToScore(vr.distance),
+      language: chunk.language
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
+}
+
+// src/search/fts.ts
+function bm25ToScore(rank) {
+  return 1 / (1 + Math.abs(rank));
+}
+function ftsSearch(db, query, limit, filters) {
+  const fetchLimit = filters?.language ? limit * 3 : limit;
+  const ftsResults = db.searchFTS(query, fetchLimit);
+  if (ftsResults.length === 0) return [];
+  const chunkIds = ftsResults.map((r) => r.chunkId);
+  const chunks = db.getChunksByIds(chunkIds);
+  const chunkMap = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    chunkMap.set(chunk.id, chunk);
+  }
+  const results = [];
+  for (const fts of ftsResults) {
+    const chunk = chunkMap.get(fts.chunkId);
+    if (!chunk) continue;
+    if (filters?.language && chunk.language !== filters.language) continue;
+    results.push({
+      chunkId: fts.chunkId,
+      filePath: chunk.filePath,
+      lineStart: chunk.lineStart,
+      lineEnd: chunk.lineEnd,
+      name: chunk.name,
+      type: chunk.type,
+      text: chunk.text,
+      score: bm25ToScore(fts.rank),
+      language: chunk.language
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
+}
+
+// src/search/ast.ts
+var SCORE_EXACT = 1;
+var SCORE_PREFIX = 0.8;
+var SCORE_FUZZY = 0.5;
+function astSearch(db, filters, limit) {
+  const matchMode = filters.matchMode ?? "fuzzy";
+  const nameMode = matchMode === "exact" ? "exact" : matchMode === "prefix" ? "prefix" : "contains";
+  const score = matchMode === "exact" ? SCORE_EXACT : matchMode === "prefix" ? SCORE_PREFIX : SCORE_FUZZY;
+  const chunks = db.searchChunks(
+    {
+      name: filters.name,
+      nameMode,
+      type: filters.type,
+      parent: filters.parent,
+      language: filters.language
+    },
+    limit
+  );
+  return chunks.map((chunk) => ({
+    chunkId: chunk.id,
+    filePath: chunk.filePath,
+    lineStart: chunk.lineStart,
+    lineEnd: chunk.lineEnd,
+    name: chunk.name,
+    type: chunk.type,
+    text: chunk.text,
+    score,
+    language: chunk.language
+  }));
+}
+
+// src/search/path.ts
+function globToRegExp(pattern) {
+  let re = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "*" && pattern[i + 1] === "*") {
+      re += ".*";
+      i += 2;
+      if (pattern[i] === "/") i++;
+    } else if (ch === "*") {
+      re += "[^/]*";
+      i++;
+    } else if (ch === "?") {
+      re += "[^/]";
+      i++;
+    } else if (".+^${}()|[]\\".includes(ch)) {
+      re += "\\" + ch;
+      i++;
+    } else {
+      re += ch;
+      i++;
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+function pathSearch(db, pattern, limit) {
+  const allPaths = db.getAllFilePaths();
+  const regex = globToRegExp(pattern);
+  const matchingPaths = allPaths.filter((p) => regex.test(p));
+  if (matchingPaths.length === 0) return [];
+  const results = [];
+  for (const filePath of matchingPaths) {
+    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 (results.length >= limit) break;
+      results.push({
+        chunkId: chunk.id,
+        filePath: file.path,
+        lineStart: chunk.lineStart,
+        lineEnd: chunk.lineEnd,
+        name: chunk.name,
+        type: chunk.type,
+        text: chunk.text,
+        score: 1,
+        language: file.language
+      });
+    }
+  }
+  return results;
+}
+var DEPTH_SCORE_BASE = 1;
+var DEPTH_SCORE_DECAY = 0.2;
+function dependencyTrace(db, chunkId, direction, depth) {
+  const visited = /* @__PURE__ */ new Set();
+  visited.add(chunkId);
+  const results = [];
+  let frontier = [chunkId];
+  for (let d = 0; d < depth; d++) {
+    const nextFrontier = [];
+    for (const currentId of frontier) {
+      const neighbors = getNeighbors(db, currentId, direction);
+      for (const neighborId of neighbors) {
+        if (visited.has(neighborId)) continue;
+        visited.add(neighborId);
+        nextFrontier.push(neighborId);
+      }
+    }
+    if (nextFrontier.length === 0) break;
+    const chunks = db.getChunksByIds(nextFrontier);
+    const score = DEPTH_SCORE_BASE - d * DEPTH_SCORE_DECAY;
+    for (const chunk of chunks) {
+      results.push({
+        chunkId: chunk.id,
+        filePath: chunk.filePath,
+        lineStart: chunk.lineStart,
+        lineEnd: chunk.lineEnd,
+        name: chunk.name,
+        type: chunk.type,
+        text: chunk.text,
+        score,
+        language: chunk.language
+      });
+    }
+    frontier = nextFrontier;
+  }
+  return results;
+}
+function getNeighbors(db, chunkId, direction) {
+  if (direction === "imports") {
+    return db.getDependencies(chunkId).map((d) => d.targetChunkId);
+  }
+  return db.getReverseDependencies(chunkId).map((d) => d.sourceChunkId);
+}
+
+// src/search/fusion.ts
+var K = 60;
+function fusionMerge(strategyResults, limit) {
+  const scoreMap = /* @__PURE__ */ new Map();
+  const resultMap = /* @__PURE__ */ new Map();
+  for (const { weight, results: results2 } of strategyResults) {
+    for (let rank = 0; rank < results2.length; rank++) {
+      const result = results2[rank];
+      const rrfScore = weight * (1 / (K + rank + 1));
+      const existing = scoreMap.get(result.chunkId) ?? 0;
+      scoreMap.set(result.chunkId, existing + rrfScore);
+      if (!resultMap.has(result.chunkId)) {
+        resultMap.set(result.chunkId, result);
+      }
+    }
+  }
+  if (scoreMap.size === 0) return [];
+  const entries = [...scoreMap.entries()].sort((a, b) => b[1] - a[1]);
+  const maxScore = entries[0][1];
+  const results = [];
+  for (const [chunkId, rawScore] of entries.slice(0, limit)) {
+    const base = resultMap.get(chunkId);
+    if (!base) continue;
+    results.push({
+      ...base,
+      score: maxScore > 0 ? rawScore / maxScore : 0
+    });
+  }
+  return results;
+}
+
+// src/steering/llm.ts
+var PLAN_SYSTEM_PROMPT = `You are a code search strategy planner. Given a user query about code, output a JSON object with:
+- "interpretation": a one-line summary of what the user is looking for
+- "strategies": an array of search strategy objects, each with:
+  - "strategy": one of "vector", "fts", "ast", "path", "dependency"
+  - "query": the optimized query string for that strategy
+  - "weight": a number 0-1 indicating importance
+  - "reason": brief explanation of why this strategy is used
+
+Choose strategies based on query type:
+- Conceptual/natural language \u2192 vector (semantic search)
+- Keywords/identifiers \u2192 fts (full-text search)
+- Symbol names (functions, classes) \u2192 ast (structural search)
+- File paths or patterns \u2192 path (path glob search)
+- Import/dependency chains \u2192 dependency
+
+Output ONLY valid JSON, no markdown.`;
+var SYNTHESIZE_SYSTEM_PROMPT = `You are a code search assistant. Given search results, write a brief, helpful explanation of what was found. Be concise (2-4 sentences). Reference specific files and function names. Do not use markdown.`;
+var VALID_STRATEGIES = /* @__PURE__ */ new Set([
+  "vector",
+  "fts",
+  "ast",
+  "path",
+  "dependency"
+]);
+function buildFallbackPlan(query) {
+  const strategies = [
+    { strategy: "fts", query, weight: 0.8, reason: "Full-text keyword search" },
+    { strategy: "ast", query, weight: 0.9, reason: "Structural symbol search" }
+  ];
+  return {
+    interpretation: `Searching for: ${query}`,
+    strategies
+  };
+}
+function parseSearchPlan(raw, query) {
+  const jsonMatch = raw.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) return buildFallbackPlan(query);
+  const parsed = JSON.parse(jsonMatch[0]);
+  if (!parsed.interpretation || !Array.isArray(parsed.strategies) || parsed.strategies.length === 0) {
+    return buildFallbackPlan(query);
+  }
+  const validStrategies = parsed.strategies.filter(
+    (s) => VALID_STRATEGIES.has(s.strategy)
+  );
+  if (validStrategies.length === 0) return buildFallbackPlan(query);
+  return {
+    interpretation: parsed.interpretation,
+    strategies: validStrategies
+  };
+}
+async function planSearch(provider, query) {
+  try {
+    const response = await provider.chat([
+      { role: "system", content: PLAN_SYSTEM_PROMPT },
+      { role: "user", content: query }
+    ]);
+    return parseSearchPlan(response, query);
+  } catch {
+    return buildFallbackPlan(query);
+  }
+}
+function formatResultsForLLM(results) {
+  return results.slice(0, 10).map(
+    (r, i) => `${i + 1}. ${r.filePath}:${r.lineStart}-${r.lineEnd} ${r.name ?? "(unnamed)"} [${r.type}] (score: ${r.score.toFixed(2)})
+   ${r.text.slice(0, 150)}`
+  ).join("\n\n");
+}
+async function synthesizeExplanation(provider, query, results) {
+  if (results.length === 0) {
+    return `No results found for "${query}".`;
+  }
+  const formattedResults = formatResultsForLLM(results);
+  const response = await provider.chat([
+    { role: "system", content: SYNTHESIZE_SYSTEM_PROMPT },
+    {
+      role: "user",
+      content: `Query: "${query}"
+
+Search results:
+${formattedResults}`
+    }
+  ]);
+  return response;
+}
+function estimateTokens2(text) {
+  return Math.ceil(text.length / 4);
+}
+async function steer(provider, query, limit, searchExecutor) {
+  let totalTokens = 0;
+  const plan = await planSearch(provider, query);
+  totalTokens += estimateTokens2(PLAN_SYSTEM_PROMPT + query);
+  totalTokens += estimateTokens2(JSON.stringify(plan));
+  const results = await searchExecutor(plan.strategies, limit);
+  let explanation;
+  try {
+    explanation = await synthesizeExplanation(provider, query, results);
+    totalTokens += estimateTokens2(SYNTHESIZE_SYSTEM_PROMPT + query);
+    totalTokens += estimateTokens2(explanation);
+  } catch {
+    explanation = results.length > 0 ? `Found ${results.length} result(s) for "${query}".` : `No results found for "${query}".`;
+  }
+  const costEstimate = totalTokens / 1e6 * 0.15;
+  return {
+    interpretation: plan.interpretation,
+    strategies: plan.strategies,
+    results,
+    explanation,
+    tokensUsed: totalTokens,
+    costEstimate
+  };
+}
+
+// src/cli/commands/init.ts
+import fs5 from "fs";
+import path4 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,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  SILENT: 4
+};
+function resolveLevel(options) {
+  if (options?.level !== void 0) return options.level;
+  if (process.env["CTX_DEBUG"] === "1") return LogLevel.DEBUG;
+  return LogLevel.INFO;
+}
+function formatArgs(args) {
+  return args.map((a) => typeof a === "string" ? a : String(a)).join(" ");
+}
+function write(level, msg, args) {
+  const extra = args.length > 0 ? ` ${formatArgs(args)}` : "";
+  process.stderr.write(`[${level}] ${msg}${extra}
+`);
+}
+function createLogger(options) {
+  const minLevel = resolveLevel(options);
+  return {
+    debug(msg, ...args) {
+      if (minLevel <= LogLevel.DEBUG) write("debug", msg, args);
+    },
+    info(msg, ...args) {
+      if (minLevel <= LogLevel.INFO) write("info", msg, args);
+    },
+    warn(msg, ...args) {
+      if (minLevel <= LogLevel.WARN) write("warn", msg, args);
+    },
+    error(msg, ...args) {
+      if (minLevel <= LogLevel.ERROR) write("error", msg, args);
+    }
+  };
+}
+
+// src/cli/commands/init.ts
+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}
+`);
+  }
+}
+function ensureConfig(ctxDir) {
+  const configPath = path4.join(ctxDir, CONFIG_FILENAME);
+  if (fs5.existsSync(configPath)) return;
+  const config = {
+    version: 1,
+    dimensions: 384,
+    model: "all-MiniLM-L6-v2"
+  };
+  fs5.writeFileSync(configPath, JSON.stringify(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 = 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`);
+    }
+    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 {
+        log(`  \u26A0 Skipping ${relPath} (parse error)`);
+        continue;
+      }
+      const chunks = chunkFile(nodes, relPath);
+      const fileId = db.upsertFile({
+        path: relPath,
+        language: discovered_file.language,
+        hash: changes.hashes.get(relPath) ?? "",
+        size: discovered_file.size
+      });
+      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: relPath,
+          chunk: { ...chunks[i], id: String(chunkIds[i]) }
+        });
+      }
+      filesProcessed++;
+      if (filesProcessed % 50 === 0 || filesProcessed === filesToProcess.length) {
+        log(`  Parsing... ${filesProcessed}/${filesToProcess.length}`);
+      }
+    }
+    log(`  ${allChunksWithMeta.length} chunks created`);
+    let vectorsCreated = 0;
+    if (!options.skipEmbedding && allChunksWithMeta.length > 0) {
+      const embedder = await createEmbedder();
+      const texts = allChunksWithMeta.map(
+        (cm) => prepareChunkText(cm.fileRelPath, cm.chunk.parent, cm.chunk.text)
+      );
+      const vectors = await embedder.embed(texts, (done, total) => {
+        log(`  Embedding... ${done}/${total}`);
+      });
+      db.transaction(() => {
+        for (let i = 0; i < allChunksWithMeta.length; i++) {
+          const chunkDbId = parseInt(allChunksWithMeta[i].chunk.id, 10);
+          db.insertVector(chunkDbId, vectors[i]);
+        }
+      });
+      vectorsCreated = vectors.length;
+    }
+    const durationMs = performance.now() - start;
+    const dbSize = fs5.existsSync(dbPath) ? fs5.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)})`);
+    return {
+      filesDiscovered: discovered.length,
+      filesAdded: changes.added.length,
+      filesModified: changes.modified.length,
+      filesDeleted: changes.deleted.length,
+      filesUnchanged: changes.unchanged.length,
+      chunksCreated: allChunksWithMeta.length,
+      vectorsCreated,
+      durationMs,
+      languageCounts
+    };
+  } finally {
+    db.close();
+  }
+}
+async function createEmbedder() {
+  return createLocalEmbedder();
+}
+
+// src/cli/commands/query.ts
+import fs6 from "fs";
+import path5 from "path";
+var CTX_DIR2 = ".ctx";
+var DB_FILENAME2 = "index.db";
+var SNIPPET_MAX_LENGTH = 200;
+var STRATEGY_WEIGHTS = {
+  vector: 1,
+  fts: 0.8,
+  ast: 0.9,
+  path: 0.7,
+  dependency: 0.6
+};
+function truncateSnippet(text) {
+  const oneLine = text.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+  if (oneLine.length <= SNIPPET_MAX_LENGTH) return oneLine;
+  return oneLine.slice(0, SNIPPET_MAX_LENGTH) + "...";
+}
+function toOutputResult(r) {
+  return {
+    file: r.filePath,
+    lines: [r.lineStart, r.lineEnd],
+    name: r.name,
+    type: r.type,
+    score: Math.round(r.score * 100) / 100,
+    snippet: truncateSnippet(r.text),
+    language: r.language
+  };
+}
+function formatTextOutput(query, results) {
+  if (results.length === 0) {
+    return `No results for "${query}"`;
+  }
+  const lines = [`Results for "${query}":
+`];
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    const nameLabel = r.name ? `${r.name} [${r.type}]` : `[${r.type}]`;
+    lines.push(`${i + 1}. ${r.file}:${r.lines[0]}-${r.lines[1]} (score: ${r.score})`);
+    lines.push(`   ${nameLabel}`);
+    lines.push(`   ${r.snippet}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function extractSymbolNames(query) {
+  const matches = query.match(/[A-Z]?[a-z]+(?:[A-Z][a-z]+)*|[a-z]+(?:_[a-z]+)+|[A-Z][a-zA-Z]+/g);
+  return matches ?? [];
+}
+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)) {
+    throw new KontextError(
+      `Project not initialized. Run "ctx init" first. (${CTX_DIR2}/${DB_FILENAME2} not found)`,
+      ErrorCode.NOT_INITIALIZED
+    );
+  }
+  const start = performance.now();
+  const db = createDatabase(dbPath);
+  try {
+    const strategyResults = await runStrategies(db, query, options);
+    const fused = fusionMerge(strategyResults, options.limit);
+    const outputResults = fused.map(toOutputResult);
+    const searchTimeMs = Math.round(performance.now() - start);
+    const text = options.format === "text" ? formatTextOutput(query, outputResults) : void 0;
+    return {
+      query,
+      results: outputResults,
+      stats: {
+        strategies: strategyResults.map((s) => s.strategy),
+        totalResults: outputResults.length,
+        searchTimeMs
+      },
+      text
+    };
+  } finally {
+    db.close();
+  }
+}
+async function runStrategies(db, query, options) {
+  const results = [];
+  const filters = options.language ? { language: options.language } : void 0;
+  const limit = options.limit * 3;
+  for (const strategy of options.strategies) {
+    const weight = STRATEGY_WEIGHTS[strategy];
+    const searchResults = await executeStrategy(
+      db,
+      strategy,
+      query,
+      limit,
+      filters
+    );
+    if (searchResults.length > 0) {
+      results.push({ strategy, weight, results: searchResults });
+    }
+  }
+  return results;
+}
+async function executeStrategy(db, strategy, query, limit, filters) {
+  switch (strategy) {
+    case "vector": {
+      const embedder = await loadEmbedder();
+      return vectorSearch(db, embedder, query, limit, filters);
+    }
+    case "fts":
+      return ftsSearch(db, query, limit, filters);
+    case "ast": {
+      const symbols = extractSymbolNames(query);
+      if (symbols.length === 0) return [];
+      const allResults = [];
+      for (const name of symbols) {
+        const results = astSearch(
+          db,
+          { name, language: filters?.language },
+          limit
+        );
+        allResults.push(...results);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      return allResults.filter((r) => {
+        if (seen.has(r.chunkId)) return false;
+        seen.add(r.chunkId);
+        return true;
+      });
+    }
+    case "path": {
+      if (!isPathLike(query)) return [];
+      return pathSearch(db, query, limit);
+    }
+    case "dependency":
+      return [];
+  }
+}
+var embedderInstance = null;
+async function loadEmbedder() {
+  if (embedderInstance) return embedderInstance;
+  embedderInstance = await createLocalEmbedder();
+  return embedderInstance;
+}
+
+// src/cli/commands/ask.ts
+import fs7 from "fs";
+import path6 from "path";
+var CTX_DIR3 = ".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 truncateSnippet2(text) {
+  const oneLine = text.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+  if (oneLine.length <= SNIPPET_MAX_LENGTH2) return oneLine;
+  return oneLine.slice(0, SNIPPET_MAX_LENGTH2) + "...";
+}
+function toOutputResult2(r) {
+  return {
+    file: r.filePath,
+    lines: [r.lineStart, r.lineEnd],
+    name: r.name,
+    type: r.type,
+    score: Math.round(r.score * 100) / 100,
+    snippet: truncateSnippet2(r.text),
+    language: r.language
+  };
+}
+function formatTextOutput2(output) {
+  const lines = [];
+  if (output.fallback) {
+    lines.push(FALLBACK_NOTICE);
+    lines.push("");
+  }
+  if (output.interpretation) {
+    lines.push(`Understanding: ${output.interpretation}`);
+    lines.push("");
+  }
+  if (output.results.length === 0) {
+    lines.push(`No results found for "${output.query}"`);
+  } else {
+    lines.push(`Found ${output.results.length} relevant location(s):`);
+    lines.push("");
+    for (let i = 0; i < output.results.length; i++) {
+      const r = output.results[i];
+      const nameLabel = r.name ? `${r.name} [${r.type}]` : `[${r.type}]`;
+      lines.push(`${i + 1}. ${r.file}:${r.lines[0]}-${r.lines[1]} (score: ${r.score})`);
+      lines.push(`   ${nameLabel}`);
+      lines.push(`   ${r.snippet}`);
+      lines.push("");
+    }
+  }
+  if (output.explanation) {
+    lines.push("Explanation:");
+    lines.push(output.explanation);
+    lines.push("");
+  }
+  lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  const cost = output.stats.costEstimate.toFixed(4);
+  lines.push(
+    `Tokens: ${output.stats.tokensUsed.toLocaleString()} | Cost: ~$${cost} | Strategies: ${output.stats.strategies.join(", ")}`
+  );
+  return lines.join("\n");
+}
+function createSearchExecutor(db) {
+  return async (strategies, limit) => {
+    const strategyResults = [];
+    const fetchLimit = limit * 3;
+    for (const plan of strategies) {
+      const results = await executeStrategy2(db, plan, fetchLimit);
+      if (results.length > 0) {
+        strategyResults.push({
+          strategy: plan.strategy,
+          weight: plan.weight,
+          results
+        });
+      }
+    }
+    return fusionMerge(strategyResults, limit);
+  };
+}
+async function executeStrategy2(db, plan, limit) {
+  switch (plan.strategy) {
+    case "vector": {
+      const embedder = await loadEmbedder2();
+      return vectorSearch(db, embedder, plan.query, limit);
+    }
+    case "fts":
+      return ftsSearch(db, plan.query, limit);
+    case "ast":
+      return astSearch(db, { name: plan.query }, limit);
+    case "path":
+      return pathSearch(db, plan.query, limit);
+    case "dependency":
+      return [];
+  }
+}
+var embedderInstance2 = null;
+async function loadEmbedder2() {
+  if (embedderInstance2) return embedderInstance2;
+  embedderInstance2 = await createLocalEmbedder();
+  return embedderInstance2;
+}
+async function fallbackSearch(db, query, limit) {
+  const executor = createSearchExecutor(db);
+  const fallbackStrategies = [
+    { strategy: "fts", query, weight: 0.8, reason: "fallback keyword search" },
+    { strategy: "ast", query, weight: 0.9, reason: "fallback structural search" }
+  ];
+  const results = await executor(fallbackStrategies, limit);
+  return {
+    query,
+    interpretation: "",
+    results: results.map(toOutputResult2),
+    explanation: "",
+    stats: {
+      strategies: fallbackStrategies.map((s) => s.strategy),
+      tokensUsed: 0,
+      costEstimate: 0,
+      totalResults: results.length
+    },
+    fallback: true
+  };
+}
+async function runAsk(projectPath, query, options) {
+  const absoluteRoot = path6.resolve(projectPath);
+  const dbPath = path6.join(absoluteRoot, CTX_DIR3, DB_FILENAME3);
+  if (!fs7.existsSync(dbPath)) {
+    throw new KontextError(
+      `Project not initialized. Run "ctx init" first. (${CTX_DIR3}/${DB_FILENAME3} not found)`,
+      ErrorCode.NOT_INITIALIZED
+    );
+  }
+  const db = createDatabase(dbPath);
+  try {
+    const provider = options.provider ?? null;
+    if (!provider) {
+      const output = await fallbackSearch(db, query, options.limit);
+      if (options.format === "text") {
+        output.text = formatTextOutput2(output);
+      }
+      return output;
+    }
+    const executor = createSearchExecutor(db);
+    if (options.noExplain) {
+      return await runNoExplain(provider, query, options, executor);
+    }
+    return await runWithSteering(provider, query, options, executor);
+  } finally {
+    db.close();
+  }
+}
+async function runNoExplain(provider, query, options, executor) {
+  const plan = await planSearch(provider, query);
+  const results = await executor(plan.strategies, options.limit);
+  const output = {
+    query,
+    interpretation: plan.interpretation,
+    results: results.map(toOutputResult2),
+    explanation: "",
+    stats: {
+      strategies: plan.strategies.map((s) => s.strategy),
+      tokensUsed: 0,
+      costEstimate: 0,
+      totalResults: results.length
+    }
+  };
+  if (options.format === "text") {
+    output.text = formatTextOutput2(output);
+  }
+  return output;
+}
+async function runWithSteering(provider, query, options, executor) {
+  const result = await steer(provider, query, options.limit, executor);
+  const output = {
+    query,
+    interpretation: result.interpretation,
+    results: result.results.map(toOutputResult2),
+    explanation: result.explanation,
+    stats: {
+      strategies: result.strategies.map((s) => s.strategy),
+      tokensUsed: result.tokensUsed,
+      costEstimate: result.costEstimate,
+      totalResults: result.results.length
+    }
+  };
+  if (options.format === "text") {
+    output.text = formatTextOutput2(output);
+  }
+  return output;
+}
+
+// src/cli/commands/status.ts
+import fs8 from "fs";
+import path7 from "path";
+var CTX_DIR4 = ".ctx";
+var DB_FILENAME4 = "index.db";
+var CONFIG_FILENAME2 = "config.json";
+function formatBytes2(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 formatTimestamp(raw) {
+  const num = Number(raw);
+  if (Number.isNaN(num)) return raw;
+  const date = new Date(num);
+  return date.toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function readConfig(ctxDir) {
+  const configPath = path7.join(ctxDir, CONFIG_FILENAME2);
+  if (!fs8.existsSync(configPath)) return null;
+  try {
+    const raw = fs8.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      model: parsed.model ?? "unknown",
+      dimensions: parsed.dimensions ?? 0
+    };
+  } catch {
+    return null;
+  }
+}
+function formatNotInitialized(projectPath) {
+  return [
+    `Kontext Status \u2014 ${projectPath}`,
+    "",
+    '  Not initialized. Run "ctx init" first.',
+    ""
+  ].join("\n");
+}
+function formatStatus(projectPath, output) {
+  const lines = [
+    `Kontext Status \u2014 ${projectPath}`,
+    "",
+    `  Initialized:  Yes`,
+    `  Database:     ${CTX_DIR4}/${DB_FILENAME4} (${formatBytes2(output.dbSizeBytes)})`
+  ];
+  if (output.lastIndexed) {
+    lines.push(`  Last indexed: ${formatTimestamp(output.lastIndexed)}`);
+  }
+  lines.push("");
+  lines.push(`  Files:    ${output.fileCount.toLocaleString()}`);
+  lines.push(`  Chunks:   ${output.chunkCount.toLocaleString()}`);
+  lines.push(`  Vectors:  ${output.vectorCount.toLocaleString()}`);
+  if (output.languages.size > 0) {
+    lines.push("");
+    lines.push("  Languages:");
+    const maxLangLen = Math.max(
+      ...[...output.languages.keys()].map((k) => capitalize(k).length)
+    );
+    for (const [lang, count] of output.languages) {
+      const label = capitalize(lang).padEnd(maxLangLen + 2);
+      lines.push(`    ${label}${count} file${count !== 1 ? "s" : ""}`);
+    }
+  }
+  if (output.config) {
+    lines.push("");
+    lines.push(
+      `  Embedder: local (${output.config.model}, ${output.config.dimensions} dims)`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+async function runStatus(projectPath) {
+  const absoluteRoot = path7.resolve(projectPath);
+  const ctxDir = path7.join(absoluteRoot, CTX_DIR4);
+  const dbPath = path7.join(ctxDir, DB_FILENAME4);
+  if (!fs8.existsSync(dbPath)) {
+    const output = {
+      initialized: false,
+      fileCount: 0,
+      chunkCount: 0,
+      vectorCount: 0,
+      dbSizeBytes: 0,
+      lastIndexed: null,
+      languages: /* @__PURE__ */ new Map(),
+      config: null,
+      text: formatNotInitialized(absoluteRoot)
+    };
+    return output;
+  }
+  const db = createDatabase(dbPath);
+  try {
+    const fileCount = db.getFileCount();
+    const chunkCount = db.getChunkCount();
+    const vectorCount = db.getVectorCount();
+    const languages = db.getLanguageBreakdown();
+    const lastIndexed = db.getLastIndexed();
+    const config = readConfig(ctxDir);
+    const dbSizeBytes = fs8.statSync(dbPath).size;
+    const output = {
+      initialized: true,
+      fileCount,
+      chunkCount,
+      vectorCount,
+      dbSizeBytes,
+      lastIndexed,
+      languages,
+      config,
+      text: ""
+    };
+    output.text = formatStatus(absoluteRoot, output);
+    return output;
+  } finally {
+    db.close();
+  }
+}
+export {
+  ConfigError,
+  DatabaseError,
+  ErrorCode,
+  IndexError,
+  KontextError,
+  LANGUAGE_MAP,
+  LogLevel,
+  SearchError,
+  astSearch,
+  chunkFile,
+  computeChanges,
+  createDatabase,
+  createLocalEmbedder,
+  createLogger,
+  createOpenAIEmbedder,
+  createVoyageEmbedder,
+  dependencyTrace,
+  discoverFiles,
+  estimateTokens,
+  ftsSearch,
+  fusionMerge,
+  initParser,
+  parseFile,
+  pathSearch,
+  planSearch,
+  prepareChunkText,
+  runAsk,
+  runInit,
+  runQuery,
+  runStatus,
+  steer,
+  vectorSearch
+};
+//# sourceMappingURL=index.js.map