@orquentra/codebuddy 2.6.2 → 2.7.0

package/dist/{chunk-NERKZSSE.js → chunk-5EDGAZQN.js}

@@ -1,24 +1,38 @@
 import {
+  extractPythonImports,
   extractSymbolTable,
   supportsSymbols
-} from "./chunk-PQK3GKZH.js";
+} from "./chunk-Y7D7PUBE.js";
+import {
+  isCredentialPath
+} from "./chunk-AL6VBTNA.js";
+import {
+  LOCAL_EMBEDDING_MODEL
+} from "./chunk-HPOR6YXA.js";
+import {
+  readConfigFile
+} from "./chunk-KNR2P2UY.js";
 import {
   assertNoSymlinkBetween,
-  readConfigFile,
   writeAtomic
-} from "./chunk-5KZY6OTG.js";
+} from "./chunk-CG5B3LYG.js";
 
 // src/map/indexer.ts
 import { readdir, readFile, stat } from "fs/promises";
 import { dirname, extname, join, relative, resolve } from "path";
-var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"]);
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
   "dist",
   "build",
   "coverage",
-  ".codebuddy"
+  ".codebuddy",
+  // Python virtualenvs and caches would otherwise map site-packages.
+  ".venv",
+  "venv",
+  ".tox",
+  "__pycache__"
 ]);
 async function buildArchitectureMap(repositoryRoot = process.cwd()) {
   const root = resolve(repositoryRoot);
@@ -29,18 +43,12 @@ async function buildArchitectureMap(repositoryRoot = process.cwd()) {
   for (const absolutePath of files) {
     const source = await readFile(absolutePath, "utf8");
     const from = normalize(relative(root, absolutePath));
-    const imports = extractImports(source);
-    const resolvedImports = [];
-    for (const specifier of imports) {
-      const resolved = resolveImport(root, from, specifier.value, fileSet);
-      if (!resolved) continue;
-      resolvedImports.push(resolved);
-      edges.push({ from, to: resolved, kind: specifier.kind });
-    }
+    const resolvedImports = moduleImports(root, from, source, fileSet);
+    edges.push(...resolvedImports.map(({ to, kind }) => ({ from, to, kind })));
     modules.push({
       path: from,
-      language: extname(absolutePath).includes("ts") ? "ts" : "js",
-      imports: [...new Set(resolvedImports)].sort()
+      language: moduleLanguage(from),
+      imports: [...new Set(resolvedImports.map(({ to }) => to))].sort()
     });
   }
   return {
@@ -66,18 +74,12 @@ async function updateArchitectureMap(repositoryRoot, sourcePaths, previous, chan
   for (const path of normalizedPaths) {
     if (!changed.has(path)) continue;
     const source = await readFile(join(root, path), "utf8");
-    const imports = extractImports(source);
-    const resolvedImports = [];
-    for (const specifier of imports) {
-      const resolvedImport = resolveImport(root, path, specifier.value, fileSet);
-      if (!resolvedImport) continue;
-      resolvedImports.push(resolvedImport);
-      edges.push({ from: path, to: resolvedImport, kind: specifier.kind });
-    }
+    const resolvedImports = moduleImports(root, path, source, fileSet);
+    edges.push(...resolvedImports.map(({ to, kind }) => ({ from: path, to, kind })));
     modules.push({
       path,
-      language: extname(path).includes("ts") ? "ts" : "js",
-      imports: [...new Set(resolvedImports)].sort()
+      language: moduleLanguage(path),
+      imports: [...new Set(resolvedImports.map(({ to }) => to))].sort()
     });
   }
   return {
@@ -136,6 +138,48 @@ async function walk(directory, files) {
     files.push(absolute);
   }
 }
+function moduleLanguage(path) {
+  const extension = extname(path);
+  if (extension === ".py") return "py";
+  return extension.includes("ts") ? "ts" : "js";
+}
+function moduleImports(root, from, source, fileSet) {
+  if (extname(from) === ".py") {
+    return pythonImports(from, source, fileSet).map((to) => ({ to, kind: "import" }));
+  }
+  return extractImports(source).flatMap((specifier) => {
+    const to = resolveImport(root, from, specifier.value, fileSet);
+    return to ? [{ to, kind: specifier.kind }] : [];
+  });
+}
+var PYTHON_ROOTS = ["", "src/"];
+function pythonImports(from, source, fileSet) {
+  const pick = (...candidates) => candidates.find((candidate) => fileSet.has(candidate)) ?? null;
+  const moduleFile = (base) => pick(`${base}.py`, `${base}/__init__.py`);
+  const packageDir = from.split("/").slice(0, -1);
+  const targets = [];
+  for (const statement of extractPythonImports(source)) {
+    const parts = statement.module ? statement.module.split(".") : [];
+    let bases;
+    if (statement.level > 0) {
+      const up = statement.level - 1;
+      if (up > packageDir.length) continue;
+      bases = [[...packageDir.slice(0, packageDir.length - up), ...parts].join("/")];
+    } else {
+      bases = PYTHON_ROOTS.map((prefix) => `${prefix}${parts.join("/")}`);
+    }
+    for (const base of bases) {
+      const prefix = base ? `${base}/` : "";
+      const module = parts.length > 0 ? moduleFile(base) : pick(`${prefix}__init__.py`);
+      const submodules = statement.names.flatMap((name) => moduleFile(`${prefix}${name}`) ?? []);
+      if (!module && submodules.length === 0) continue;
+      targets.push(...submodules);
+      if (module && submodules.length < Math.max(1, statement.names.length)) targets.push(module);
+      break;
+    }
+  }
+  return [...new Set(targets)].filter((target) => target !== from);
+}
 function extractImports(source) {
   const imports = [];
   const stripped = source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:])\/\/[^\n]*/g, "$1 ");
@@ -192,12 +236,12 @@ import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
 import { z } from "zod";
 
 // src/indexer/types.ts
-var INDEX_MANIFEST_VERSION = 2;
+var INDEX_MANIFEST_VERSION = 3;
 
 // src/indexer/store.ts
 var symbolSpanSchema = z.object({
   name: z.string(),
-  kind: z.enum(["function", "method", "class", "interface", "type", "enum", "const"]),
+  kind: z.enum(["function", "method", "class", "interface", "type", "enum", "const", "heading"]),
   startLine: z.number().int().nonnegative(),
   endLine: z.number().int().nonnegative(),
   signature: z.string(),
@@ -255,7 +299,7 @@ function emptyManifest() {
 
 // src/map/cache.ts
 var CACHE_VERSION = 1;
-var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"]);
 async function loadArchitectureMap(repositoryRoot = process.cwd(), suppliedManifest) {
   const root = resolve3(repositoryRoot);
   const manifest = suppliedManifest ?? await new IndexStore(root).read();
@@ -331,7 +375,7 @@ function sourceHashes(manifest) {
 // src/indexer/scan.ts
 import { spawn } from "child_process";
 import { readdir as readdir2 } from "fs/promises";
-import { extname as extname4, join as join4, relative as relative2 } from "path";
+import { extname as extname4, join as join4, relative as relative2, sep } from "path";
 
 // src/indexer/summary.ts
 import { extname as extname3 } from "path";
@@ -345,6 +389,7 @@ var LANGUAGE_BY_EXTENSION = {
   ".json": "json",
   ".md": "md",
   ".mdx": "md",
+  ".rst": "rst",
   ".yaml": "yaml",
   ".yml": "yaml",
   ".toml": "toml",
@@ -371,7 +416,7 @@ function languageFor(path) {
 function summarizeSource(path, content) {
   const language = languageFor(path);
   const lines = countLines(content);
-  const symbols = CODE_LANGUAGES.has(language) ? extractSymbols(content) : [];
+  const symbols = CODE_LANGUAGES.has(language) ? extractSymbols(content) : language === "py" ? pythonPublicNames(content) : [];
   const summary = composeSummary(language, lines, symbols, content);
   return { language, lines, symbols, summary };
 }
@@ -398,6 +443,9 @@ function extractSymbols(content) {
   }
   return names.slice(0, SYMBOL_LIMIT);
 }
+function pythonPublicNames(content) {
+  return extractSymbolTable(content, "x.py").filter((symbol) => symbol.exported && symbol.kind !== "method").map((symbol) => symbol.name).slice(0, SYMBOL_LIMIT);
+}
 function composeSummary(language, lines, symbols, content) {
   const head = `${language} \u2022 ${lines} line${lines === 1 ? "" : "s"}`;
   if (symbols.length > 0) return `${head} \u2022 exports ${symbols.join(", ")}`;
@@ -433,7 +481,10 @@ var FALLBACK_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
   "graphify-out",
   ".next",
   ".turbo",
-  "out"
+  "out",
+  ".venv",
+  "venv",
+  "__pycache__"
 ]);
 async function listIndexableFiles(repositoryRoot) {
   const tracked = await gitListFiles(repositoryRoot);
@@ -443,12 +494,13 @@ async function listIndexableFiles(repositoryRoot) {
 async function gitListFiles(repositoryRoot) {
   const result = await runGit(repositoryRoot, [
     "ls-files",
+    "-z",
     "--cached",
     "--others",
     "--exclude-standard"
   ]);
   if (result.code !== 0) return null;
-  return result.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+  return result.stdout.split("\0").filter(Boolean);
 }
 async function walkFiles(root) {
   const files = [];
@@ -472,18 +524,19 @@ function runGit(cwd, args) {
     const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk2) => {
+      stdout += String(chunk2);
     });
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
+    child.stderr.on("data", (chunk2) => {
+      stderr += String(chunk2);
     });
     child.on("error", () => resolveResult({ code: -1, stdout: "", stderr: "git unavailable" }));
     child.on("close", (code) => resolveResult({ code: code ?? 0, stdout, stderr }));
   });
 }
 function normalize2(path) {
-  return path.replace(/\\/g, "/").replace(/^\.\//, "");
+  return (sep === "\\" ? path.replace(/\\/g, "/") : path).replace(/^\.\//, "");
 }
 
 // src/indexer/engine.ts
@@ -556,7 +609,7 @@ async function runIndexPass(options) {
         continue;
       }
       const { language, lines, symbols, summary } = summarizeSource(path, content);
-      const symbolTable = supportsSymbols(path) ? extractSymbolTable(content) : [];
+      const symbolTable = supportsSymbols(path) ? extractSymbolTable(content, path) : [];
       entries[path] = {
         path,
         hash,
@@ -622,7 +675,7 @@ function sortEntries(entries) {
 import { execFile } from "child_process";
 import { mkdir as mkdir3, mkdtemp, readFile as readFile6, rm, stat as stat3, utimes } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname4, join as join6, relative as relative3, resolve as resolve5, sep } from "path";
+import { dirname as dirname4, join as join6, relative as relative3, resolve as resolve5, sep as sep2 } from "path";
 import { promisify } from "util";
 
 // src/map/graph-freshness.ts
@@ -788,7 +841,7 @@ async function ignoreGeneratedGraphDirectory(directory) {
 function resolveGraphPath(repositoryRoot, graphPath) {
   const absolute = resolve5(repositoryRoot, graphPath);
   const relativePath = relative3(repositoryRoot, absolute);
-  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`)) {
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep2}`)) {
     throw new Error(`Graph path must be inside the project root: ${graphPath}`);
   }
   return absolute;
@@ -814,9 +867,13 @@ function arrayLength(value) {
   return Array.isArray(value) ? value.length : 0;
 }
 
+// src/context/file-vectors.ts
+import { mkdir as mkdir5, readFile as readFile10 } from "fs/promises";
+import { dirname as dirname6, join as join9 } from "path";
+
 // src/context/discovery.ts
-import { readFile as readFile8, realpath, stat as stat4 } from "fs/promises";
-import { isAbsolute as isAbsolute3, join as join7, relative as relative6 } from "path";
+import { readFile as readFile9, realpath, stat as stat4 } from "fs/promises";
+import { isAbsolute as isAbsolute3, join as join8, relative as relative6 } from "path";
 
 // src/map/graphify.ts
 import { readFile as readFile7 } from "fs/promises";
@@ -956,11 +1013,12 @@ function stringValue(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 function languageFor2(path) {
+  if (/\.py$/.test(path)) return "py";
   return /\.tsx?$/.test(path) ? "ts" : "js";
 }
 
 // src/context/anchors.ts
-import { isAbsolute as isAbsolute2, relative as relative5, resolve as resolve7, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute2, relative as relative5, resolve as resolve7, sep as sep3 } from "path";
 var MAX_ANCHORS = 3;
 var MAX_ERROR_SEARCH_FILES = 2e3;
 var JS_FRAME = /\bat\s+(?:[^\s()]+\s+\()?([^\s()]+?):(\d+):\d+\)?/g;
@@ -998,7 +1056,7 @@ async function extractTaskAnchors(repositoryRoot, task, paths) {
 function toIndexedPath(root, raw, paths) {
   const absolute = isAbsolute2(raw) ? raw : resolve7(root, raw);
   const rel = relative5(root, absolute);
-  if (rel === "" || rel.startsWith(`..${sep2}`) || rel === ".." || isAbsolute2(rel)) return null;
+  if (rel === "" || rel.startsWith(`..${sep3}`) || rel === ".." || isAbsolute2(rel)) return null;
   const normalized = rel.replace(/\\/g, "/");
   return paths.has(normalized) ? normalized : null;
 }
@@ -1023,16 +1081,131 @@ async function errorAnchors(root, task, paths) {
   return matches.flatMap((found) => found.length === 1 ? found : []);
 }
 
+// src/context/content-index.ts
+import { mkdir as mkdir4, readFile as readFile8 } from "fs/promises";
+import { dirname as dirname5, join as join7 } from "path";
+var PASSAGE_LINES = 40;
+var K1 = 1.2;
+var B = 0.75;
+var MIN_TERMS = 2;
+var MIN_SHARE = 0.5;
+var MIN_IDF_COVERAGE = 0.3;
+async function rankContent(repositoryRoot, manifest, terms, wantsTests, wantsDocs = false, wantsChangelog = false) {
+  const none = { matches: [], idf: /* @__PURE__ */ new Map() };
+  if (terms.length === 0) return none;
+  const paths = Object.keys(manifest.entries).filter(
+    (path) => (!NON_SOURCE_PATH.test(path) || wantsDocs && DOC_PATH.test(path) || wantsChangelog && CHANGELOG_PATH.test(path)) && (wantsTests || !TEST_PATH.test(path))
+  );
+  const cache = await loadCache(repositoryRoot);
+  let changed = false;
+  const files = {};
+  await Promise.all(
+    paths.map(async (path) => {
+      const hash = manifest.entries[path]?.hash ?? "";
+      const cached = cache.files[path];
+      if (cached && cached.hash === hash) {
+        files[path] = cached;
+        return;
+      }
+      const source = await readBoundedSource(repositoryRoot, path);
+      if (source === null) return;
+      const counts = {};
+      const words = splitWords(`${path} ${source}`);
+      for (const word of words) counts[word] = (counts[word] ?? 0) + 1;
+      const lines = source.split("\n");
+      const passages = [];
+      for (let start = 0; start === 0 || start + PASSAGE_LINES / 2 < lines.length; start += PASSAGE_LINES / 2) {
+        passages.push([
+          ...new Set(splitWords(lines.slice(start, start + PASSAGE_LINES).join("\n")))
+        ]);
+      }
+      files[path] = { hash, length: words.length, counts, passages };
+      changed = true;
+    })
+  );
+  const retained = Object.fromEntries(
+    Object.entries(cache.files).filter(
+      ([path, file]) => !(path in files) && manifest.entries[path]?.hash === file.hash
+    )
+  );
+  const kept = Object.keys(retained).length + Object.keys(files).length;
+  if (changed || kept !== Object.keys(cache.files).length) {
+    await saveCache(repositoryRoot, { version: 2, files: { ...retained, ...files } });
+  }
+  const documents = Object.entries(files);
+  if (documents.length === 0) return none;
+  const averageLength = documents.reduce((sum, [, file]) => sum + file.length, 0) / documents.length;
+  const idf = new Map(
+    terms.map((term) => {
+      const df = documents.filter(([, file]) => (file.counts[term] ?? 0) > 0).length;
+      return [term, Math.log(1 + (documents.length - df + 0.5) / (df + 0.5))];
+    })
+  );
+  const totalIdf = [...idf.values()].reduce((sum, value) => sum + value, 0);
+  const scored = documents.map(([path, file]) => {
+    const fileName = new Set(splitWords(path.slice(path.lastIndexOf("/") + 1)));
+    let score = 0;
+    let covered = 0;
+    for (const term of terms) {
+      const tf = file.counts[term] ?? 0;
+      if (tf === 0) continue;
+      covered += idf.get(term) ?? 0;
+      const saturation = tf * (K1 + 1) / (tf + K1 * (1 - B + B * file.length / averageLength));
+      score += (idf.get(term) ?? 0) * saturation * (fileName.has(term) ? 1.5 : 1);
+    }
+    const named = terms.filter((term) => fileName.has(term));
+    const matched = Math.max(
+      named.length,
+      ...file.passages.map(
+        (words) => (/* @__PURE__ */ new Set([...named, ...terms.filter((term) => words.includes(term))])).size
+      )
+    );
+    return { path, score, terms: matched, coverage: totalIdf > 0 ? covered / totalIdf : 0 };
+  }).filter((match) => match.score > 0).sort((left, right) => right.score - left.score || left.path.localeCompare(right.path));
+  const best = scored[0]?.score ?? 0;
+  const needed = Math.min(MIN_TERMS, terms.length);
+  const matches = scored.filter(
+    (match) => match.terms >= needed && match.score >= MIN_SHARE * best && match.coverage >= MIN_IDF_COVERAGE
+  ).map(({ path, score, terms: matched }) => ({ path, score, terms: matched }));
+  return { matches, idf };
+}
+function idfCoverage(text, terms, idf) {
+  const total = terms.reduce((sum, term) => sum + (idf.get(term) ?? 0), 0);
+  if (total === 0) return 0;
+  const words = new Set(splitWords(text));
+  return terms.reduce((sum, term) => sum + (words.has(term) ? idf.get(term) ?? 0 : 0), 0) / total;
+}
+function cachePath(repositoryRoot) {
+  return join7(repositoryRoot, ".codebuddy", "cache", "content-terms.json");
+}
+async function loadCache(repositoryRoot) {
+  try {
+    const parsed = JSON.parse(await readFile8(cachePath(repositoryRoot), "utf8"));
+    if (parsed.version === 2 && parsed.files && typeof parsed.files === "object") return parsed;
+  } catch {
+  }
+  return { version: 2, files: {} };
+}
+async function saveCache(repositoryRoot, cache) {
+  try {
+    const path = cachePath(repositoryRoot);
+    await mkdir4(dirname5(path), { recursive: true });
+    await writeAtomic(path, JSON.stringify(cache));
+  } catch {
+  }
+}
+
 // src/context/discovery.ts
 var TASK_PATH_LIMIT = 10;
 var TASK_FILES = 3;
 var EXPANSION = { seeds: 2, files: 1 };
 var MAX_EVIDENCE_BYTES = 512e3;
 async function readBoundedSource(repositoryRoot, path) {
+  if (isCredentialPath(path)) return null;
   try {
-    const absolute = join7(repositoryRoot, path);
+    const absolute = join8(repositoryRoot, path);
     if ((await stat4(absolute)).size > MAX_EVIDENCE_BYTES) return null;
-    const source = await readFile8(absolute, "utf8");
+    const source = await readFile9(absolute, "utf8");
     return source.includes("\0") ? null : source;
   } catch {
     return null;
@@ -1077,10 +1250,10 @@ async function discoverTaskPaths(repositoryRoot, task, manifest, mapSource, opti
 async function withLlmSummaries(repositoryRoot, manifest) {
   const entries = Object.values(manifest.entries);
   try {
-    const { resolveLlmConfig } = await import("./config-DEVHUDIU.js");
+    const { resolveLlmConfig } = await import("./config-GEZFLXK6.js");
     const config = await resolveLlmConfig(repositoryRoot);
     if (!config.enabled || !config.features.summaries) return entries;
-    const { loadLlmSummaries } = await import("./summaries-SB5L2TSW.js");
+    const { loadLlmSummaries } = await import("./summaries-XV3JGGCC.js");
     const summaries = await loadLlmSummaries(repositoryRoot, manifest);
     if (summaries.size === 0) return entries;
     return entries.map((entry) => {
@@ -1092,7 +1265,10 @@ async function withLlmSummaries(repositoryRoot, manifest) {
   }
 }
 async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options) {
-  const entries = await withLlmSummaries(repositoryRoot, manifest);
+  const wantsChangelog = asksForChangelog(task);
+  const entries = (await withLlmSummaries(repositoryRoot, manifest)).filter(
+    (entry) => wantsChangelog || !CHANGELOG_PATH.test(entry.path)
+  );
   const wantsTests = /\b(tests?|spec)\b/i.test(task);
   const identifiers = identifierTokens(task).filter((token) => CODE_IDENTIFIER.test(token));
   if (identifiers.length > 0) {
@@ -1100,7 +1276,10 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
       path: entry.path,
       named: new Set(
         (entry.symbolTable ?? []).flatMap(
-          (symbol) => symbol.name.split(".").filter((segment) => identifiers.includes(segment))
+          (symbol) => (
+            // A doc heading naming an identifier is not its declaration.
+            symbol.kind === "heading" ? [] : symbol.name.split(".").filter((segment) => identifiers.includes(segment))
+          )
         )
       ).size
     })).filter((entry) => entry.named > 0).sort((left, right) => right.named - left.named || left.path.localeCompare(right.path)).map((entry) => entry.path);
@@ -1123,16 +1302,31 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
   }
   const commands = await commandFiles(repositoryRoot, task, entries);
   const scored = scoreTaskPaths(entries, task);
-  const keyword = scored.filter((entry) => entry.score >= EVIDENCE_FLOOR.keywordScore).map((entry) => entry.path);
+  const summaryKeyword = scored.filter((entry) => entry.score >= EVIDENCE_FLOOR.keywordScore).map((entry) => entry.path);
+  const { matches: content, idf } = await rankContent(
+    repositoryRoot,
+    manifest,
+    taskTerms(task),
+    wantsTests,
+    DOCS_TASK.test(task),
+    wantsChangelog
+  );
+  const keyword = content.length > 0 ? fuseRankings([summaryKeyword, content.map((match) => match.path)]) : summaryKeyword;
   const weakKeyword = scored.length - keyword.length;
-  const semantic = options.semantic === false ? {
+  const semantic = options.semantic === false && options.zvecDeadlineAt === void 0 ? {
     status: "disabled",
     paths: [],
     hits: [],
     reason: "semantic retrieval off",
     stale: 0,
     changed: 0
-  } : await import("./zvec-MSRKT7IV.js").then(({ zvecCandidates }) => zvecCandidates(repositoryRoot, task)).catch(
+  } : await import("./zvec-KP4KNB7Y.js").then(
+    ({ zvecCandidates }) => zvecCandidates(
+      repositoryRoot,
+      task,
+      options.semantic === false && options.zvecDeadlineAt !== void 0 ? { deadlineAt: options.zvecDeadlineAt, requireServer: true } : {}
+    )
+  ).catch(
     () => ({
       status: "failed",
       paths: [],
@@ -1155,8 +1349,11 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
     const vector = [];
     const partial = [];
     let uncorroborated = 0;
+    let belowFloor = 0;
+    const minScore = semantic.minScore ?? 0;
     for (const path of semantic.paths) {
       if (!wantsTests && TEST_PATH.test(path)) continue;
+      if (!wantsChangelog && CHANGELOG_PATH.test(path)) continue;
       if (keyword.includes(path)) vector.push(path);
       else if (await hasMatchedPassageEvidence(
         repositoryRoot,
@@ -1166,6 +1363,10 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
         manifest.entries[path]?.symbolTable ?? []
       )) {
         const source = await readBoundedSource(repositoryRoot, path) ?? "";
+        if (idfCoverage(`${path} ${source}`, terms, idf) < minScore) {
+          belowFloor++;
+          continue;
+        }
         if (countTerms(source, terms) >= EVIDENCE_FLOOR.vectorTerms) vector.push(path);
         else partial.push(path);
         if (!evidence.has(path)) evidence.set(path, 0);
@@ -1181,6 +1382,11 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
     explain.push(
       `retrieval: keyword ranking fused with ${semantic.reason}` + (uncorroborated > 0 ? `; ${uncorroborated} uncorroborated vector file(s) dropped` : "")
     );
+    if (belowFloor > 0) {
+      explain.push(
+        `abstention: ${belowFloor} vector-only file(s) below zvec.minScore ${minScore} (task IDF coverage of current source) dropped`
+      );
+    }
   }
   let symbols;
   const reranked = await llmRerank({
@@ -1199,7 +1405,8 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
     ranked = reranked.ranked;
     symbols = reranked.symbols;
   }
-  if (!ranked.some((path) => !NON_SOURCE_PATH.test(path))) {
+  const wantsDocs = DOCS_TASK.test(task);
+  if (!ranked.some((path) => countsAsSource(path, task))) {
     explain.push(
       "abstention: no source file reached the evidence floor (" + (ranked.length > 0 ? "only docs/config did" : `best keyword score ${scored[0]?.score ?? 0} < ${EVIDENCE_FLOOR.keywordScore}`) + (commands.length > 0 ? "); only the named CLI command returned" : "); no task targets returned")
     );
@@ -1210,6 +1417,14 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
       `abstention: ${weakKeyword} weak keyword candidate(s) below the evidence floor (score < ${EVIDENCE_FLOOR.keywordScore}) dropped`
     );
   }
+  const vectors = options.semantic === false || reranked ? null : await rankFilesByVector(repositoryRoot, manifest, task);
+  if (vectors && vectors.length > 0) {
+    const doc = wantsDocs ? ranked.filter((path) => DOC_PATH.test(path)).slice(0, 1) : [];
+    ranked = [...doc, ...vectors.map((match) => match.path)].slice(0, TASK_FILES);
+    explain.push(
+      `retrieval: file vectors ordered the files (best ${vectors[0]?.score.toFixed(2)})`
+    );
+  }
   const expansion = expandAlongImports(ranked, await mapSource, evidence, task);
   if (expansion.explain) explain.push(expansion.explain);
   if (commands.length > 0) {
@@ -1232,7 +1447,7 @@ var MIN_RERANK_MS = 200;
 async function llmRerank(input) {
   let config;
   try {
-    config = await (await import("./config-DEVHUDIU.js")).resolveLlmConfig(input.repositoryRoot);
+    config = await (await import("./config-GEZFLXK6.js")).resolveLlmConfig(input.repositoryRoot);
   } catch {
     return null;
   }
@@ -1257,7 +1472,7 @@ async function llmRerank(input) {
     input.deadlineAt === void 0 ? config.timeoutMs : input.deadlineAt - Date.now()
   );
   if (deadlineMs < MIN_RERANK_MS) return skipped("no time left in the hook budget");
-  const { rerankCandidates } = await import("./rerank-5QZ3PNUW.js");
+  const { rerankCandidates } = await import("./rerank-IQAEWLQR.js");
   const result = await rerankCandidates(
     input.repositoryRoot,
     config,
@@ -1329,7 +1544,7 @@ async function commandFiles(repositoryRoot, task, entries) {
 var COMMAND_DIR = /(^|\/)(cli|cmd|commands?)\//;
 async function packageBins(repositoryRoot) {
   try {
-    const manifest = JSON.parse(await readFile8(join7(repositoryRoot, "package.json"), "utf8"));
+    const manifest = JSON.parse(await readFile9(join8(repositoryRoot, "package.json"), "utf8"));
     if (typeof manifest.bin === "string" && typeof manifest.name === "string") {
       return [manifest.name.slice(manifest.name.lastIndexOf("/") + 1)];
     }
@@ -1419,8 +1634,30 @@ async function hasMatchedPassageEvidence(repositoryRoot, path, hits, terms, symb
     );
   });
 }
-var TEST_PATH = /(^|\/)(__tests__|__fixtures__|fixtures?|test|tests)\/|\.(test|spec)\.[a-z]+$/;
-var NON_SOURCE_PATH = /(^|\/)(docs?|\.github)\/|\.(md|mdx|txt|ya?ml|json|lock)$|(^|\/)CHANGELOG/i;
+var TEST_PATH = /(^|\/)(__tests__|__fixtures__|fixtures?|test|tests)\/|\.(test|spec)\.[a-z]+$|(^|\/)(test_[^/]*|[^/]*_test|conftest)\.py$/;
+var CHANGELOG_PATH = new RegExp(
+  [
+    "(?:CHANGES|CHANGELOG|HISTORY|NEWS|RELEASES?|RELEASE[-_]?NOTES)(?:[._-][^/]*)?",
+    "[Cc]hange[-_]?[Ll]og[^/]*",
+    "[Rr]elease[-_]?[Nn]otes[^/]*",
+    "(?:[Cc]hanges|[Hh]istory|[Nn]ews|[Rr]eleases?)\\.(?:md|mdx|rst|txt|adoc|markdown)"
+  ].map((name) => `(?:^|/)${name}$`).join("|")
+);
+function asksForChangelog(task) {
+  return /\b(?:change[-_ ]?logs?|release[-_ ]?notes?|(?:release|version) history)\b/i.test(task) || /\b(?:CHANGES|HISTORY|NEWS|RELEASES?)\b/.test(task) || /\b(?:changes|history|news|releases?)\.(?:md|mdx|rst|txt|adoc)\b/i.test(task);
+}
+var NON_SOURCE_BASE = /(^|\/)(docs?|\.github)\/|\.(md|mdx|rst|adoc|txt|ya?ml|json|lock)$|(^|\/)CHANGELOG/i;
+var NON_SOURCE_PATH = {
+  test: (path) => NON_SOURCE_BASE.test(path) || CHANGELOG_PATH.test(path)
+};
+var PROSE_PATH = /(^|\/)docs?\/|\.(md|mdx|rst|txt)$/i;
+var DOC_PATH = {
+  test: (path) => PROSE_PATH.test(path) && !CHANGELOG_PATH.test(path)
+};
+var DOCS_TASK = /\b(docs?|documentation|documented|guides?|tutorials?|readme|manual)\b/i;
+function countsAsSource(path, task) {
+  return !NON_SOURCE_PATH.test(path) || DOCS_TASK.test(task) && DOC_PATH.test(path) || asksForChangelog(task) && CHANGELOG_PATH.test(path);
+}
 function scoreTaskPaths(entries, task) {
   const terms = taskTerms(task);
   if (terms.length === 0) return [];
@@ -1457,7 +1694,7 @@ function scoreTaskPaths(entries, task) {
       }
     }
     if (weighted === 0) return [];
-    if (NON_SOURCE_PATH.test(path)) {
+    if (!countsAsSource(path, task)) {
       score *= 0.5;
       weighted *= 0.5;
     }
@@ -1467,12 +1704,22 @@ function scoreTaskPaths(entries, task) {
   );
 }
 function splitWords(text) {
-  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 2).map(
-    (word) => word.length > 3 && word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word
-  );
+  return rawWords(text).map(foldPlural);
+}
+function rawWords(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 2);
+}
+function foldPlural(word) {
+  if (word.length <= 3 || !word.endsWith("s") || /(ss|us|is)$/.test(word)) return word;
+  if (/(ss|sh|ch|x|z)es$/.test(word)) return word.slice(0, -2);
+  return word.slice(0, -1);
 }
 function taskTerms(task) {
-  return [...new Set(splitWords(task).filter((term) => !TASK_STOPWORDS.has(term)))];
+  return [
+    ...new Set(
+      rawWords(task).filter((word) => !TASK_STOPWORDS.has(word)).map(foldPlural).filter((term) => !TASK_STOPWORDS.has(term))
+    )
+  ];
 }
 function countTerms(text, terms) {
   if (terms.length === 0) return 0;
@@ -1492,7 +1739,7 @@ async function loadProjectArchitectureMap(repositoryRoot, manifestSource) {
   const builtIn = (await loadArchitectureMap(repositoryRoot, manifest)).map;
   if (config.graphify?.enabled && await graphifyGraphExists(repositoryRoot, config.graphify.graphPath)) {
     try {
-      const graphPath = join7(
+      const graphPath = join8(
         repositoryRoot,
         config.graphify.graphPath ?? "graphify-out/graph.json"
       );
@@ -1505,7 +1752,7 @@ async function loadProjectArchitectureMap(repositoryRoot, manifestSource) {
         (await Promise.all(
           graph.modules.map(async (module) => {
             try {
-              const absolute = await realpath(join7(repositoryRoot, module.path));
+              const absolute = await realpath(join8(repositoryRoot, module.path));
               const inside = relative6(await realpath(repositoryRoot), absolute);
               if (inside.startsWith("..") || isAbsolute3(inside)) return null;
               const source = await stat4(absolute);
@@ -1554,20 +1801,143 @@ async function loadProjectArchitectureMap(repositoryRoot, manifestSource) {
   return { ...builtIn, source: "imports" };
 }
 
+// src/context/file-vectors.ts
+var CHUNK_LINES = 40;
+var CHUNK_STEP = 30;
+var CHUNK_CHARS = 2e3;
+var BATCH = 16;
+var MODEL = `${LOCAL_EMBEDDING_MODEL.id}@${LOCAL_EMBEDDING_MODEL.revision}`;
+async function localEmbed(texts) {
+  const { LocalModelProvider } = await import("./local-ST4WMRCG.js");
+  return (await new LocalModelProvider().embed({ input: texts })).vectors;
+}
+async function refreshFileVectors(repositoryRoot, manifest, deadlineAt, embed = localEmbed) {
+  const store = await loadStore(repositoryRoot);
+  const eligible = eligiblePaths(manifest);
+  const files = {};
+  const todo = [];
+  for (const path of eligible) {
+    const cached = store.files[path];
+    if (cached && cached.hash === manifest.entries[path]?.hash) files[path] = cached;
+    else todo.push(path);
+  }
+  let embedded = 0;
+  let lastSave = Date.now();
+  for (const path of todo) {
+    if (Date.now() >= deadlineAt) break;
+    const source = await readBoundedSource(repositoryRoot, path);
+    if (source === null) continue;
+    const vectors = [];
+    const chunks = chunk(path, source);
+    for (let start = 0; start < chunks.length; start += BATCH) {
+      for (const vector of await embed(chunks.slice(start, start + BATCH))) {
+        vectors.push(encode(vector));
+      }
+    }
+    files[path] = { hash: manifest.entries[path]?.hash ?? "", vectors };
+    embedded += 1;
+    if (Date.now() - lastSave > 3e4) {
+      await saveStore(repositoryRoot, { version: 1, model: MODEL, files });
+      lastSave = Date.now();
+    }
+  }
+  await saveStore(repositoryRoot, { version: 1, model: MODEL, files });
+  return {
+    embedded,
+    files: Object.keys(files).length,
+    pending: eligible.length - Object.keys(files).length
+  };
+}
+async function syncFileVectors(repositoryRoot, budgetMs) {
+  const started = Date.now();
+  try {
+    const { manifest } = await loadFreshIndex(repositoryRoot);
+    return await refreshFileVectors(repositoryRoot, manifest, started + budgetMs);
+  } catch {
+    return null;
+  }
+}
+async function rankFilesByVector(repositoryRoot, manifest, task, embed = localEmbed) {
+  if (process.env.CODEBUDDY_SEMANTIC === "0") return null;
+  const store = await loadStore(repositoryRoot);
+  const current = eligiblePaths(manifest).filter(
+    (path) => store.files[path]?.hash === manifest.entries[path]?.hash
+  );
+  if (current.length === 0) return null;
+  let query;
+  try {
+    const [vector] = await embed([task]);
+    if (!vector) return null;
+    query = vector;
+  } catch {
+    return null;
+  }
+  return current.map((path) => ({
+    path,
+    score: Math.max(...(store.files[path]?.vectors ?? []).map((v) => dot(decode(v), query)))
+  })).sort((left, right) => right.score - left.score || left.path.localeCompare(right.path));
+}
+function eligiblePaths(manifest) {
+  return Object.keys(manifest.entries).filter(
+    (path) => !NON_SOURCE_PATH.test(path) && !TEST_PATH.test(path)
+  );
+}
+function chunk(path, source) {
+  const lines = source.split("\n");
+  const chunks = [];
+  for (let start = 0; start === 0 || start + 10 < lines.length; start += CHUNK_STEP) {
+    chunks.push(
+      `${path}
+${lines.slice(start, start + CHUNK_LINES).join("\n")}`.slice(0, CHUNK_CHARS)
+    );
+  }
+  return chunks;
+}
+function encode(vector) {
+  return Buffer.from(Float32Array.from(vector).buffer).toString("base64");
+}
+function decode(text) {
+  const bytes = Buffer.from(text, "base64");
+  return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+}
+function dot(left, right) {
+  let sum = 0;
+  for (let index = 0; index < right.length; index++)
+    sum += (left[index] ?? 0) * (right[index] ?? 0);
+  return sum;
+}
+function storePath(repositoryRoot) {
+  return join9(repositoryRoot, ".codebuddy", "cache", "file-vectors.json");
+}
+async function loadStore(repositoryRoot) {
+  try {
+    const parsed = JSON.parse(await readFile10(storePath(repositoryRoot), "utf8"));
+    if (parsed.version === 1 && parsed.model === MODEL && parsed.files) return parsed;
+  } catch {
+  }
+  return { version: 1, model: MODEL, files: {} };
+}
+async function saveStore(repositoryRoot, store) {
+  const path = storePath(repositoryRoot);
+  await mkdir5(dirname6(path), { recursive: true });
+  await writeAtomic(path, JSON.stringify(store));
+}
+
 export {
   buildArchitectureMap,
   queryMap,
   neighbours,
-  loadArchitectureMap,
   indexRepository,
   loadFreshIndex,
   setupGraphify,
   generateGraphifyGraph,
   loadGraphifyMap,
+  syncFileVectors,
   TASK_PATH_LIMIT,
   readBoundedSource,
   discoverTaskPaths,
   TEST_PATH,
+  asksForChangelog,
   NON_SOURCE_PATH,
   taskTerms,
   countTerms,
@@ -1575,4 +1945,4 @@ export {
   namedSegments,
   loadProjectArchitectureMap
 };
-//# sourceMappingURL=chunk-NERKZSSE.js.map
+//# sourceMappingURL=chunk-5EDGAZQN.js.map