@orquentra/codebuddy 0.0.0-stage → 2.4.0

package/dist/chunk-IBMJYIEP.js

@@ -0,0 +1,1578 @@
+import {
+  extractSymbolTable,
+  supportsSymbols
+} from "./chunk-PQK3GKZH.js";
+import {
+  assertNoSymlinkBetween,
+  readConfigFile,
+  writeAtomic
+} from "./chunk-K63EOA4B.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 IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".codebuddy"
+]);
+async function buildArchitectureMap(repositoryRoot = process.cwd()) {
+  const root = resolve(repositoryRoot);
+  const files = await listSourceFiles(root);
+  const fileSet = new Set(files.map((file) => normalize(relative(root, file))));
+  const modules = [];
+  const edges = [];
+  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 });
+    }
+    modules.push({
+      path: from,
+      language: extname(absolutePath).includes("ts") ? "ts" : "js",
+      imports: [...new Set(resolvedImports)].sort()
+    });
+  }
+  return {
+    modules: modules.sort((left, right) => left.path.localeCompare(right.path)),
+    edges: edges.sort(
+      (left, right) => `${left.from}:${left.to}`.localeCompare(`${right.from}:${right.to}`)
+    )
+  };
+}
+async function updateArchitectureMap(repositoryRoot, sourcePaths, previous, changedPaths) {
+  const root = resolve(repositoryRoot);
+  const normalizedPaths = sourcePaths.map(normalize).sort();
+  const fileSet = new Set(normalizedPaths);
+  const changed = new Set(changedPaths.map(normalize));
+  const retainedModules = (previous?.modules ?? []).filter(
+    (module) => fileSet.has(module.path) && !changed.has(module.path)
+  );
+  const retainedEdges = (previous?.edges ?? []).filter(
+    (edge) => fileSet.has(edge.from) && fileSet.has(edge.to) && !changed.has(edge.from)
+  );
+  const modules = [...retainedModules];
+  const edges = [...retainedEdges];
+  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 });
+    }
+    modules.push({
+      path,
+      language: extname(path).includes("ts") ? "ts" : "js",
+      imports: [...new Set(resolvedImports)].sort()
+    });
+  }
+  return {
+    map: {
+      modules: modules.sort((left, right) => left.path.localeCompare(right.path)),
+      edges: edges.sort(
+        (left, right) => `${left.from}:${left.to}`.localeCompare(`${right.from}:${right.to}`)
+      )
+    },
+    stats: {
+      readFiles: changed.size,
+      reusedFiles: retainedModules.length,
+      rebuilt: previous === null || changed.size === normalizedPaths.length
+    }
+  };
+}
+function queryMap(map, query) {
+  const limit = query.limit ?? 50;
+  return map.edges.filter((edge) => query.from ? edge.from === normalize(query.from) : true).filter((edge) => query.to ? edge.to === normalize(query.to) : true).slice(0, limit);
+}
+function neighbours(map, modulePath, direction = "both") {
+  const target = normalize(modulePath);
+  const edges = map.edges.filter((edge) => {
+    if (direction === "in") return edge.to === target;
+    if (direction === "out") return edge.from === target;
+    return edge.from === target || edge.to === target;
+  });
+  const paths = /* @__PURE__ */ new Set([target]);
+  for (const edge of edges) {
+    paths.add(edge.from);
+    paths.add(edge.to);
+  }
+  return {
+    modules: map.modules.filter((module) => paths.has(module.path)),
+    edges
+  };
+}
+async function listSourceFiles(root) {
+  const files = [];
+  await walk(root, files);
+  return files.sort();
+}
+async function walk(directory, files) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    const absolute = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (IGNORED_DIRECTORIES.has(entry.name)) continue;
+      await walk(absolute, files);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!SUPPORTED_EXTENSIONS.has(extname(entry.name))) continue;
+    const info = await stat(absolute);
+    if (info.size > 5e5) continue;
+    files.push(absolute);
+  }
+}
+function extractImports(source) {
+  const imports = [];
+  const stripped = source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:])\/\/[^\n]*/g, "$1 ");
+  const staticImport = /\bimport\s+(?:type\s+)?(?:[^'"()+]+?\s+from\s+)?["']([^"']+)["']/g;
+  const exportFrom = /\bexport\s+[^'"()+]+?\s+from\s+["']([^"']+)["']/g;
+  const dynamicImport = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+  for (const match of stripped.matchAll(staticImport)) {
+    if (match[1]) imports.push({ value: match[1], kind: "import" });
+  }
+  for (const match of stripped.matchAll(exportFrom)) {
+    if (match[1]) imports.push({ value: match[1], kind: "import" });
+  }
+  for (const match of stripped.matchAll(dynamicImport)) {
+    if (match[1]) imports.push({ value: match[1], kind: "dynamic_import" });
+  }
+  return imports;
+}
+function resolveImport(root, from, specifier, fileSet) {
+  if (!specifier.startsWith(".")) return null;
+  const base = normalize(relative(root, resolve(root, dirname(from), specifier)));
+  const stem = base.replace(/\.(js|jsx|mjs|cjs)$/, "");
+  const bases = stem === base ? [base] : [base, stem];
+  const candidates = bases.flatMap((b) => [
+    b,
+    `${b}.ts`,
+    `${b}.tsx`,
+    `${b}.js`,
+    `${b}.jsx`,
+    `${b}.mjs`,
+    `${b}.cjs`,
+    `${b}/index.ts`,
+    `${b}/index.tsx`,
+    `${b}/index.js`,
+    `${b}/index.jsx`
+  ]);
+  return candidates.find((candidate) => fileSet.has(candidate)) ?? null;
+}
+function normalize(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+// src/indexer/engine.ts
+import { createHash } from "crypto";
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
+import { join as join5, resolve as resolve4 } from "path";
+
+// src/map/cache.ts
+import { mkdir as mkdir2, readFile as readFile3 } from "fs/promises";
+import { dirname as dirname3, extname as extname2, join as join3, resolve as resolve3 } from "path";
+
+// src/indexer/store.ts
+import { mkdir, readFile as readFile2 } from "fs/promises";
+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;
+
+// src/indexer/store.ts
+var symbolSpanSchema = z.object({
+  name: z.string(),
+  kind: z.enum(["function", "method", "class", "interface", "type", "enum", "const"]),
+  startLine: z.number().int().nonnegative(),
+  endLine: z.number().int().nonnegative(),
+  signature: z.string(),
+  exported: z.boolean()
+});
+var entrySchema = z.object({
+  path: z.string(),
+  hash: z.string(),
+  size: z.number().int().nonnegative(),
+  mtimeMs: z.number().optional(),
+  ctimeMs: z.number().optional(),
+  language: z.string(),
+  lines: z.number().int().nonnegative(),
+  symbols: z.array(z.string()),
+  symbolTable: z.array(symbolSpanSchema).optional(),
+  summary: z.string(),
+  indexedAt: z.string()
+});
+var manifestSchema = z.object({
+  version: z.literal(INDEX_MANIFEST_VERSION),
+  generatedAt: z.string(),
+  entries: z.record(z.string(), entrySchema)
+});
+var IndexStore = class {
+  repositoryRoot;
+  cacheDirectory;
+  manifestPath;
+  constructor(repositoryRoot = process.cwd()) {
+    this.repositoryRoot = resolve2(repositoryRoot);
+    this.cacheDirectory = join2(this.repositoryRoot, ".codebuddy", "cache");
+    this.manifestPath = join2(this.cacheDirectory, "index.json");
+  }
+  /** Read the manifest, or an empty one if absent/corrupt/version-mismatched. */
+  async read() {
+    try {
+      const raw = await readFile2(this.manifestPath, "utf8");
+      const parsed = manifestSchema.safeParse(JSON.parse(raw));
+      if (!parsed.success) return emptyManifest();
+      return parsed.data;
+    } catch (error) {
+      if (error.code === "ENOENT") return emptyManifest();
+      return emptyManifest();
+    }
+  }
+  async write(manifest) {
+    await assertNoSymlinkBetween(this.repositoryRoot, dirname2(this.manifestPath));
+    await mkdir(this.cacheDirectory, { recursive: true, mode: 448 });
+    await writeAtomic(this.manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  }
+};
+function emptyManifest() {
+  return { version: INDEX_MANIFEST_VERSION, generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(), entries: {} };
+}
+
+// src/map/cache.ts
+var CACHE_VERSION = 1;
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+async function loadArchitectureMap(repositoryRoot = process.cwd(), suppliedManifest) {
+  const root = resolve3(repositoryRoot);
+  const manifest = suppliedManifest ?? await new IndexStore(root).read();
+  if (Object.keys(manifest.entries).length === 0) {
+    const map = await buildArchitectureMap(root);
+    return {
+      map,
+      stats: { readFiles: map.modules.length, reusedFiles: 0, rebuilt: true },
+      source: "fallback"
+    };
+  }
+  return refreshArchitectureCache(root, manifest);
+}
+async function refreshArchitectureCache(repositoryRoot, manifest) {
+  const root = resolve3(repositoryRoot);
+  const path = join3(root, ".codebuddy", "cache", "architecture.json");
+  const currentHashes = sourceHashes(manifest);
+  const currentPaths = Object.keys(currentHashes).sort();
+  const cached = await readCache(path);
+  const cachedPaths = cached ? Object.keys(cached.sourceHashes).sort() : [];
+  const fileSetChanged = cachedPaths.join("\n") !== currentPaths.join("\n");
+  const changedPaths = !cached || fileSetChanged ? currentPaths : currentPaths.filter(
+    (sourcePath) => cached.sourceHashes[sourcePath] !== currentHashes[sourcePath]
+  );
+  if (cached && changedPaths.length === 0) {
+    return {
+      map: cached.map,
+      stats: { readFiles: 0, reusedFiles: cached.map.modules.length, rebuilt: false },
+      source: "cache"
+    };
+  }
+  const updated = await updateArchitectureMap(
+    root,
+    currentPaths,
+    fileSetChanged ? null : cached?.map ?? null,
+    changedPaths
+  );
+  const next = {
+    version: CACHE_VERSION,
+    generatedAt: manifest.generatedAt,
+    sourceHashes: currentHashes,
+    map: updated.map
+  };
+  await assertNoSymlinkBetween(root, dirname3(path));
+  await mkdir2(dirname3(path), { recursive: true, mode: 448 });
+  await writeAtomic(path, `${JSON.stringify(next, null, 2)}
+`);
+  return { ...updated, source: fileSetChanged || !cached ? "rebuild" : "incremental" };
+}
+async function readCache(path) {
+  try {
+    const parsed = JSON.parse(await readFile3(path, "utf8"));
+    if (parsed.version !== CACHE_VERSION || !parsed.map || !parsed.sourceHashes) return null;
+    if (!Array.isArray(parsed.map.modules) || !Array.isArray(parsed.map.edges)) return null;
+    if (!parsed.map.modules.every(
+      (module) => module && typeof module.path === "string" && typeof module.language === "string" && Array.isArray(module.imports)
+    ) || !parsed.map.edges.every(
+      (edge) => edge && typeof edge.from === "string" && typeof edge.to === "string"
+    )) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function sourceHashes(manifest) {
+  return Object.fromEntries(
+    Object.values(manifest.entries).filter((entry) => SOURCE_EXTENSIONS.has(extname2(entry.path).toLowerCase())).map((entry) => [entry.path, entry.hash])
+  );
+}
+
+// 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";
+
+// src/indexer/summary.ts
+import { extname as extname3 } from "path";
+var LANGUAGE_BY_EXTENSION = {
+  ".ts": "ts",
+  ".tsx": "tsx",
+  ".js": "js",
+  ".jsx": "jsx",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".json": "json",
+  ".md": "md",
+  ".mdx": "md",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".css": "css",
+  ".scss": "scss",
+  ".html": "html",
+  ".py": "py",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".rb": "ruby",
+  ".php": "php",
+  ".sh": "shell",
+  ".sql": "sql",
+  ".txt": "text"
+};
+var SUPPORTED_EXTENSIONS2 = new Set(Object.keys(LANGUAGE_BY_EXTENSION));
+var CODE_LANGUAGES = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx"]);
+var SYMBOL_LIMIT = 8;
+var SUMMARY_COMMENT_MAX = 80;
+function languageFor(path) {
+  return LANGUAGE_BY_EXTENSION[extname3(path).toLowerCase()] ?? "text";
+}
+function summarizeSource(path, content) {
+  const language = languageFor(path);
+  const lines = countLines(content);
+  const symbols = CODE_LANGUAGES.has(language) ? extractSymbols(content) : [];
+  const summary = composeSummary(language, lines, symbols, content);
+  return { language, lines, symbols, summary };
+}
+function countLines(content) {
+  if (content.length === 0) return 0;
+  return content.replace(/\r/g, "").replace(/\n$/, "").split("\n").length;
+}
+function extractSymbols(content) {
+  const names = [];
+  const push = (name) => {
+    const trimmed = name?.trim();
+    if (trimmed && /^[A-Za-z_$][\w$]*$/.test(trimmed) && !names.includes(trimmed)) {
+      names.push(trimmed);
+    }
+  };
+  const declaration = /^export\s+(?:default\s+)?(?:async\s+)?(?:abstract\s+)?(?:const|let|var|function|class|interface|type|enum)\s+([A-Za-z_$][\w$]*)/gm;
+  for (const match of content.matchAll(declaration)) push(match[1]);
+  const namedExports = /^export\s*\{([^}]*)\}/gm;
+  for (const match of content.matchAll(namedExports)) {
+    for (const part of (match[1] ?? "").split(",")) {
+      const alias = part.includes(" as ") ? part.split(" as ").pop() : part;
+      push(alias);
+    }
+  }
+  return names.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(", ")}`;
+  const comment = leadingComment(content);
+  if (comment) return `${head} \u2022 ${comment}`;
+  return head;
+}
+function leadingComment(content) {
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line === "") continue;
+    const stripped = line.replace(/^\/\/+/, "").replace(/^\/\*+/, "").replace(/\*+\/$/, "").replace(/^[#*]+/, "").trim();
+    if (line.startsWith("//") || line.startsWith("/*") || line.startsWith("#") || line.startsWith("*")) {
+      if (stripped) return truncate(stripped, SUMMARY_COMMENT_MAX);
+      continue;
+    }
+    return null;
+  }
+  return null;
+}
+function truncate(value, max) {
+  return value.length <= max ? value : `${value.slice(0, max - 1)}\u2026`;
+}
+
+// src/indexer/scan.ts
+var FALLBACK_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".codebuddy",
+  "graphify-out",
+  ".next",
+  ".turbo",
+  "out"
+]);
+async function listIndexableFiles(repositoryRoot) {
+  const tracked = await gitListFiles(repositoryRoot);
+  const paths = tracked ?? await walkFiles(repositoryRoot);
+  return paths.map(normalize2).filter((path) => !path.startsWith(".codebuddy/") && !path.startsWith("graphify-out/")).filter((path) => SUPPORTED_EXTENSIONS2.has(extname4(path).toLowerCase())).sort();
+}
+async function gitListFiles(repositoryRoot) {
+  const result = await runGit(repositoryRoot, [
+    "ls-files",
+    "--cached",
+    "--others",
+    "--exclude-standard"
+  ]);
+  if (result.code !== 0) return null;
+  return result.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+async function walkFiles(root) {
+  const files = [];
+  const walk2 = async (directory) => {
+    const entries = await readdir2(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolute = join4(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (FALLBACK_IGNORED_DIRECTORIES.has(entry.name)) continue;
+        await walk2(absolute);
+        continue;
+      }
+      if (entry.isFile()) files.push(relative2(root, absolute));
+    }
+  };
+  await walk2(root);
+  return files;
+}
+function runGit(cwd, args) {
+  return new Promise((resolveResult) => {
+    const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    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(/^\.\//, "");
+}
+
+// src/indexer/engine.ts
+var MAX_FILE_BYTES = 512e3;
+var RACY_WINDOW_MS = 3e3;
+async function indexRepository(options = {}) {
+  return (await refreshIndex(options)).result;
+}
+async function loadFreshIndex(repositoryRoot) {
+  try {
+    const { result, manifest } = await refreshIndex({ repositoryRoot });
+    const delta = result.added + result.changed + result.removed;
+    const failures = result.errors.length > 0 ? `; ${result.errors.length} file(s) could not be validated and were omitted` : "";
+    return {
+      manifest,
+      explain: delta === 0 ? `index: ${result.totalIndexed} indexed file(s) match current source${failures}` : `index: refreshed against current source (${result.changed} changed, ${result.added} added, ${result.removed} removed; ${result.totalIndexed} indexed)${failures}`
+    };
+  } catch (error) {
+    return {
+      manifest: emptyManifest(),
+      explain: `index: freshness check failed (${error.message}); indexed evidence omitted`
+    };
+  }
+}
+var passes = /* @__PURE__ */ new Map();
+function refreshIndex(options) {
+  const key = resolve4(options.repositoryRoot ?? process.cwd());
+  const next = (passes.get(key) ?? Promise.resolve()).catch(() => void 0).then(() => runIndexPass(options));
+  passes.set(key, next);
+  void next.finally(() => {
+    if (passes.get(key) === next) passes.delete(key);
+  }).catch(() => void 0);
+  return next;
+}
+async function runIndexPass(options) {
+  const start = Date.now();
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const repositoryRoot = resolve4(options.repositoryRoot ?? process.cwd());
+  const store = new IndexStore(repositoryRoot);
+  const [files, previous] = await Promise.all([listIndexableFiles(repositoryRoot), store.read()]);
+  const entries = {};
+  const errors = [];
+  let added = 0;
+  let changed = 0;
+  let unchanged = 0;
+  let skipped = 0;
+  let dirty = previous.generatedAt === emptyManifest().generatedAt;
+  for (const path of files) {
+    try {
+      const info = await stat2(join5(repositoryRoot, path));
+      if (!info.isFile()) continue;
+      if (info.size > MAX_FILE_BYTES) {
+        skipped++;
+        continue;
+      }
+      const existing = previous.entries[path];
+      if (!options.full && existing && statUnchanged(existing, info)) {
+        entries[path] = existing;
+        unchanged++;
+        continue;
+      }
+      const content = await readFile4(join5(repositoryRoot, path), "utf8");
+      const hash = hashContent(content);
+      const metadata = trustedMetadata(info);
+      dirty = true;
+      if (!options.full && existing && existing.hash === hash) {
+        const { mtimeMs: _mtime, ctimeMs: _ctime, ...rest } = existing;
+        entries[path] = { ...rest, size: info.size, ...metadata };
+        unchanged++;
+        continue;
+      }
+      const { language, lines, symbols, summary } = summarizeSource(path, content);
+      const symbolTable = supportsSymbols(path) ? extractSymbolTable(content) : [];
+      entries[path] = {
+        path,
+        hash,
+        size: info.size,
+        ...metadata,
+        language,
+        lines,
+        symbols,
+        ...symbolTable.length > 0 ? { symbolTable } : {},
+        summary,
+        indexedAt: now().toISOString()
+      };
+      if (existing) changed++;
+      else added++;
+    } catch (error) {
+      errors.push({ path, error: error.message });
+      skipped++;
+    }
+  }
+  const removed = Object.keys(previous.entries).filter((path) => !(path in entries)).length;
+  const manifest = {
+    version: INDEX_MANIFEST_VERSION,
+    generatedAt: now().toISOString(),
+    entries: sortEntries(entries)
+  };
+  if (dirty || removed > 0) await store.write(manifest);
+  const architecture = await refreshArchitectureCache(repositoryRoot, manifest);
+  const result = {
+    scanned: files.length,
+    added,
+    changed,
+    unchanged,
+    removed,
+    skipped,
+    errors,
+    durationMs: Date.now() - start,
+    totalIndexed: Object.keys(entries).length,
+    architecture: {
+      source: architecture.source,
+      readFiles: architecture.stats.readFiles,
+      reusedFiles: architecture.stats.reusedFiles
+    }
+  };
+  return { result, manifest };
+}
+function statUnchanged(entry, info) {
+  return entry.mtimeMs !== void 0 && entry.size === info.size && entry.mtimeMs === info.mtimeMs && entry.ctimeMs === info.ctimeMs;
+}
+function trustedMetadata(info) {
+  if (Date.now() - Math.max(info.mtimeMs, info.ctimeMs) < RACY_WINDOW_MS) return {};
+  return { mtimeMs: info.mtimeMs, ctimeMs: info.ctimeMs };
+}
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function sortEntries(entries) {
+  return Object.fromEntries(
+    Object.keys(entries).sort().map((key) => [key, entries[key]])
+  );
+}
+
+// src/integrations/graphify.ts
+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 { promisify } from "util";
+
+// src/map/graph-freshness.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile5 } from "fs/promises";
+var digest = (value) => createHash2("sha256").update(value).digest("hex");
+async function writeGraphSourceSnapshot(path, manifest) {
+  await writeAtomic(
+    `${path}.sources.json`,
+    JSON.stringify({
+      version: 1,
+      graphHash: digest(await readFile5(path, "utf8")),
+      sources: Object.fromEntries(
+        Object.values(manifest.entries).map((entry) => [entry.path, entry.hash])
+      )
+    })
+  );
+}
+async function readGraphSourceSnapshot(path) {
+  let raw;
+  try {
+    raw = await readFile5(`${path}.sources.json`, "utf8");
+  } catch (error) {
+    return error.code === "ENOENT" ? null : {};
+  }
+  try {
+    const snapshot = JSON.parse(raw);
+    if (snapshot.version !== 1 || snapshot.graphHash !== digest(await readFile5(path, "utf8")) || !snapshot.sources || typeof snapshot.sources !== "object" || Array.isArray(snapshot.sources))
+      return {};
+    return Object.fromEntries(
+      Object.entries(snapshot.sources).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    );
+  } catch {
+    return {};
+  }
+}
+
+// src/integrations/graphify.ts
+var execFileAsync = promisify(execFile);
+var DEFAULT_GRAPH_PATH = "graphify-out/graph.json";
+async function setupGraphify(options) {
+  const run = options.run ?? runCommand;
+  let available = await commandWorks(run, "graphify", ["--version"], options.repositoryRoot);
+  let installed = false;
+  if (!available) {
+    const installers = [
+      ["uv", ["tool", "install", "graphifyy"]],
+      ["pipx", ["install", "graphifyy"]],
+      ["python", ["-m", "pip", "install", "--user", "graphifyy"]]
+    ];
+    for (const [command, args] of installers) {
+      try {
+        await run(command, [...args], options.repositoryRoot);
+        available = await commandWorks(run, "graphify", ["--version"], options.repositoryRoot);
+        if (available) {
+          installed = true;
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  if (!available) {
+    return {
+      available: false,
+      installed,
+      generated: false,
+      graphPath: DEFAULT_GRAPH_PATH,
+      message: "Graphify was selected but is not available. Install graphifyy with uv/pipx, then run `codebuddy graphify index`."
+    };
+  }
+  try {
+    await run("graphify", ["install"], options.repositoryRoot).catch(() => void 0);
+    const graph = await generateGraphifyGraph({ repositoryRoot: options.repositoryRoot, run });
+    return {
+      available: true,
+      installed,
+      generated: true,
+      graphPath: graph.graphPath,
+      message: `Graphify graph generated (${graph.nodes} nodes, ${graph.edges} edges).`
+    };
+  } catch (error) {
+    return {
+      available: true,
+      installed,
+      generated: false,
+      graphPath: DEFAULT_GRAPH_PATH,
+      message: `Graphify is installed but its graph could not be generated: ${error.message}`
+    };
+  }
+}
+async function commandWorks(run, command, args, cwd) {
+  try {
+    await run(command, args, cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runCommand(command, args, cwd) {
+  return execFileAsync(command, args, { cwd });
+}
+async function graphifyGraphExists(repositoryRoot, graphPath = DEFAULT_GRAPH_PATH) {
+  try {
+    const parsed = await readGraphFile(resolveGraphPath(repositoryRoot, graphPath));
+    return parsed.nodes > 0;
+  } catch {
+    return false;
+  }
+}
+async function generateGraphifyGraph(options) {
+  const run = options.run ?? runCommand;
+  const repositoryRoot = resolve5(options.repositoryRoot);
+  const graphPath = options.graphPath ?? DEFAULT_GRAPH_PATH;
+  const destination = resolveGraphPath(repositoryRoot, graphPath);
+  await mkdir3(dirname4(destination), { recursive: true });
+  await ignoreGeneratedGraphDirectory(dirname4(destination));
+  const { manifest: sourceSnapshot } = await loadFreshIndex(repositoryRoot);
+  const current = await readGraphFileIfPresent(destination);
+  const isDefaultPath = graphPath === DEFAULT_GRAPH_PATH;
+  if (current && isDefaultPath) {
+    const backup = await readFile6(destination, "utf8");
+    const backupStat = await stat3(destination);
+    try {
+      await run("graphify", ["update", repositoryRoot, "--force", "--no-cluster"], repositoryRoot);
+      const updated = await readGraphFile(destination);
+      await writeGraphSourceSnapshot(destination, sourceSnapshot);
+      return { graphPath, generated: true, ...updated };
+    } catch (error) {
+      await writeAtomic(destination, backup);
+      await utimes(destination, backupStat.atime, backupStat.mtime);
+      throw new Error(
+        `Graphify update failed; the previous graph was preserved: ${error.message}`
+      );
+    }
+  }
+  const stagingRoot = await mkdtemp(join6(tmpdir(), "codebuddy-graphify-"));
+  try {
+    await run(
+      "graphify",
+      ["extract", repositoryRoot, "--out", stagingRoot, "--code-only", "--no-cluster"],
+      repositoryRoot
+    );
+    const stagedPath = join6(stagingRoot, DEFAULT_GRAPH_PATH);
+    const staged = await readGraphFile(stagedPath);
+    await writeAtomic(destination, await readFile6(stagedPath, "utf8"));
+    await writeGraphSourceSnapshot(destination, sourceSnapshot);
+    return { graphPath, generated: true, ...staged };
+  } finally {
+    await rm(stagingRoot, { recursive: true, force: true });
+  }
+}
+async function ignoreGeneratedGraphDirectory(directory) {
+  const path = join6(directory, ".gitignore");
+  try {
+    await stat3(path);
+  } catch {
+    await writeAtomic(path, "# CodeBuddy-generated Graphify output (derived, rebuildable)\n*\n");
+  }
+}
+function resolveGraphPath(repositoryRoot, graphPath) {
+  const absolute = resolve5(repositoryRoot, graphPath);
+  const relativePath = relative3(repositoryRoot, absolute);
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`)) {
+    throw new Error(`Graph path must be inside the project root: ${graphPath}`);
+  }
+  return absolute;
+}
+async function readGraphFileIfPresent(path) {
+  try {
+    return await readGraphFile(path);
+  } catch {
+    return null;
+  }
+}
+async function readGraphFile(path) {
+  const info = await stat3(path);
+  if (!info.isFile() || info.size === 0)
+    throw new Error(`Graphify graph is missing or empty: ${path}`);
+  const raw = JSON.parse(await readFile6(path, "utf8"));
+  const nodes = arrayLength(raw.nodes ?? raw.entities);
+  const edges = arrayLength(raw.edges ?? raw.links ?? raw.relationships);
+  if (nodes === 0) throw new Error(`Graphify graph contains no nodes: ${path}`);
+  return { nodes, edges };
+}
+function arrayLength(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+
+// 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";
+
+// src/map/graphify.ts
+import { readFile as readFile7 } from "fs/promises";
+import { isAbsolute, relative as relative4, resolve as resolve6 } from "path";
+var NON_DEPENDENCY_RELATIONS = /* @__PURE__ */ new Set([
+  "contains",
+  "part_of",
+  "defines",
+  "declares",
+  "references",
+  "requires_env",
+  "rationale_for"
+]);
+var INVERSE_RELATIONS = /* @__PURE__ */ new Set([
+  "imported_by",
+  "called_by",
+  "used_by",
+  "referenced_by",
+  "extended_by",
+  "implemented_by",
+  "dependency_of",
+  "depended_on_by"
+]);
+var DIRECT_DEPENDENCY_RELATIONS = /* @__PURE__ */ new Set([
+  "import",
+  "imports",
+  "imports_from",
+  "dynamic_import",
+  "dynamic_imports",
+  "calls",
+  "uses",
+  "extends",
+  "implements",
+  "depends_on"
+]);
+var MAX_EDGE_SYMBOLS = 8;
+async function loadGraphifyMap(graphPath, repositoryRoot = process.cwd()) {
+  const raw = JSON.parse(await readFile7(graphPath, "utf8"));
+  const nodes = arrayRecord(raw.nodes ?? raw.entities);
+  const edges = arrayRecord(raw.edges ?? raw.links ?? raw.relationships);
+  const nodePaths = /* @__PURE__ */ new Map();
+  const nodeLabels = /* @__PURE__ */ new Map();
+  const modules = [];
+  for (const node of nodes) {
+    const id = stringValue(node.id ?? node.key ?? node.name);
+    const path = graphifyPath(node, repositoryRoot);
+    if (!id || !path) continue;
+    nodePaths.set(id, path);
+    const label = stringValue(node.label ?? node.name);
+    if (label && label !== path && !path.endsWith(`/${label}`)) nodeLabels.set(id, label);
+    modules.push({ path, language: languageFor2(path), imports: [] });
+  }
+  const modulePaths = new Set(modules.map((module) => module.path));
+  const importedEdges = [];
+  for (const edge of edges) {
+    const relation = stringValue(edge.relation ?? edge.type ?? edge.kind)?.toLowerCase() ?? null;
+    if (relation && NON_DEPENDENCY_RELATIONS.has(relation)) continue;
+    if (relation && !DIRECT_DEPENDENCY_RELATIONS.has(relation) && !INVERSE_RELATIONS.has(relation))
+      continue;
+    const inverse = relation !== null && INVERSE_RELATIONS.has(relation);
+    const sourceEndpoint = edge.from ?? edge.source;
+    const targetEndpoint = edge.to ?? edge.target;
+    const [tail, head] = inverse ? [targetEndpoint, sourceEndpoint] : [sourceEndpoint, targetEndpoint];
+    const from = endpointPath(tail, nodePaths, repositoryRoot);
+    const to = endpointPath(head, nodePaths, repositoryRoot);
+    if (!from || !to || !modulePaths.has(from) || !modulePaths.has(to) || from === to) continue;
+    const symbol = endpointLabel(head, nodeLabels);
+    importedEdges.push({
+      from,
+      to,
+      kind: relation?.includes("dynamic") ? "dynamic_import" : "import",
+      ...symbol ? { symbols: [symbol] } : {}
+    });
+  }
+  const uniqueModules = [...new Map(modules.map((module) => [module.path, module])).values()].sort(
+    (left, right) => left.path.localeCompare(right.path)
+  );
+  const byEndpoints = /* @__PURE__ */ new Map();
+  for (const edge of importedEdges) {
+    const key = `${edge.from}:${edge.to}`;
+    const existing = byEndpoints.get(key);
+    if (!existing) {
+      byEndpoints.set(key, edge);
+      continue;
+    }
+    const symbols = mergeSymbols(existing.symbols, edge.symbols);
+    byEndpoints.set(key, {
+      ...existing.kind === "dynamic_import" && edge.kind === "import" ? edge : existing,
+      ...symbols ? { symbols } : {}
+    });
+  }
+  const uniqueEdges = [...byEndpoints.values()].sort(
+    (left, right) => `${left.from}:${left.to}`.localeCompare(`${right.from}:${right.to}`)
+  );
+  if (uniqueModules.length === 0 || uniqueEdges.length === 0) {
+    throw new Error(`Graphify graph contains no usable file relationships: ${graphPath}`);
+  }
+  for (const module of uniqueModules) {
+    module.imports = uniqueEdges.filter((edge) => edge.from === module.path).map((edge) => edge.to).sort();
+  }
+  return { modules: uniqueModules, edges: uniqueEdges };
+}
+function arrayRecord(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object")) : [];
+}
+function endpointPath(endpoint, nodePaths, repositoryRoot) {
+  if (typeof endpoint === "string")
+    return nodePaths.get(endpoint) ?? normalizeGraphPath(endpoint, repositoryRoot);
+  if (!endpoint || typeof endpoint !== "object") return null;
+  const record = endpoint;
+  const id = stringValue(record.id ?? record.key ?? record.name);
+  return nodePaths.get(id ?? "") ?? graphifyPath(record, repositoryRoot);
+}
+function endpointLabel(endpoint, nodeLabels) {
+  if (typeof endpoint === "string") return nodeLabels.get(endpoint) ?? null;
+  if (!endpoint || typeof endpoint !== "object") return null;
+  const id = stringValue(endpoint.id);
+  return id ? nodeLabels.get(id) ?? null : null;
+}
+function mergeSymbols(left, right) {
+  if (!left && !right) return void 0;
+  return [.../* @__PURE__ */ new Set([...left ?? [], ...right ?? []])].sort().slice(0, MAX_EDGE_SYMBOLS);
+}
+function graphifyPath(node, repositoryRoot) {
+  const source = node.source;
+  const location = node.location;
+  const candidate = stringValue(node.path ?? node.file ?? node.file_path ?? node.source_file) ?? (source && typeof source === "object" ? stringValue(source.path) : null) ?? (location && typeof location === "object" ? stringValue(location.file ?? location.path) : null);
+  return candidate ? normalizeGraphPath(candidate, repositoryRoot) : null;
+}
+function normalizeGraphPath(path, repositoryRoot) {
+  const absolute = isAbsolute(path) ? resolve6(path) : resolve6(repositoryRoot, path);
+  const relativePath = relative4(resolve6(repositoryRoot), absolute).replace(/\\/g, "/");
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith("../")) return null;
+  return relativePath.replace(/^\.\//, "");
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function languageFor2(path) {
+  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";
+var MAX_ANCHORS = 3;
+var MAX_ERROR_SEARCH_FILES = 2e3;
+var JS_FRAME = /\bat\s+(?:[^\s()]+\s+\()?([^\s()]+?):(\d+):\d+\)?/g;
+var PY_FRAME = /\bFile\s+"([^"]+)",\s+line\s+(\d+)/g;
+var PATH_TOKEN = /(?:^|[\s(`'"[])((?:\.{0,2}\/)?[\w@.-]+(?:\/[\w@.-]+)*\.[A-Za-z0-9]+)(?::(\d+))?/g;
+var QUOTED = /"([^"\n]{8,200})"|'([^'\n]{8,200})'|`([^`\n]{8,200})`/g;
+async function extractTaskAnchors(repositoryRoot, task, paths) {
+  const root = resolve7(repositoryRoot);
+  const found = [];
+  const add = (raw, line, kind, at) => {
+    const path = toIndexedPath(root, raw, paths);
+    if (path) found.push({ path, line: line ? Number(line) : null, kind, at });
+  };
+  for (const match of task.matchAll(JS_FRAME)) add(match[1] ?? "", match[2], "stack", match.index);
+  for (const match of task.matchAll(PY_FRAME)) add(match[1] ?? "", match[2], "stack", match.index);
+  for (const match of task.matchAll(PATH_TOKEN)) {
+    add(match[1] ?? "", match[2], match[2] ? "line" : "path", match.index);
+  }
+  const anchors = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { at: _at, ...anchor } of found.sort((left, right) => left.at - right.at)) {
+    if (seen.has(anchor.path)) continue;
+    seen.add(anchor.path);
+    anchors.push(anchor);
+  }
+  if (anchors.length < MAX_ANCHORS) {
+    for (const error of await errorAnchors(root, task, paths)) {
+      if (seen.has(error.path)) continue;
+      seen.add(error.path);
+      anchors.push(error);
+    }
+  }
+  return anchors.slice(0, MAX_ANCHORS);
+}
+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;
+  const normalized = rel.replace(/\\/g, "/");
+  return paths.has(normalized) ? normalized : null;
+}
+async function errorAnchors(root, task, paths) {
+  const quotes = [...task.matchAll(QUOTED)].map((match) => match[1] ?? match[2] ?? match[3] ?? "").filter((text) => text.trim().length >= 8 && !toIndexedPath(root, text, paths));
+  if (quotes.length === 0) return [];
+  const sources = [...paths].filter((path) => !TEST_PATH.test(path) && !NON_SOURCE_PATH.test(path)).sort().slice(0, MAX_ERROR_SEARCH_FILES);
+  const matches = quotes.map(() => []);
+  for (const path of sources) {
+    if (matches.every((found) => found.length > 1)) break;
+    const source = await readBoundedSource(root, path);
+    if (!source) continue;
+    quotes.forEach((quote, i) => {
+      const found = matches[i];
+      if (found.length > 1) return;
+      const index = source.indexOf(quote);
+      if (index >= 0) {
+        found.push({ path, line: source.slice(0, index).split("\n").length, kind: "error" });
+      }
+    });
+  }
+  return matches.flatMap((found) => found.length === 1 ? found : []);
+}
+
+// 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) {
+  try {
+    const absolute = join7(repositoryRoot, path);
+    if ((await stat4(absolute)).size > MAX_EVIDENCE_BYTES) return null;
+    const source = await readFile8(absolute, "utf8");
+    return source.includes("\0") ? null : source;
+  } catch {
+    return null;
+  }
+}
+async function discoverTaskPaths(repositoryRoot, task, manifest, mapSource, options = {}) {
+  const anchors = await extractTaskAnchors(
+    repositoryRoot,
+    task,
+    new Set(Object.keys(manifest.entries))
+  );
+  if (anchors.length === 0)
+    return rankTaskFiles(repositoryRoot, task, manifest, mapSource, options);
+  const anchored = anchors.map((anchor) => anchor.path);
+  const hits = anchors.flatMap(
+    (anchor) => anchor.line === null ? [] : [
+      {
+        path: anchor.path,
+        startLine: anchor.line,
+        endLine: anchor.line,
+        rank: 0,
+        source: "anchor",
+        freshness: "unverified"
+      }
+    ]
+  );
+  const explain = `retrieval: anchors (${anchors.map(
+    (anchor) => `${anchor.kind} ${anchor.path}${anchor.line === null ? "" : `:${anchor.line}`}`
+  ).join(", ")})`;
+  if (anchored.length >= TASK_FILES) return { paths: anchored, hits, explain: [explain] };
+  const ranked = await rankTaskFiles(repositoryRoot, task, manifest, mapSource, options);
+  return {
+    ...ranked.symbols ? { symbols: ranked.symbols } : {},
+    paths: [...anchored, ...ranked.paths.filter((path) => !anchored.includes(path))].slice(
+      0,
+      TASK_FILES
+    ),
+    hits: [...hits, ...ranked.hits.filter((hit) => !anchored.includes(hit.path))],
+    explain: [explain, ...ranked.explain]
+  };
+}
+async function withLlmSummaries(repositoryRoot, manifest) {
+  const entries = Object.values(manifest.entries);
+  try {
+    const { resolveLlmConfig } = await import("./config-S2TULOMK.js");
+    const config = await resolveLlmConfig(repositoryRoot);
+    if (!config.enabled || !config.features.summaries) return entries;
+    const { loadLlmSummaries } = await import("./summaries-TSE44KUQ.js");
+    const summaries = await loadLlmSummaries(repositoryRoot, manifest);
+    if (summaries.size === 0) return entries;
+    return entries.map((entry) => {
+      const summary = summaries.get(entry.path);
+      return summary ? { ...entry, llmText: `${summary.summary} ${Object.values(summary.symbols).join(" ")}` } : entry;
+    });
+  } catch {
+    return entries;
+  }
+}
+async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options) {
+  const entries = await withLlmSummaries(repositoryRoot, manifest);
+  const wantsTests = /\b(tests?|spec)\b/i.test(task);
+  const identifiers = identifierTokens(task).filter((token) => CODE_IDENTIFIER.test(token));
+  if (identifiers.length > 0) {
+    const exact = entries.filter((entry) => wantsTests || !TEST_PATH.test(entry.path)).map((entry) => ({
+      path: entry.path,
+      named: new Set(
+        (entry.symbolTable ?? []).flatMap(
+          (symbol) => 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);
+    if (exact.length > 0) {
+      const evidence2 = new Map(
+        scoreTaskPaths(entries, task).filter((entry) => entry.score > 0).map((entry) => [entry.path, entry.score])
+      );
+      const expansion2 = expandAlongImports(exact, await mapSource, evidence2, task, {
+        allowGraphOnly: true
+      });
+      return {
+        paths: expansion2.paths.slice(0, TASK_FILES),
+        hits: [],
+        explain: [
+          `retrieval: exact-symbol routing (${identifiers.slice(0, 5).join(", ")})`,
+          ...expansion2.explain ? [expansion2.explain] : []
+        ]
+      };
+    }
+  }
+  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 weakKeyword = scored.length - keyword.length;
+  const semantic = options.semantic === false ? {
+    status: "disabled",
+    paths: [],
+    hits: [],
+    reason: "semantic retrieval off",
+    stale: 0,
+    changed: 0
+  } : await import("./zvec-F27AR357.js").then(({ zvecCandidates }) => zvecCandidates(repositoryRoot, task)).catch(
+    () => ({
+      status: "failed",
+      paths: [],
+      hits: [],
+      reason: "zvec-grep failed",
+      stale: 0,
+      changed: 0
+    })
+  );
+  const evidence = new Map(
+    scored.filter((entry) => entry.score > 0).map((entry) => [entry.path, entry.score])
+  );
+  let ranked = keyword;
+  let hits = [];
+  const explain = [];
+  if (semantic.status !== "disabled" && semantic.paths.length === 0) {
+    explain.push(`retrieval: keyword ranking only (${semantic.reason})`);
+  } else if (semantic.status !== "disabled") {
+    const terms = taskTerms(task);
+    const vector = [];
+    const partial = [];
+    let uncorroborated = 0;
+    for (const path of semantic.paths) {
+      if (!wantsTests && TEST_PATH.test(path)) continue;
+      if (keyword.includes(path)) vector.push(path);
+      else if (await hasMatchedPassageEvidence(
+        repositoryRoot,
+        path,
+        semantic.hits,
+        terms,
+        manifest.entries[path]?.symbolTable ?? []
+      )) {
+        const source = await readBoundedSource(repositoryRoot, path) ?? "";
+        if (countTerms(source, terms) >= EVIDENCE_FLOOR.vectorTerms) vector.push(path);
+        else partial.push(path);
+        if (!evidence.has(path)) evidence.set(path, 0);
+      } else uncorroborated++;
+    }
+    ranked = rankEvidenceCandidates(
+      scored.map((entry) => entry.path),
+      keyword,
+      vector,
+      partial
+    );
+    hits = semantic.hits.filter((hit) => vector.includes(hit.path) || partial.includes(hit.path));
+    explain.push(
+      `retrieval: keyword ranking fused with ${semantic.reason}` + (uncorroborated > 0 ? `; ${uncorroborated} uncorroborated vector file(s) dropped` : "")
+    );
+  }
+  let symbols;
+  const reranked = await llmRerank({
+    repositoryRoot,
+    task,
+    manifest,
+    entries,
+    scored,
+    semantic: semantic.paths,
+    ranked,
+    wantsTests,
+    deadlineAt: options.llmDeadlineAt
+  });
+  if (reranked) {
+    explain.push(reranked.explain);
+    ranked = reranked.ranked;
+    symbols = reranked.symbols;
+  }
+  if (!ranked.some((path) => !NON_SOURCE_PATH.test(path))) {
+    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")
+    );
+    return { paths: commands, hits: [], explain };
+  }
+  if (weakKeyword > 0) {
+    explain.push(
+      `abstention: ${weakKeyword} weak keyword candidate(s) below the evidence floor (score < ${EVIDENCE_FLOOR.keywordScore}) dropped`
+    );
+  }
+  const expansion = expandAlongImports(ranked, await mapSource, evidence, task);
+  if (expansion.explain) explain.push(expansion.explain);
+  if (commands.length > 0) {
+    explain.push(`retrieval: CLI command routing (${commands.join(", ")})`);
+  }
+  const paths = [.../* @__PURE__ */ new Set([...commands, ...expansion.paths])];
+  if (paths.length > TASK_FILES) {
+    explain.push(
+      `abstention: ${paths.length - TASK_FILES} lower-ranked candidate(s) beyond the top ${TASK_FILES} dropped`
+    );
+  }
+  return {
+    paths: paths.slice(0, TASK_FILES),
+    hits,
+    explain,
+    ...symbols && Object.keys(symbols).length > 0 ? { symbols } : {}
+  };
+}
+var MIN_RERANK_MS = 200;
+async function llmRerank(input) {
+  let config;
+  try {
+    config = await (await import("./config-S2TULOMK.js")).resolveLlmConfig(input.repositoryRoot);
+  } catch {
+    return null;
+  }
+  if (!config.enabled || !config.features.rerank) return null;
+  const skipped = (reason) => ({
+    ranked: input.ranked,
+    explain: `retrieval: llm rerank skipped (${reason})`,
+    symbols: {}
+  });
+  const usable = (path) => input.wantsTests || !TEST_PATH.test(path);
+  const candidatePaths = [
+    .../* @__PURE__ */ new Set([
+      ...input.ranked,
+      ...input.scored.map((entry) => entry.path).filter(usable).slice(0, 12),
+      ...input.semantic.filter(usable).slice(0, 8)
+    ])
+  ].slice(0, 15);
+  if (candidatePaths.length === 0) return null;
+  const byPath = new Map(input.entries.map((entry) => [entry.path, entry]));
+  const deadlineMs = Math.min(
+    config.timeoutMs,
+    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-Q7MIFNKA.js");
+  const result = await rerankCandidates(
+    input.repositoryRoot,
+    config,
+    input.task,
+    candidatePaths.map((path) => ({
+      path,
+      summary: byPath.get(path)?.llmText || byPath.get(path)?.summary || "",
+      signatures: (input.manifest.entries[path]?.symbolTable ?? []).map((s) => s.signature)
+    })),
+    deadlineMs
+  ).catch(() => ({ ok: false, reason: "invalid" }));
+  if (!result.ok) return skipped(result.reason);
+  const label = `${config.provider} ${config.model}, ${result.cached ? "cached" : `${result.latencyMs} ms`}`;
+  if (result.value.abstain) {
+    return {
+      ranked: [],
+      explain: `retrieval: llm rerank (${label}, model abstained over ${candidatePaths.length} candidates)`,
+      symbols: {}
+    };
+  }
+  const terms = taskTerms(input.task);
+  const picks = [];
+  const symbols = {};
+  let promoted = 0;
+  for (const file of result.value.files) {
+    if (!input.ranked.includes(file.path)) {
+      const source = await readBoundedSource(input.repositoryRoot, file.path) ?? "";
+      const llmText = byPath.get(file.path)?.llmText ?? "";
+      if (Math.max(countTerms(llmText, terms), countTerms(source, terms)) < EVIDENCE_FLOOR.vectorTerms)
+        continue;
+      promoted++;
+    }
+    picks.push(file.path);
+    const known = new Set(
+      (input.manifest.entries[file.path]?.symbolTable ?? []).map((s) => s.name)
+    );
+    const named = file.symbols.filter((name) => known.has(name));
+    if (named.length > 0) symbols[file.path] = named;
+  }
+  return {
+    ranked: [...picks, ...input.ranked.filter((path) => !picks.includes(path))],
+    explain: `retrieval: llm rerank (${label}, ${picks.length} of ${candidatePaths.length} candidates` + (promoted > 0 ? `, ${promoted} promoted` : "") + ")",
+    symbols
+  };
+}
+async function commandFiles(repositoryRoot, task, entries) {
+  const bins = await packageBins(repositoryRoot);
+  if (bins.length === 0) return [];
+  const stems = /* @__PURE__ */ new Set();
+  const pattern = new RegExp(
+    `\\b(?:${bins.map(escapeRegExp).join("|")})\\s+([a-z][\\w-]*)(?:\\s+([a-z][\\w-]*))?`,
+    "gi"
+  );
+  for (const [, command, sub] of task.matchAll(pattern)) {
+    if (!command) continue;
+    stems.add(command.toLowerCase());
+    if (sub) stems.add(`${command}-${sub}`.toLowerCase());
+  }
+  if (stems.size === 0) return [];
+  const matches = entries.map((entry) => entry.path).filter((path) => {
+    if (TEST_PATH.test(path) || NON_SOURCE_PATH.test(path) || !COMMAND_DIR.test(path)) {
+      return false;
+    }
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    return stems.has(name.slice(0, name.lastIndexOf(".")).toLowerCase());
+  });
+  return matches.sort((left, right) => right.length - left.length || left.localeCompare(right)).slice(0, TASK_FILES);
+}
+var COMMAND_DIR = /(^|\/)(cli|cmd|commands?)\//;
+async function packageBins(repositoryRoot) {
+  try {
+    const manifest = JSON.parse(await readFile8(join7(repositoryRoot, "package.json"), "utf8"));
+    if (typeof manifest.bin === "string" && typeof manifest.name === "string") {
+      return [manifest.name.slice(manifest.name.lastIndexOf("/") + 1)];
+    }
+    if (manifest.bin && typeof manifest.bin === "object") return Object.keys(manifest.bin);
+  } catch {
+  }
+  return [];
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var MULTI_FILE_TASK = /\b(trace|follow|flows?|through|across|between|end[- ]to[- ]end|pipeline)\b|\bfrom\b.+\bto\b/i;
+function expandAlongImports(ranked, map, evidence, task, options = {}) {
+  if (!MULTI_FILE_TASK.test(task)) return { paths: ranked, explain: null };
+  const seeds = ranked.slice(0, EXPANSION.seeds);
+  const links = /* @__PURE__ */ new Map();
+  const graphOnly = /* @__PURE__ */ new Map();
+  for (const edge of map.edges) {
+    for (const [seed, other] of [
+      [edge.from, edge.to],
+      [edge.to, edge.from]
+    ]) {
+      if (!seeds.includes(seed) || seeds.includes(other)) continue;
+      if (!evidence.has(other)) {
+        if (!options.allowGraphOnly || edge.from !== seed || TEST_PATH.test(other) || NON_SOURCE_PATH.test(other))
+          continue;
+        graphOnly.set(
+          other,
+          Math.max(
+            graphOnly.get(other) ?? 0,
+            edge.symbols?.length ? 2 : edge.kind === "import" ? 1 : 0
+          )
+        );
+      }
+      links.set(other, (links.get(other) ?? /* @__PURE__ */ new Set()).add(seed));
+    }
+  }
+  const scoreOf = (path) => evidence.get(path) ?? 0;
+  const added = [...links].sort(
+    ([left, a], [right, b]) => b.size - a.size || scoreOf(right) - scoreOf(left) || (graphOnly.get(right) ?? 0) - (graphOnly.get(left) ?? 0) || left.localeCompare(right)
+  ).slice(0, EXPANSION.files).map(([path]) => path);
+  if (added.length === 0) return { paths: ranked, explain: null };
+  const paths = ranked.filter((path) => !added.includes(path));
+  for (const path of added) {
+    const credited = scoreOf(path) + 1;
+    const at = paths.findIndex(
+      (other, index) => index >= seeds.length && scoreOf(other) < credited
+    );
+    paths.splice(at < 0 ? paths.length : at, 0, path);
+  }
+  return {
+    paths,
+    explain: `expansion: ${added.length} import neighbour(s) of the top ${seeds.length} target(s) ranked with the import edge credited as a task term (${added.join(", ")}; multi-file task wording)` + (added.some((path) => graphOnly.has(path)) ? "; graph-only import bridge" : "")
+  };
+}
+function rankEvidenceCandidates(lexical, admittedKeywords, vector, partial) {
+  const admitted = /* @__PURE__ */ new Set([...admittedKeywords, ...vector]);
+  const established = fuseRankings([lexical, vector]).filter((path) => admitted.has(path));
+  return [.../* @__PURE__ */ new Set([...established, ...partial])];
+}
+function fuseRankings(lists, k = 60) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    list.forEach((path, index) => {
+      scores.set(path, (scores.get(path) ?? 0) + 1 / (k + index + 1));
+    });
+  }
+  return [...scores].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])).map(([path]) => path);
+}
+var TASK_STOPWORDS = new Set(
+  "the and for are was were how does did which where when what why who with without from into onto that this these those there their them then than have has had not but can could should would will its it's our your you all any each some such only also just like make makes made use uses used get gets set sets new old way".split(
+    " "
+  )
+);
+var EVIDENCE_FLOOR = { keywordScore: 1.5, vectorTerms: 2 };
+async function hasMatchedPassageEvidence(repositoryRoot, path, hits, terms, symbols) {
+  const source = await readBoundedSource(repositoryRoot, path);
+  if (source === null) return false;
+  if (countTerms(source, terms) >= EVIDENCE_FLOOR.vectorTerms) return true;
+  const lines = source.split(/\r?\n/);
+  return hits.some((hit) => {
+    if (hit.path !== path || hit.endLine > lines.length) return false;
+    const passage = lines.slice(hit.startLine - 1, hit.endLine);
+    const matched = countTerms(passage.join(" "), terms);
+    return matched >= EVIDENCE_FLOOR.vectorTerms || matched >= 1 && terms.length === 2 && hit.rank <= 3 && symbols.some(
+      (symbol) => hit.startLine <= symbol.endLine && hit.endLine >= symbol.startLine
+    );
+  });
+}
+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;
+function scoreTaskPaths(entries, task) {
+  const terms = taskTerms(task);
+  if (terms.length === 0) return [];
+  const wantsTests = terms.some((term) => term === "test" || term === "spec");
+  const candidates = entries.flatMap((entry) => {
+    if (TEST_PATH.test(entry.path) && !wantsTests) return [];
+    const words = new Set(
+      splitWords(
+        `${entry.path} ${entry.summary} ${entry.symbols.join(" ")} ${entry.symbolTable?.map((symbol) => symbol.name).join(" ") ?? ""}`
+      )
+    );
+    const llmWords = new Set(entry.llmText ? splitWords(entry.llmText) : []);
+    const fileWords = new Set(splitWords(entry.path.slice(entry.path.lastIndexOf("/") + 1)));
+    return [{ path: entry.path, words, llmWords, fileWords }];
+  });
+  const idf = new Map(
+    terms.map((term) => {
+      const df = candidates.filter(
+        (candidate) => candidate.words.has(term) || candidate.llmWords.has(term)
+      ).length;
+      return [term, Math.log((candidates.length + 1) / (df + 1)) + 1];
+    })
+  );
+  return candidates.flatMap(({ path, words, llmWords, fileWords }) => {
+    let score = 0;
+    let weighted = 0;
+    for (const term of terms) {
+      if (words.has(term)) {
+        const points = fileWords.has(term) ? 1.5 : 1;
+        score += points;
+        weighted += points * (idf.get(term) ?? 1);
+      } else if (llmWords.has(term)) {
+        weighted += 0.5 * (idf.get(term) ?? 1);
+      }
+    }
+    if (weighted === 0) return [];
+    if (NON_SOURCE_PATH.test(path)) {
+      score *= 0.5;
+      weighted *= 0.5;
+    }
+    return [{ path, score, order: weighted }];
+  }).sort(
+    (left, right) => right.order - left.order || right.score - left.score || left.path.localeCompare(right.path)
+  );
+}
+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
+  );
+}
+function taskTerms(task) {
+  return [...new Set(splitWords(task).filter((term) => !TASK_STOPWORDS.has(term)))];
+}
+function countTerms(text, terms) {
+  if (terms.length === 0) return 0;
+  const words = new Set(splitWords(text));
+  return terms.filter((term) => words.has(term)).length;
+}
+var CODE_IDENTIFIER = /[a-z0-9][A-Z]|[_$.]/;
+function identifierTokens(task) {
+  const tokens = task.match(/[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*/g) ?? [];
+  return [...new Set(tokens.flatMap((token) => [token, ...token.split(".")]))];
+}
+function namedSegments(name, tokens) {
+  return name.split(".").filter((segment) => tokens.includes(segment)).length;
+}
+async function loadProjectArchitectureMap(repositoryRoot, manifestSource) {
+  const [config, manifest] = await Promise.all([readConfigFile(repositoryRoot), manifestSource]);
+  const builtIn = (await loadArchitectureMap(repositoryRoot, manifest)).map;
+  if (config.graphify?.enabled && await graphifyGraphExists(repositoryRoot, config.graphify.graphPath)) {
+    try {
+      const graphPath = join7(
+        repositoryRoot,
+        config.graphify.graphPath ?? "graphify-out/graph.json"
+      );
+      const [graph, graphFile, sourceHashes2] = await Promise.all([
+        loadGraphifyMap(graphPath, repositoryRoot),
+        stat4(graphPath),
+        readGraphSourceSnapshot(graphPath)
+      ]);
+      const livePaths = new Set(
+        (await Promise.all(
+          graph.modules.map(async (module) => {
+            try {
+              const absolute = await realpath(join7(repositoryRoot, module.path));
+              const inside = relative6(await realpath(repositoryRoot), absolute);
+              if (inside.startsWith("..") || isAbsolute3(inside)) return null;
+              const source = await stat4(absolute);
+              const fresh = sourceHashes2 === null ? source.mtimeMs <= graphFile.mtimeMs : sourceHashes2[module.path] !== void 0 && sourceHashes2[module.path] === manifest.entries[module.path]?.hash;
+              return source.isFile() && fresh ? module.path : null;
+            } catch {
+              return null;
+            }
+          })
+        )).filter((path) => path !== null)
+      );
+      const modules = new Map(builtIn.modules.map((module) => [module.path, module]));
+      for (const module of graph.modules) {
+        if (livePaths.has(module.path) && !modules.has(module.path))
+          modules.set(module.path, module);
+      }
+      const edges = new Map(builtIn.edges.map((edge) => [`${edge.from}\0${edge.to}`, edge]));
+      let freshGraphEdges = 0;
+      for (const edge of graph.edges) {
+        if (!livePaths.has(edge.from) || !livePaths.has(edge.to)) continue;
+        freshGraphEdges++;
+        const key = `${edge.from}\0${edge.to}`;
+        const scanned = edges.get(key);
+        edges.set(
+          key,
+          scanned ? { ...scanned, ...edge.symbols ? { symbols: edge.symbols } : {} } : edge
+        );
+      }
+      const mergedEdges = [...edges.values()].sort(
+        (left, right) => `${left.from}:${left.to}`.localeCompare(`${right.from}:${right.to}`)
+      );
+      const importsByPath = /* @__PURE__ */ new Map();
+      for (const edge of mergedEdges) {
+        const imports = importsByPath.get(edge.from) ?? [];
+        imports.push(edge.to);
+        importsByPath.set(edge.from, imports);
+      }
+      return {
+        modules: [...modules.values()].map((module) => ({ ...module, imports: importsByPath.get(module.path) ?? [] })).sort((left, right) => left.path.localeCompare(right.path)),
+        edges: mergedEdges,
+        source: freshGraphEdges > 0 ? "graphify+imports" : "imports"
+      };
+    } catch {
+    }
+  }
+  return { ...builtIn, source: "imports" };
+}
+
+export {
+  buildArchitectureMap,
+  queryMap,
+  neighbours,
+  loadArchitectureMap,
+  indexRepository,
+  loadFreshIndex,
+  setupGraphify,
+  generateGraphifyGraph,
+  loadGraphifyMap,
+  TASK_PATH_LIMIT,
+  readBoundedSource,
+  discoverTaskPaths,
+  TEST_PATH,
+  NON_SOURCE_PATH,
+  taskTerms,
+  countTerms,
+  identifierTokens,
+  namedSegments,
+  loadProjectArchitectureMap
+};
+//# sourceMappingURL=chunk-IBMJYIEP.js.map