@orquentra/codebuddy 2.9.0 → 2.15.0

package/dist/chunk-ITQO632W.js

@@ -1,673 +0,0 @@
-import {
-  extractPythonImports,
-  extractSymbolTable,
-  supportsSymbols
-} from "./chunk-Y7D7PUBE.js";
-import {
-  assertNoSymlinkBetween,
-  writeAtomic
-} 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", ".py"]);
-var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
-  ".git",
-  "node_modules",
-  "dist",
-  "build",
-  "coverage",
-  ".codebuddy",
-  // Python virtualenvs and caches would otherwise map site-packages.
-  ".venv",
-  "venv",
-  ".tox",
-  "__pycache__"
-]);
-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 resolvedImports = moduleImports(root, from, source, fileSet);
-    edges.push(...resolvedImports.map(({ to, kind }) => ({ from, to, kind })));
-    modules.push({
-      path: from,
-      language: moduleLanguage(from),
-      imports: [...new Set(resolvedImports.map(({ to }) => to))].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 resolvedImports = moduleImports(root, path, source, fileSet);
-    edges.push(...resolvedImports.map(({ to, kind }) => ({ from: path, to, kind })));
-    modules.push({
-      path,
-      language: moduleLanguage(path),
-      imports: [...new Set(resolvedImports.map(({ to }) => to))].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 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 ");
-  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 = 3;
-
-// src/indexer/store.ts
-var symbolSpanSchema = z.object({
-  name: z.string(),
-  kind: z.enum(["function", "method", "class", "interface", "type", "enum", "const", "heading"]),
-  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", ".py"]);
-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, sep } 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",
-  ".rst": "rst",
-  ".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) : language === "py" ? pythonPublicNames(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 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(", ")}`;
-  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",
-  ".venv",
-  "venv",
-  "__pycache__"
-]);
-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",
-    "-z",
-    "--cached",
-    "--others",
-    "--exclude-standard"
-  ]);
-  if (result.code !== 0) return null;
-  return result.stdout.split("\0").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.setEncoding("utf8");
-    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 (sep === "\\" ? path.replace(/\\/g, "/") : path).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, path) : [];
-      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]])
-  );
-}
-
-export {
-  buildArchitectureMap,
-  queryMap,
-  neighbours,
-  loadArchitectureMap,
-  indexRepository,
-  loadFreshIndex
-};
-//# sourceMappingURL=chunk-ITQO632W.js.map