@mutmutco/cli 3.139.0 → 3.139.2

package/dist/repo-index-v4.cjs

@@ -0,0 +1,684 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/repo-index-v4/index.ts
+var index_exports = {};
+__export(index_exports, {
+  REPO_INDEX_V4_SCHEMA: () => REPO_INDEX_V4_SCHEMA,
+  V4_GRAPH_MAX_EDGES: () => V4_GRAPH_MAX_EDGES,
+  V4_GRAPH_MAX_EDGES_PER_FILE: () => V4_GRAPH_MAX_EDGES_PER_FILE,
+  V4_MAX_ARTIFACT_BYTES: () => V4_MAX_ARTIFACT_BYTES,
+  V4_MAX_CHUNKS: () => V4_MAX_CHUNKS,
+  V4_STAGE_MAX_BODY_BYTES: () => V4_STAGE_MAX_BODY_BYTES,
+  V4_STAGE_MAX_RECORDS: () => V4_STAGE_MAX_RECORDS,
+  buildGraphEdges: () => buildGraphEdges,
+  buildRepoIndexV4: () => buildRepoIndexV4,
+  buildStructuralChunks: () => buildStructuralChunks,
+  encodedStageBytes: () => encodedStageBytes,
+  graphEdgesForSource: () => graphEdgesForSource,
+  languageForPath: () => languageForPath,
+  repoIndexV4StorePath: () => repoIndexV4StorePath,
+  shardRepoIndexV4: () => shardRepoIndexV4,
+  structuralChunksForSource: () => structuralChunksForSource
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/repo-index-v4/chunks.ts
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs2 = require("node:fs");
+var import_node_path3 = require("node:path");
+
+// src/doc-refs-core.ts
+var import_node_child_process = require("node:child_process");
+var CHECK_IGNORE_MAX_BUFFER = 32 * 1024 * 1024;
+function defaultIsIgnored(root, relPaths, exec = import_node_child_process.execFileSync) {
+  const inRepo = relPaths.filter((p) => !p.startsWith(".."));
+  if (inRepo.length === 0) return /* @__PURE__ */ new Set();
+  try {
+    const out = exec("git", ["check-ignore", "--stdin"], {
+      cwd: root,
+      input: inRepo.join("\n"),
+      encoding: "utf8",
+      maxBuffer: CHECK_IGNORE_MAX_BUFFER
+    });
+    return new Set(out.split(/\r?\n/).filter(Boolean));
+  } catch (error) {
+    if (error?.status === 1) return /* @__PURE__ */ new Set();
+    if (error?.status === 128) return /* @__PURE__ */ new Set();
+    if (error?.code === "ENOENT") return /* @__PURE__ */ new Set();
+    if (error?.code === "ENOBUFS") {
+      throw new Error(
+        `git check-ignore produced more than ${CHECK_IGNORE_MAX_BUFFER} bytes for ${inRepo.length} path(s) \u2014 the ignore set cannot be read, and treating it as empty would index gitignored paths (#4062)`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/repo-index.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_path2 = require("node:path");
+
+// ../infra/repo-index-path-policy.mjs
+var HARD_DENY = Object.freeze([
+  /(^|\/)\.env(\.|$)/i,
+  /(^|\/)\.env\./i,
+  /credentials/i,
+  /secrets?\.json$/i,
+  /\.pem$/i,
+  /\.p12$/i,
+  /\.key$/i,
+  /(^|\/)id_rsa/i,
+  /(^|\/)id_ed25519/i,
+  /\.keystore$/i
+]);
+function isHardDeniedRepoIndexPath(value) {
+  return typeof value !== "string" || HARD_DENY.some((pattern) => pattern.test(value));
+}
+function isSafeRepoIndexPath(value) {
+  if (typeof value !== "string" || !value || value.length > 1024) return false;
+  if (value.startsWith("/") || value.includes("\\") || /[\u0000-\u001f\u007f]/u.test(value)) return false;
+  const segments = value.split("/");
+  if (segments.some((segment) => !segment || segment === "." || segment === "..")) return false;
+  return !isHardDeniedRepoIndexPath(value);
+}
+
+// src/repo-runtime-state.ts
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var RUNTIME_DIR = "mmi-runtime";
+function hashPath(path) {
+  return (0, import_node_crypto.createHash)("sha256").update((0, import_node_path.resolve)(path)).digest("hex").slice(0, 16);
+}
+function resolveGitDir(cwd) {
+  const dotGit = (0, import_node_path.join)(cwd, ".git");
+  try {
+    const st = (0, import_node_fs.statSync)(dotGit);
+    if (st.isDirectory()) return dotGit;
+    if (!st.isFile()) return void 0;
+  } catch {
+    return void 0;
+  }
+  try {
+    const raw = (0, import_node_fs.readFileSync)(dotGit, "utf8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(raw);
+    if (!match) return void 0;
+    const gitdir = match[1].trim();
+    return (0, import_node_path.isAbsolute)(gitdir) ? gitdir : (0, import_node_path.resolve)(cwd, gitdir);
+  } catch {
+    return void 0;
+  }
+}
+function repoRuntimeStatePath(cwd, ...parts) {
+  const gitDir = resolveGitDir(cwd);
+  if (gitDir && (0, import_node_fs.existsSync)(gitDir)) return (0, import_node_path.join)(gitDir, RUNTIME_DIR, ...parts);
+  return (0, import_node_path.join)((0, import_node_os.tmpdir)(), "mmi-cli", hashPath(cwd), ...parts);
+}
+
+// src/repo-index.ts
+var INDEXABLE_EXT = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".md",
+  ".yml",
+  ".yaml",
+  ".json",
+  ".toml",
+  ".sh",
+  ".ps1",
+  ".css",
+  ".html"
+]);
+function isHardDeniedPath(relPosix) {
+  return isHardDeniedRepoIndexPath(relPosix);
+}
+function isIndexablePath(relPosix) {
+  if (!isSafeRepoIndexPath(relPosix)) return false;
+  if (relPosix.startsWith(".git/")) return false;
+  if (relPosix.includes("node_modules/")) return false;
+  if (relPosix.includes("dist/")) return false;
+  const dot = relPosix.lastIndexOf(".");
+  if (dot < 0) return false;
+  return INDEXABLE_EXT.has(relPosix.slice(dot).toLowerCase());
+}
+function toPosix(p) {
+  return p.split(import_node_path2.sep).join("/");
+}
+function listCandidatePaths(cwd, exec = import_node_child_process2.execFileSync) {
+  try {
+    const out = exec("git", ["ls-files", "-z", "-c", "-o", "--exclude-standard"], {
+      cwd,
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024
+    });
+    return out.split("\0").filter(Boolean).map(toPosix);
+  } catch {
+    return [];
+  }
+}
+
+// src/repo-index-v4/language.ts
+var LANGUAGE_BY_EXTENSION = {
+  ".ts": { name: "typescript", parserName: "typescript" },
+  ".tsx": { name: "tsx", parserName: "tsx" },
+  ".js": { name: "javascript", parserName: "javascript" },
+  ".jsx": { name: "jsx", parserName: "javascript" },
+  ".py": { name: "python", parserName: "python" },
+  ".go": { name: "go", parserName: "go" },
+  ".rs": { name: "rust", parserName: "rust" },
+  ".java": { name: "java", parserName: "java" },
+  ".kt": { name: "kotlin", parserName: "kotlin" }
+};
+function languageForPath(path) {
+  const dot = path.lastIndexOf(".");
+  return dot < 0 ? void 0 : LANGUAGE_BY_EXTENSION[path.slice(dot).toLowerCase()];
+}
+
+// src/repo-index-v4/chunks.ts
+var BLURB_CAP = 200;
+var SIGNATURE_CAP = 300;
+var STRUCTURAL_KINDS = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function_definition",
+  "function_item",
+  "function",
+  "method_declaration",
+  "method_definition",
+  "method",
+  "class_declaration",
+  "class_definition",
+  "class",
+  "interface_declaration",
+  "interface_definition",
+  "enum_declaration",
+  "enum_definition",
+  "enum_item",
+  "struct_item",
+  "struct_specifier",
+  "trait_item",
+  "impl_item",
+  "type_declaration",
+  "type_alias_declaration",
+  "object_declaration"
+]);
+var parserRuntime;
+var grammarCache = /* @__PURE__ */ new Map();
+async function parserFor(language) {
+  const api = await (parserRuntime ??= import("web-tree-sitter"));
+  await api.Parser.init();
+  let grammar = grammarCache.get(language);
+  if (!grammar) {
+    grammar = import("tree-sitter-wasm").then(({ getWasmPath }) => api.Language.load(getWasmPath(language)));
+    grammarCache.set(language, grammar);
+  }
+  const parser = new api.Parser();
+  parser.setLanguage(await grammar);
+  return parser;
+}
+function sha256(value) {
+  return (0, import_node_crypto2.createHash)("sha256").update(value).digest("hex");
+}
+function pointerId(path, kind, contentHash, start, end, symbol) {
+  return sha256(["repo-index-v4", path, kind, contentHash, String(start), String(end), symbol ?? ""].join("\0"));
+}
+function lineAt(bytes, offset) {
+  let line = 1;
+  for (let i = 0; i < Math.min(offset, bytes.length); i++) if (bytes[i] === 10) line++;
+  return line;
+}
+function lineRange(bytes, start, end) {
+  const startLine = lineAt(bytes, start);
+  const endLine = lineAt(bytes, Math.max(start, end - 1));
+  return { startLine, endLine: Math.max(startLine, endLine) };
+}
+function boundedLine(value, cap) {
+  const line = value?.replace(/\r?\n/g, " ").replace(/\s+/g, " ").trim();
+  return line ? line.slice(0, cap) : void 0;
+}
+function citation(repo, commit, path, bytes, start, end, symbol) {
+  return { repo, commit, path, ...lineRange(bytes, start, end), ...symbol ? { symbol } : {} };
+}
+function doclineBefore(bytes, start) {
+  const prior2 = Buffer.from(bytes.subarray(0, start)).toString("utf8").split(/\r?\n/);
+  for (let i = prior2.length - 1; i >= 0; i--) {
+    const line = prior2[i].trim();
+    if (!line) continue;
+    const text = line.replace(/^(?:\/\/\/|\/\/|#|\/\*\*?|\*)\s?/, "").replace(/\*\/$/, "").trim();
+    return text === line ? void 0 : boundedLine(text, BLURB_CAP);
+  }
+  return void 0;
+}
+function fileChunk(repo, commit, path, source, language) {
+  const bytes = Buffer.from(source, "utf8");
+  const contentHash = sha256(bytes);
+  return {
+    id: pointerId(path, "file", contentHash, 0, bytes.length),
+    path,
+    kind: "file",
+    contentHash,
+    ...language ? { language } : {},
+    citations: [citation(repo, commit, path, bytes, 0, bytes.length)]
+  };
+}
+function structuralNode(node) {
+  if (STRUCTURAL_KINDS.has(node.type)) return node;
+  return node.namedChildren.find((child) => STRUCTURAL_KINDS.has(child.type));
+}
+function structureChunk(repo, commit, path, sourceBytes, language, owner) {
+  const item = structuralNode(owner);
+  if (!item) return void 0;
+  const start = owner.startIndex;
+  const end = owner.endIndex;
+  if (start < 0 || end < start || end > sourceBytes.length) return void 0;
+  const contentHash = sha256(sourceBytes.subarray(start, end));
+  const name = boundedLine(item.childForFieldName("name")?.text, SIGNATURE_CAP);
+  const bodyStart = item.childForFieldName("body")?.startIndex ?? end;
+  const symbol = boundedLine(Buffer.from(sourceBytes.subarray(start, bodyStart)).toString("utf8"), SIGNATURE_CAP) ?? name;
+  return {
+    id: pointerId(path, "symbol", contentHash, start, end, symbol),
+    path,
+    kind: "symbol",
+    contentHash,
+    language,
+    ...symbol ? { symbol } : {},
+    ...doclineBefore(sourceBytes, start) ? { blurb: doclineBefore(sourceBytes, start) } : {},
+    citations: [citation(repo, commit, path, sourceBytes, start, end, name)]
+  };
+}
+async function structuralChunksForSource(repo, commit, path, source) {
+  const language = languageForPath(path);
+  if (!language) return [fileChunk(repo, commit, path, source)];
+  let parser;
+  let tree;
+  try {
+    parser = await parserFor(language.parserName);
+    tree = parser.parse(source) ?? void 0;
+    if (!tree || tree.rootNode.hasError) return [fileChunk(repo, commit, path, source, language.name)];
+    const bytes = Buffer.from(source, "utf8");
+    const chunks = tree.rootNode.namedChildren.map((node) => structureChunk(repo, commit, path, bytes, language.name, node)).filter((chunk) => chunk !== void 0).sort((a, b) => a.citations[0].startLine - b.citations[0].startLine || a.id.localeCompare(b.id));
+    return chunks.length ? chunks : [fileChunk(repo, commit, path, source, language.name)];
+  } catch {
+    return [fileChunk(repo, commit, path, source, language.name)];
+  } finally {
+    tree?.delete();
+    parser?.delete();
+  }
+}
+async function buildStructuralChunks(cwd, repo, commit) {
+  const candidates = listCandidatePaths(cwd).filter(isIndexablePath).sort((a, b) => a.localeCompare(b));
+  const ignored = defaultIsIgnored(cwd, candidates);
+  const chunks = [];
+  for (const path of candidates) {
+    if (ignored.has(path) || isHardDeniedPath(path)) continue;
+    const absolute = (0, import_node_path3.join)(cwd, ...path.split("/"));
+    if (!(0, import_node_fs2.existsSync)(absolute)) continue;
+    let source;
+    try {
+      source = (0, import_node_fs2.readFileSync)(absolute, "utf8");
+    } catch {
+      continue;
+    }
+    chunks.push(...await structuralChunksForSource(repo, commit, path, source));
+  }
+  return chunks.sort((a, b) => a.path.localeCompare(b.path) || a.citations[0].startLine - b.citations[0].startLine || a.id.localeCompare(b.id));
+}
+
+// src/repo-index-v4/types.ts
+var REPO_INDEX_V4_SCHEMA = 4;
+
+// src/repo-index-v4/builder.ts
+var import_node_crypto3 = require("node:crypto");
+var import_node_child_process3 = require("node:child_process");
+var import_node_fs3 = require("node:fs");
+var import_node_path4 = require("node:path");
+var V4_MAX_CHUNKS = 1e4;
+var V4_MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
+var V4_EMBED_BATCH = 32;
+var COMMIT = /^[a-f0-9]{40}$/;
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(record[k])}`).join(",")}}`;
+}
+function sha2562(value) {
+  return (0, import_node_crypto3.createHash)("sha256").update(canonicalJson(value)).digest("hex");
+}
+function statePath(cwd) {
+  return repoRuntimeStatePath(cwd, "repo-index", "v4.json");
+}
+function git(cwd, args) {
+  return String((0, import_node_child_process3.execFileSync)("git", args, { cwd, encoding: "utf8", windowsHide: true, stdio: ["ignore", "pipe", "ignore"] })).trim();
+}
+function gitInfo(cwd) {
+  const commit = git(cwd, ["rev-parse", "HEAD"]).toLowerCase();
+  if (!COMMIT.test(commit)) throw new Error("repo-index v4 requires an exact git HEAD commit");
+  let defaultBranch = "main";
+  try {
+    defaultBranch = git(cwd, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]).replace(/^origin\//, "") || defaultBranch;
+  } catch {
+  }
+  let createdAt;
+  try {
+    createdAt = new Date(git(cwd, ["show", "-s", "--format=%cI", "HEAD"])).toISOString();
+  } catch {
+    createdAt = "1970-01-01T00:00:00.000Z";
+  }
+  return { commit, defaultBranch, createdAt };
+}
+function prior(cwd) {
+  try {
+    const p = JSON.parse((0, import_node_fs3.readFileSync)(statePath(cwd), "utf8"));
+    return p?.schemaVersion === 4 && p?.manifest?.immutable === true ? p : null;
+  } catch {
+    return null;
+  }
+}
+function tombstone(repo, commit, path, createdAt) {
+  const base = { repo, commit, path, reason: "deleted", createdAt };
+  return { ...base, id: sha2562(base) };
+}
+function embeddingInput(cwd, chunk) {
+  const c = chunk.citations[0];
+  if (!c) return `${chunk.path}
+${chunk.symbol ?? ""}
+${chunk.blurb ?? ""}`;
+  try {
+    const lines = (0, import_node_fs3.readFileSync)((0, import_node_path4.join)(cwd, ...chunk.path.split("/")), "utf8").split(/\r?\n/);
+    const body = lines.slice(Math.max(0, (c.startLine ?? 1) - 1), Math.min(lines.length, c.endLine ?? lines.length)).join("\n");
+    return body.slice(0, 1e5);
+  } catch {
+    return `${chunk.path}
+${chunk.symbol ?? ""}
+${chunk.blurb ?? ""}`;
+  }
+}
+function runEmbedder(cwd, chunks, modelDirectory, createdAt) {
+  if (!chunks.length) return { embeddings: [] };
+  const runner = (0, import_node_path4.join)(cwd, "repo-indexer", "src", "batch.mjs");
+  const fallback = (0, import_node_path4.join)(process.cwd(), "repo-indexer", "src", "batch.mjs");
+  const file = (0, import_node_fs3.existsSync)(runner) ? runner : fallback;
+  if (!(0, import_node_fs3.existsSync)(file)) return { embeddings: [], reason: "embeddings-unavailable" };
+  const request = { texts: chunks.map((chunk) => ({ id: chunk.id, text: embeddingInput(cwd, chunk) })), maxBatch: V4_EMBED_BATCH };
+  const env = { ...process.env, ...modelDirectory ? { MMI_REPO_INDEXER_MODEL_DIR: modelDirectory } : {} };
+  const result = (0, import_node_child_process3.spawnSync)(process.execPath, [file], { input: JSON.stringify(request), encoding: "utf8", windowsHide: true, timeout: 3e5, maxBuffer: V4_MAX_ARTIFACT_BYTES, env });
+  if (result.error || result.status !== 0) return { embeddings: [], reason: "embeddings-unavailable" };
+  try {
+    const response = JSON.parse(result.stdout);
+    if (!response.ok || !response.provenance || !Array.isArray(response.embeddings)) return { embeddings: [], reason: "embeddings-unavailable" };
+    const provenance = {
+      provider: response.provenance.provider,
+      model: response.provenance.model,
+      modelDigest: response.provenance.modelDigest,
+      dimensions: response.provenance.dimensions,
+      input: response.provenance.input,
+      createdAt
+    };
+    const byId = new Map(response.embeddings.map((e) => [e.id, e.vector]));
+    const embeddings = chunks.map((chunk) => ({ chunkId: chunk.id, vector: byId.get(chunk.id), provenance })).filter((e) => Array.isArray(e.vector) && e.vector.length === provenance.dimensions && e.vector.every(Number.isFinite));
+    return embeddings.length === chunks.length ? { embeddings } : { embeddings: [], reason: "partial-coverage" };
+  } catch {
+    return { embeddings: [], reason: "embeddings-unavailable" };
+  }
+}
+async function buildRepoIndexV4(cwd, repo, opts = {}) {
+  const { commit, defaultBranch, createdAt } = gitInfo(cwd);
+  const chunks = await buildStructuralChunks(cwd, repo, commit);
+  if (chunks.length > V4_MAX_CHUNKS) throw new Error(`repo-index v4 exceeds ${V4_MAX_CHUNKS} chunk ceiling`);
+  const old = prior(cwd);
+  const currentPaths = new Set(chunks.map((c) => c.path));
+  const tombstonePaths = [
+    ...(old?.manifest.tombstones ?? []).map((t) => t.path),
+    ...(old?.manifest.chunks ?? []).map((c) => c.path).filter((path2) => !currentPaths.has(path2))
+  ];
+  const tombstones = [...new Set(tombstonePaths)].sort().map((path2) => tombstone(repo, commit, path2, createdAt));
+  const oldChunkHashById = new Map((old?.manifest.chunks ?? []).map((c) => [c.id, c.contentHash]));
+  const reusableEmbedding = (embedding) => {
+    const norm = Math.hypot(...embedding.vector);
+    return embedding.vector.length === 384 && embedding.vector.every(Number.isFinite) && norm >= 0.98 && norm <= 1.02 && embedding.provenance.provider === "local" && embedding.provenance.modelDigest === "828e1496d7fabb79cfa4dcd84fa38625c0d3d21da474a00f08db0f559940cf35" && embedding.provenance.dimensions === 384 && embedding.provenance.input === "pointer-safe-structural-chunk";
+  };
+  const oldEmbeddingByHash = new Map((old?.manifest.embeddings ?? []).filter(reusableEmbedding).map((e) => [oldChunkHashById.get(e.chunkId), e]));
+  const reusable = chunks.flatMap((chunk) => {
+    const priorEmbedding = oldEmbeddingByHash.get(chunk.contentHash);
+    return priorEmbedding ? [{ ...priorEmbedding, chunkId: chunk.id }] : [];
+  });
+  const reusableIds = new Set(reusable.map((e) => e.chunkId));
+  const missing = chunks.filter((chunk) => !reusableIds.has(chunk.id));
+  const generated = missing.length === 0 ? { embeddings: [] } : opts.embed === false ? { embeddings: [], reason: "embeddings-unavailable" } : runEmbedder(cwd, missing, opts.modelDirectory, createdAt);
+  const embeddings = [...reusable, ...generated.embeddings].sort((a, b) => a.chunkId.localeCompare(b.chunkId));
+  const chunksDigest = sha2562(chunks);
+  const embeddingsDigest = sha2562(embeddings);
+  const artifact = (kind, digest) => {
+    const identity2 = { repo, commit, immutable: true, kind, uri: `s3://repo-index/v4/${repo}/${commit}/${digest}.${kind}.json`, sha256: digest, createdAt };
+    return { ...identity2, id: sha2562(identity2) };
+  };
+  const artifacts = [artifact("chunks", chunksDigest), artifact("embeddings", embeddingsDigest)];
+  const grammarProvenance = {
+    runtime: { name: "web-tree-sitter", version: "0.26.12", license: "MIT" },
+    grammarPack: { name: "tree-sitter-wasm", version: "1.1.4", license: "MIT", digest: "f3089ddf2c9615a423783b645c4dfb23ccda30807bbd059746f583952357c489" },
+    languages: ["go", "java", "javascript", "jsx", "kotlin", "python", "rust", "tsx", "typescript"]
+  };
+  const rrf = { algorithm: "reciprocal-rank-fusion", k: 60, lexicalWeight: 1, semanticWeight: 1 };
+  const identity = { repo, commit, defaultBranch, immutable: true, createdAt, grammarProvenance, chunks, embeddings, artifacts, tombstones, rrf };
+  const manifest = { ...identity, id: sha2562(identity) };
+  const complete = embeddings.length === chunks.length;
+  const envelope = {
+    schemaVersion: 4,
+    manifest,
+    status: { repo, commit, state: complete ? "ready" : "degraded", updatedAt: createdAt, ...!complete ? { degradedReasons: [generated.reason === "partial-coverage" ? "partial-coverage" : "embeddings-unavailable"] } : {} }
+  };
+  const encoded = canonicalJson(envelope);
+  if (Buffer.byteLength(encoded) > V4_MAX_ARTIFACT_BYTES) throw new Error(`repo-index v4 artifact exceeds ${V4_MAX_ARTIFACT_BYTES} byte ceiling`);
+  const path = statePath(cwd);
+  (0, import_node_fs3.mkdirSync)((0, import_node_path4.dirname)(path), { recursive: true });
+  (0, import_node_fs3.writeFileSync)(path, `${JSON.stringify(envelope, null, 2)}
+`, "utf8");
+  return envelope;
+}
+function repoIndexV4StorePath(cwd) {
+  return statePath(cwd);
+}
+
+// src/repo-index-v4/shards.ts
+var V4_STAGE_MAX_BODY_BYTES = 750 * 1024;
+var V4_STAGE_MAX_RECORDS = 256;
+var V4_STAGE_MAX_SHARDS = 128;
+function encodedBytes(value) {
+  return Buffer.byteLength(JSON.stringify(value));
+}
+function split(kind, records, manifest) {
+  const groups = [];
+  let group = [];
+  for (const record of records) {
+    const next = [...group, record];
+    const probe = { repo: manifest.repo, commit: manifest.commit, manifestId: manifest.id, kind, index: 127, total: 128, digest: "0".repeat(64), records: next };
+    if (group.length && (group.length >= V4_STAGE_MAX_RECORDS || encodedBytes(probe) > V4_STAGE_MAX_BODY_BYTES)) {
+      groups.push(group);
+      group = [record];
+    } else {
+      group = next;
+    }
+  }
+  if (group.length || records.length === 0) groups.push(group);
+  if (groups.length > V4_STAGE_MAX_SHARDS) throw new Error(`repo-index v4 ${kind} requires ${groups.length} shards (max ${V4_STAGE_MAX_SHARDS})`);
+  return groups.map((items, index) => {
+    const request = {
+      repo: manifest.repo,
+      commit: manifest.commit,
+      manifestId: manifest.id,
+      kind,
+      index,
+      total: groups.length,
+      digest: sha2562(items),
+      records: items
+    };
+    if (encodedBytes(request) > V4_STAGE_MAX_BODY_BYTES) throw new Error(`repo-index v4 ${kind} shard ${index} exceeds ${V4_STAGE_MAX_BODY_BYTES} bytes`);
+    return request;
+  });
+}
+function shardRepoIndexV4(envelope) {
+  const { chunks, embeddings, ...header } = envelope.manifest;
+  const stages = [...split("chunks", chunks, envelope.manifest), ...split("embeddings", embeddings ?? [], envelope.manifest)];
+  const shards = stages.map(({ kind, index, total, digest, records }) => ({ kind, index, total, digest, count: records.length }));
+  return { stages, finalize: { repo: header.repo, commit: header.commit, manifestId: header.id, header, status: envelope.status, shards } };
+}
+function encodedStageBytes(stage) {
+  return encodedBytes(stage);
+}
+
+// src/repo-index-v4/edges.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path5 = require("node:path");
+var V4_GRAPH_MAX_EDGES = 5e3;
+var V4_GRAPH_MAX_EDGES_PER_FILE = 64;
+var SUPPORTED = /* @__PURE__ */ new Map([
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".py", "python"],
+  [".go", "go"],
+  [".rs", "rust"],
+  [".cs", "csharp"],
+  [".md", "resource"],
+  [".json", "resource"],
+  [".yaml", "resource"],
+  [".yml", "resource"]
+]);
+function extension(path) {
+  const index = path.lastIndexOf(".");
+  return index < 0 ? "" : path.slice(index).toLowerCase();
+}
+function lineAt2(source, offset) {
+  return source.slice(0, offset).split(/\r?\n/).length;
+}
+function normalizedRepo(value) {
+  return value.toLowerCase().replace(/^https?:\/\/github\.com\//, "").replace(/\.git(?:[#/?].*)?$/, "").replace(/[?#].*$/, "");
+}
+function targetRepo(specifier, roster) {
+  const direct = normalizedRepo(specifier).match(/(?:^|\/)mutmutco\/([a-z0-9._-]+)/)?.[1];
+  if (direct && roster.has(`mutmutco/${direct}`)) return `mutmutco/${direct}`;
+  const scoped = specifier.toLowerCase().match(/^@mutmutco\/([a-z0-9._-]+)/)?.[1];
+  if (scoped && roster.has(`mutmutco/${scoped}`)) return `mutmutco/${scoped}`;
+  const crate = specifier.toLowerCase().replace(/_/g, "-");
+  return roster.has(`mutmutco/${crate}`) ? `mutmutco/${crate}` : void 0;
+}
+function candidate(base) {
+  return { ...base, id: sha2562(base) };
+}
+function graphEdgesForSource(repo, commit, path, source, rosterRepos) {
+  const language = SUPPORTED.get(extension(path));
+  if (!language) return [];
+  const roster = new Set(rosterRepos.map((value) => value.toLowerCase()));
+  roster.delete(repo.toLowerCase());
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (kind, offset, target, confidence, rule, symbol) => {
+    const targetName = targetRepo(target, roster);
+    if (!targetName) return;
+    const base = { kind, confidence, source: { repo, commit, path, line: lineAt2(source, offset), ...symbol ? { symbol } : {} }, target: { repo: targetName, ...symbol ? { symbol } : {} }, resolver: { name: "repo-index-v4-static", version: 1, language, rule } };
+    const edge = candidate(base);
+    if (!seen.has(edge.id) && edges.length < V4_GRAPH_MAX_EDGES_PER_FILE) {
+      seen.add(edge.id);
+      edges.push(edge);
+    }
+  };
+  const imports = [];
+  const patterns = [
+    /\bimport\s+(?:\{?\s*([A-Za-z_$][\w$]*)[^'";]*?\s+from\s+)?['"]([^'"]+)['"]/g,
+    /\brequire\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /\bfrom\s+([A-Za-z0-9_.\/-]+)\s+import\s+([A-Za-z_]\w*)/g,
+    /\b(?:use|extern\s+crate)\s+([A-Za-z0-9_:\/-]+)/g,
+    /\bimport\s+"([^"]+)"/g,
+    /<ProjectReference\b[^>]*Include=["']([^"']+)["']/gi
+  ];
+  for (const pattern of patterns) for (const match of source.matchAll(pattern)) {
+    const values = match.slice(1).filter((value) => !!value);
+    const target = values.find((value) => targetRepo(value, roster));
+    if (!target || match.index === void 0) continue;
+    const binding = values.find((value) => value !== target && /^[A-Za-z_$][\w$]*$/.test(value));
+    imports.push({ binding, target });
+    push("import", match.index, target, 0.95, `import-${pattern.source.slice(0, 16)}`, binding);
+  }
+  for (const imported of imports) if (imported.binding) {
+    const call = new RegExp(`\\b${imported.binding.replace(/[$]/g, "\\$&")}\\s*\\(`, "g");
+    for (const match of source.matchAll(call)) if (match.index !== void 0) push("call", match.index, imported.target, 0.85, "import-bound-call", imported.binding);
+  }
+  const resource = /https?:\/\/github\.com\/mutmutco\/[A-Za-z0-9._-]+(?:\.git)?/g;
+  for (const match of source.matchAll(resource)) if (match.index !== void 0) push("resource", match.index, match[0], 1, "github-url");
+  return edges.sort((a, b) => a.source.path.localeCompare(b.source.path) || a.source.line - b.source.line || a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id));
+}
+function buildGraphEdges(cwd, repo, commit, rosterRepos) {
+  const paths = listCandidatePaths(cwd).filter(isIndexablePath).sort((a, b) => a.localeCompare(b));
+  const ignored = defaultIsIgnored(cwd, paths);
+  const edges = [];
+  for (const path of paths) {
+    if (ignored.has(path) || isHardDeniedPath(path) || !SUPPORTED.has(extension(path))) continue;
+    const absolute = (0, import_node_path5.join)(cwd, ...path.split("/"));
+    if (!(0, import_node_fs4.existsSync)(absolute)) continue;
+    try {
+      edges.push(...graphEdgesForSource(repo, commit, path, (0, import_node_fs4.readFileSync)(absolute, "utf8"), rosterRepos));
+    } catch {
+    }
+    if (edges.length >= V4_GRAPH_MAX_EDGES) break;
+  }
+  return edges.slice(0, V4_GRAPH_MAX_EDGES).sort((a, b) => a.source.path.localeCompare(b.source.path) || a.source.line - b.source.line || a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REPO_INDEX_V4_SCHEMA,
+  V4_GRAPH_MAX_EDGES,
+  V4_GRAPH_MAX_EDGES_PER_FILE,
+  V4_MAX_ARTIFACT_BYTES,
+  V4_MAX_CHUNKS,
+  V4_STAGE_MAX_BODY_BYTES,
+  V4_STAGE_MAX_RECORDS,
+  buildGraphEdges,
+  buildRepoIndexV4,
+  buildStructuralChunks,
+  encodedStageBytes,
+  graphEdgesForSource,
+  languageForPath,
+  repoIndexV4StorePath,
+  shardRepoIndexV4,
+  structuralChunksForSource
+});