karajan-code 2.33.0 → 3.0.0

package/src/commands/telemetry.js

@@ -0,0 +1,70 @@
+import { TELEMETRY_ENDPOINT, buildTelemetryPayload, isTelemetryEnabled } from "../utils/telemetry.js";
+
+/**
+ * Render the exact payload that would be POSTed for every event type.
+ *
+ * Read-only by design: this never opens a socket. It exists so users
+ * can inspect what telemetry sends before (or after) opting in,
+ * without grepping the source. The contract here MUST stay in sync
+ * with the producers in src/cli/_shared.js and the pipeline emitter
+ * in src/orchestrator/flow-runner.js — if a new field appears there,
+ * mirror it in the example below.
+ */
+function buildPreview(version) {
+  const v = version || "x.y.z";
+  return {
+    endpoint: TELEMETRY_ENDPOINT,
+    events: [
+      buildTelemetryPayload("install", { version: v }),
+      buildTelemetryPayload("cli_command", { version: v, command: "run" }),
+      buildTelemetryPayload("pipeline_complete", {
+        version: v,
+        mode: "standard",
+        agent: "claude",
+        duration_s: 42,
+        success: true,
+        taskType: "feature"
+      })
+    ]
+  };
+}
+
+export async function telemetryPreviewCommand({ config, logger, version, json }) {
+  const preview = buildPreview(version);
+  if (json) {
+    logger.info(JSON.stringify(preview, null, 2));
+    return preview;
+  }
+  const enabled = isTelemetryEnabled(config);
+  logger.info(`Telemetry endpoint: ${preview.endpoint}`);
+  logger.info(`Telemetry enabled:  ${enabled ? "yes" : "no"}`);
+  logger.info("");
+  logger.info("Exact payloads that would be POSTed (one per event type):");
+  logger.info("");
+  for (const payload of preview.events) {
+    logger.info(`  [${payload.event}]`);
+    logger.info(`    ${JSON.stringify(payload)}`);
+    logger.info("");
+  }
+  logger.info("No data was sent — `kj telemetry preview` never opens a socket.");
+  return preview;
+}
+
+export async function telemetryStatusCommand({ config, logger, json }) {
+  const enabled = isTelemetryEnabled(config);
+  const report = {
+    enabled,
+    endpoint: TELEMETRY_ENDPOINT,
+    flipHint: enabled
+      ? "Set `telemetry: false` in ~/.karajan/kj.config.yml (or re-run `kj init`) to turn it off."
+      : "Set `telemetry: true` in ~/.karajan/kj.config.yml (or re-run `kj init`) to turn it on."
+  };
+  if (json) {
+    logger.info(JSON.stringify(report, null, 2));
+    return report;
+  }
+  logger.info(`Telemetry: ${enabled ? "enabled" : "disabled"}`);
+  logger.info(`Endpoint:  ${report.endpoint}`);
+  logger.info(report.flipHint);
+  return report;
+}

package/src/config/defaults.js

@@ -189,7 +189,17 @@ const DEFAULTS = {
     devtools_mcp: false,
     thresholds: { lcp: 2500, cls: 0.1, inp: 200 }
   },
-  telemetry: true,
+  rag: {
+    // KJC-TSK-0455 — Auto-refresh the local RAG index. `onRun` runs a
+    // delta re-index before every `kj run`; `onCommit` is consulted by
+    // `kj rag install-hooks` to decide whether to install the post-merge
+    // hook. Both default ON; flip to false to opt out without uninstalling.
+    autoUpdate: { onCommit: true, onRun: true }
+  },
+  // Opt-in. Set by the `kj init` wizard (explicit consent prompt in the OS
+  // locale). When the key is absent or false, no events are sent. See
+  // src/utils/telemetry.js and the Privacy & Telemetry section of README.md.
+  telemetry: false,
   guards: {
     output: {
       enabled: true,

package/src/lang/chunk-go.js

@@ -0,0 +1,94 @@
+// KJC-PCS-0052 PR-B.2.3 — Go source chunker (tree-sitter + regex fallback).
+// Mismo contrato síncrono que chunk-rust: AST si el caller awaited
+// `prepareGo()` antes, regex si no. Top-level: func / method / type.
+//
+// `method_declaration` (con receiver) y `function_declaration` se tratan
+// igual — symbol es el nombre, sin componer "Recv.Method" (coherente con
+// Python: del scope se ocupa la búsqueda semántica, no el chunk).
+// `type_declaration` contiene type_spec(s); usamos el primero como symbol.
+
+import { getLoaded, loadLanguage } from "./tree-sitter-loader.js";
+
+const DEFAULT_LIMIT = 800;
+const DEFAULT_OVERLAP = 100;
+const NAMED_KINDS = new Set([
+  "function_declaration",
+  "method_declaration",
+]);
+const TOP_RE = /^(?:func(?:\s+\([^)]+\))?|type)\s+([A-Za-z_]\w*)/gm;
+
+export async function prepareGo() {
+  return loadLanguage("go");
+}
+
+function windowText(text, limit, overlap) {
+  if (text.length <= limit) return [text];
+  const step = Math.max(1, limit - overlap);
+  const out = [];
+  for (let i = 0; i < text.length; i += step) {
+    out.push(text.slice(i, i + limit));
+    if (i + limit >= text.length) break;
+  }
+  return out;
+}
+
+function symbolForType(node) {
+  for (const spec of node.namedChildren) {
+    if (spec.type === "type_spec" || spec.type === "type_alias") {
+      const nameNode = spec.childForFieldName("name");
+      if (nameNode) return nameNode.text;
+    }
+  }
+  return null;
+}
+
+function marksViaAST(text) {
+  const entry = getLoaded("go");
+  if (!entry) return null;
+  let tree;
+  try {
+    tree = entry.parser.parse(text);
+  } catch {
+    return null;
+  }
+  const marks = [];
+  for (const child of tree.rootNode.namedChildren) {
+    let symbol = null;
+    if (NAMED_KINDS.has(child.type)) {
+      const nameNode = child.childForFieldName("name");
+      if (nameNode) symbol = nameNode.text;
+    } else if (child.type === "type_declaration") {
+      symbol = symbolForType(child);
+    }
+    if (symbol) marks.push({ idx: child.startIndex, symbol });
+  }
+  return marks;
+}
+
+function marksViaRegex(text) {
+  const marks = [];
+  TOP_RE.lastIndex = 0;
+  let m;
+  while ((m = TOP_RE.exec(text)) !== null) marks.push({ idx: m.index, symbol: m[1] });
+  return marks;
+}
+
+export function chunkGo(text, { path = "<src>", limit = DEFAULT_LIMIT, overlap = DEFAULT_OVERLAP } = {}) {
+  const marks = marksViaAST(text) ?? marksViaRegex(text);
+  if (marks.length === 0) {
+    return windowText(text, limit, overlap).map((piece) => ({
+      text: piece,
+      metadata: { source: path, kind: "code", symbol: null, language: "go" },
+    }));
+  }
+  const out = [];
+  for (let i = 0; i < marks.length; i += 1) {
+    const start = marks[i].idx;
+    const end = i + 1 < marks.length ? marks[i + 1].idx : text.length;
+    const body = text.slice(start, end);
+    for (const piece of windowText(body, limit, overlap)) {
+      out.push({ text: piece, metadata: { source: path, kind: "code", symbol: marks[i].symbol, language: "go" } });
+    }
+  }
+  return out;
+}

package/src/lang/chunk-java.js

@@ -0,0 +1,90 @@
+// KJC-PCS-0052 PR-B.2.5 — Java chunker (tree-sitter + regex fallback).
+// Walker 2 niveles: top-level emite class/interface/enum/record; segundo pase
+// desciende al body por method_declaration / constructor_declaration. Symbol
+// sin prefijar (coherente con chunk-go), el RAG ya lleva contexto del fichero.
+
+import { getLoaded, loadLanguage } from "./tree-sitter-loader.js";
+
+const DEFAULT_LIMIT = 800;
+const DEFAULT_OVERLAP = 100;
+const CONTAINER_KINDS = new Set([
+  "class_declaration",
+  "interface_declaration",
+  "enum_declaration",
+  "record_declaration",
+]);
+const MEMBER_KINDS = new Set([
+  "method_declaration",
+  "constructor_declaration",
+]);
+const TOP_RE = /^[ \t]*(?:public\s+|private\s+|protected\s+|static\s+|final\s+|abstract\s+|sealed\s+|non-sealed\s+)*(class|interface|enum|record)\s+([A-Za-z_]\w*)/gm;
+
+export async function prepareJava() {
+  return loadLanguage("java");
+}
+
+function windowText(text, limit, overlap) {
+  if (text.length <= limit) return [text];
+  const step = Math.max(1, limit - overlap);
+  const out = [];
+  for (let i = 0; i < text.length; i += step) {
+    out.push(text.slice(i, i + limit));
+    if (i + limit >= text.length) break;
+  }
+  return out;
+}
+
+function nameOf(node) {
+  const n = node.childForFieldName("name");
+  return n ? n.text : null;
+}
+
+function marksViaAST(text) {
+  const entry = getLoaded("java");
+  if (!entry) return null;
+  let tree;
+  try { tree = entry.parser.parse(text); } catch { return null; }
+  const marks = [];
+  for (const child of tree.rootNode.namedChildren) {
+    if (!CONTAINER_KINDS.has(child.type)) continue;
+    const s = nameOf(child);
+    if (s) marks.push({ idx: child.startIndex, symbol: s });
+    const body = child.childForFieldName("body");
+    if (!body) continue;
+    for (const m of body.namedChildren) {
+      if (!MEMBER_KINDS.has(m.type)) continue;
+      const ms = nameOf(m);
+      if (ms) marks.push({ idx: m.startIndex, symbol: ms });
+    }
+  }
+  marks.sort((a, b) => a.idx - b.idx);
+  return marks;
+}
+
+function marksViaRegex(text) {
+  const marks = [];
+  TOP_RE.lastIndex = 0;
+  let m;
+  while ((m = TOP_RE.exec(text)) !== null) marks.push({ idx: m.index, symbol: m[2] });
+  return marks;
+}
+
+export function chunkJava(text, { path = "<src>", limit = DEFAULT_LIMIT, overlap = DEFAULT_OVERLAP } = {}) {
+  const marks = marksViaAST(text) ?? marksViaRegex(text);
+  if (marks.length === 0) {
+    return windowText(text, limit, overlap).map((piece) => ({
+      text: piece,
+      metadata: { source: path, kind: "code", symbol: null, language: "java" },
+    }));
+  }
+  const out = [];
+  for (let i = 0; i < marks.length; i += 1) {
+    const start = marks[i].idx;
+    const end = i + 1 < marks.length ? marks[i + 1].idx : text.length;
+    const body = text.slice(start, end);
+    for (const piece of windowText(body, limit, overlap)) {
+      out.push({ text: piece, metadata: { source: path, kind: "code", symbol: marks[i].symbol, language: "java" } });
+    }
+  }
+  return out;
+}

package/src/lang/chunk-python.js

@@ -0,0 +1,88 @@
+// KJC-PCS-0052 PR-B.2.1 — Python source chunker (tree-sitter + regex fallback).
+// Top-level `def`/`async def`/`class` siguen siendo la frontera de chunk, pero
+// ahora con dos caminos:
+//   1. AST (web-tree-sitter): si el caller hizo `await preparePython()` antes
+//      del indexado, leemos el árbol y capturamos solo nodos cuyo `parent.type`
+//      es `module` — eso excluye métodos anidados sin depender de la
+//      indentación visual y captura decoradores (`decorated_definition`)
+//      apuntando al def/class real subyacente.
+//   2. Regex: fallback síncrono para entornos sin tree-sitter listo (tests
+//      legacy, primera invocación antes de `preparePython`). Misma semántica
+//      que PR-B.
+//
+// El contrato externo no cambia: `chunkPython(text, opts)` es síncrono y
+// devuelve `[{ text, metadata: { source, kind, symbol, language } }]`.
+
+import { getLoaded, loadLanguage } from "./tree-sitter-loader.js";
+
+const DEFAULT_LIMIT = 800;
+const DEFAULT_OVERLAP = 100;
+const TOP_RE = /^(?:async\s+)?(?:def|class)\s+([A-Za-z_]\w*)/gm;
+
+export async function preparePython() {
+  return loadLanguage("python");
+}
+
+function windowText(text, limit, overlap) {
+  if (text.length <= limit) return [text];
+  const step = Math.max(1, limit - overlap);
+  const out = [];
+  for (let i = 0; i < text.length; i += step) {
+    out.push(text.slice(i, i + limit));
+    if (i + limit >= text.length) break;
+  }
+  return out;
+}
+
+function marksViaAST(text) {
+  const entry = getLoaded("python");
+  if (!entry) return null;
+  let tree;
+  try {
+    tree = entry.parser.parse(text);
+  } catch {
+    return null;
+  }
+  const marks = [];
+  for (const child of tree.rootNode.namedChildren) {
+    let defNode = null;
+    if (child.type === "function_definition" || child.type === "class_definition") {
+      defNode = child;
+    } else if (child.type === "decorated_definition") {
+      defNode = child.childForFieldName("definition");
+    }
+    if (!defNode) continue;
+    const nameNode = defNode.childForFieldName("name");
+    if (!nameNode) continue;
+    marks.push({ idx: child.startIndex, symbol: nameNode.text });
+  }
+  return marks;
+}
+
+function marksViaRegex(text) {
+  const marks = [];
+  TOP_RE.lastIndex = 0;
+  let m;
+  while ((m = TOP_RE.exec(text)) !== null) marks.push({ idx: m.index, symbol: m[1] });
+  return marks;
+}
+
+export function chunkPython(text, { path = "<src>", limit = DEFAULT_LIMIT, overlap = DEFAULT_OVERLAP } = {}) {
+  const marks = marksViaAST(text) ?? marksViaRegex(text);
+  if (marks.length === 0) {
+    return windowText(text, limit, overlap).map((piece) => ({
+      text: piece,
+      metadata: { source: path, kind: "code", symbol: null, language: "python" },
+    }));
+  }
+  const out = [];
+  for (let i = 0; i < marks.length; i += 1) {
+    const start = marks[i].idx;
+    const end = i + 1 < marks.length ? marks[i + 1].idx : text.length;
+    const body = text.slice(start, end);
+    for (const piece of windowText(body, limit, overlap)) {
+      out.push({ text: piece, metadata: { source: path, kind: "code", symbol: marks[i].symbol, language: "python" } });
+    }
+  }
+  return out;
+}

package/src/lang/chunk-rust.js

@@ -0,0 +1,102 @@
+// KJC-PCS-0052 PR-B.2.2 — Rust source chunker (tree-sitter + regex fallback).
+// Mismo contrato síncrono que chunk-python: AST si el caller awaited
+// `prepareRust()` antes, regex si no. Top-level items (fn / struct / enum /
+// trait / impl / mod) son la frontera de chunk.
+//
+// El nodo `impl_item` no tiene field `name`; usamos el campo `type` para
+// que metadata.symbol apunte al tipo implementado (útil para grep en RAG).
+
+import { getLoaded, loadLanguage } from "./tree-sitter-loader.js";
+
+const DEFAULT_LIMIT = 800;
+const DEFAULT_OVERLAP = 100;
+const NAMED_KINDS = new Set([
+  "function_item",
+  "struct_item",
+  "enum_item",
+  "trait_item",
+  "mod_item",
+  "type_item",
+  "union_item",
+]);
+const TOP_RE = /^(?:pub(?:\([^)]*\))?\s+)?(?:async\s+|unsafe\s+|extern\s+(?:"[^"]+"\s+)?)*(?:fn|struct|enum|trait|mod|type|union|impl)(?:\s+(?:<[^>]+>\s+)?)?([A-Za-z_][\w]*)/gm;
+
+export async function prepareRust() {
+  return loadLanguage("rust");
+}
+
+function windowText(text, limit, overlap) {
+  if (text.length <= limit) return [text];
+  const step = Math.max(1, limit - overlap);
+  const out = [];
+  for (let i = 0; i < text.length; i += step) {
+    out.push(text.slice(i, i + limit));
+    if (i + limit >= text.length) break;
+  }
+  return out;
+}
+
+function symbolForImpl(node) {
+  const typeNode = node.childForFieldName("type");
+  return typeNode ? typeNode.text : null;
+}
+
+function marksViaAST(text) {
+  const entry = getLoaded("rust");
+  if (!entry) return null;
+  let tree;
+  try {
+    tree = entry.parser.parse(text);
+  } catch {
+    return null;
+  }
+  const marks = [];
+  let pendingAttrStart = null;
+  for (const child of tree.rootNode.namedChildren) {
+    if (child.type === "attribute_item" || child.type === "inner_attribute_item") {
+      if (pendingAttrStart === null) pendingAttrStart = child.startIndex;
+      continue;
+    }
+    let symbol = null;
+    if (NAMED_KINDS.has(child.type)) {
+      const nameNode = child.childForFieldName("name");
+      if (nameNode) symbol = nameNode.text;
+    } else if (child.type === "impl_item") {
+      symbol = symbolForImpl(child);
+    }
+    if (symbol) {
+      const idx = pendingAttrStart ?? child.startIndex;
+      marks.push({ idx, symbol });
+    }
+    pendingAttrStart = null;
+  }
+  return marks;
+}
+
+function marksViaRegex(text) {
+  const marks = [];
+  TOP_RE.lastIndex = 0;
+  let m;
+  while ((m = TOP_RE.exec(text)) !== null) marks.push({ idx: m.index, symbol: m[1] });
+  return marks;
+}
+
+export function chunkRust(text, { path = "<src>", limit = DEFAULT_LIMIT, overlap = DEFAULT_OVERLAP } = {}) {
+  const marks = marksViaAST(text) ?? marksViaRegex(text);
+  if (marks.length === 0) {
+    return windowText(text, limit, overlap).map((piece) => ({
+      text: piece,
+      metadata: { source: path, kind: "code", symbol: null, language: "rust" },
+    }));
+  }
+  const out = [];
+  for (let i = 0; i < marks.length; i += 1) {
+    const start = marks[i].idx;
+    const end = i + 1 < marks.length ? marks[i + 1].idx : text.length;
+    const body = text.slice(start, end);
+    for (const piece of windowText(body, limit, overlap)) {
+      out.push({ text: piece, metadata: { source: path, kind: "code", symbol: marks[i].symbol, language: "rust" } });
+    }
+  }
+  return out;
+}

package/src/lang/go.js

@@ -0,0 +1,14 @@
+// KJC-PCS-0052 PR-B.2.3 — Go adapter. Detección por go.mod/go.sum; vendor/
+// y bin/ no se recorren (vendor lo usa `go mod vendor`, bin son builds).
+// chunk-go usa AST (tree-sitter) cuando el caller hizo `await prepareGo()`
+// y cae a regex en otro caso (mismo patrón que PYTHON_ADAPTER / RUST_ADAPTER).
+import { chunkGo, prepareGo } from "./chunk-go.js";
+
+export const GO_ADAPTER = {
+  id: "go",
+  extensions: [".go"],
+  skipSegments: ["vendor", "bin"],
+  manifests: ["go.mod", "go.sum"],
+  chunkSource: chunkGo,
+  prepare: prepareGo,
+};

package/src/lang/java.js

@@ -0,0 +1,16 @@
+// KJC-PCS-0052 PR-B.2.5 — Java adapter. Detección por pom.xml / build.gradle
+// (Maven, Gradle Groovy y Kotlin DSL). target/ y build/ son outputs estándar
+// de ambos sistemas; .gradle/ es el cache del wrapper; out/ lo usan IDEs
+// (IntelliJ/Eclipse) para classes. chunk-java usa AST (tree-sitter) cuando
+// el caller hizo `await prepareJava()` y cae a regex en otro caso (mismo
+// patrón que GO_ADAPTER / RUST_ADAPTER / PYTHON_ADAPTER).
+import { chunkJava, prepareJava } from "./chunk-java.js";
+
+export const JAVA_ADAPTER = {
+  id: "java",
+  extensions: [".java"],
+  skipSegments: ["target", "build", ".gradle", "out"],
+  manifests: ["pom.xml", "build.gradle", "build.gradle.kts"],
+  chunkSource: chunkJava,
+  prepare: prepareJava,
+};

package/src/lang/js.js

@@ -0,0 +1,8 @@
+// KJC-PCS-0052 PR-A — JS/TS adapter. Codifica las constantes que vivían
+// hard-coded en src/rag/indexer.js antes del registry.
+export const JS_ADAPTER = {
+  id: "js",
+  extensions: [".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"],
+  skipSegments: ["node_modules", ".next", ".nuxt", ".svelte-kit"],
+  manifests: ["package.json"],
+};

package/src/lang/python.js

@@ -0,0 +1,14 @@
+// KJC-PCS-0052 PR-A/PR-B — Python adapter. Detección por manifest activa
+// el adapter; virtualenvs y caches se excluyen del walk. PR-B añade
+// `chunkSource` regex top-level (def/async def/class) — tree-sitter real
+// queda para PR-B.2 (decisión WASM vs native).
+import { chunkPython, preparePython } from "./chunk-python.js";
+
+export const PYTHON_ADAPTER = {
+  id: "python",
+  extensions: [".py"],
+  skipSegments: ["__pycache__", ".venv", "venv", ".tox", ".pytest_cache", ".mypy_cache", ".ruff_cache"],
+  manifests: ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile"],
+  chunkSource: chunkPython,
+  prepare: preparePython,
+};

package/src/lang/registry.js

@@ -0,0 +1,79 @@
+// KJC-PCS-0052 PR-A — Language adapter registry. Antes vivían CODE_EXT_RE
+// y SKIP_SEGMENTS hardcoded en indexer.js (solo JS/TS); ahora cada adapter
+// declara extensiones, skipSegments y manifests. PR-B añadirá AST chunkers
+// (tree-sitter); PR-C/D usan el mismo registry para audit y onboarder.
+import { existsSync } from "node:fs";
+import { extname, join } from "node:path";
+
+import { GO_ADAPTER } from "./go.js";
+import { JAVA_ADAPTER } from "./java.js";
+import { JS_ADAPTER } from "./js.js";
+import { PYTHON_ADAPTER } from "./python.js";
+import { RUST_ADAPTER } from "./rust.js";
+
+// Segmentos siempre excluidos del walk, independientes de stack: VCS,
+// outputs de build, scratch de Karajan, sandbox del audit. Lo que viva
+// aquí jamás se indexa.
+const COMMON_SKIP_SEGMENTS = [".git", "dist", "build", "coverage", ".karajan", ".kj", "_diet"];
+
+const REGISTRY = [JS_ADAPTER, PYTHON_ADAPTER, RUST_ADAPTER, GO_ADAPTER, JAVA_ADAPTER];
+
+export function getAdapters() {
+  return REGISTRY.slice();
+}
+
+/**
+ * Detecta qué adapters aplican a un projectDir mirando los manifests
+ * declarados. Si ningún adapter coincide (proyecto sin manifest), cae
+ * a JS para no romper repos legacy o sandboxes de tests.
+ */
+export function detectAdaptersForProject(projectDir) {
+  if (!projectDir) return [JS_ADAPTER];
+  const matched = REGISTRY.filter((a) => a.manifests.some((m) => existsSync(join(projectDir, m))));
+  return matched.length ? matched : [JS_ADAPTER];
+}
+
+/**
+ * Construye los matchers que usa el indexer al recorrer el árbol:
+ * `isCodeFile(path)` decide si la extensión cuadra con algún adapter
+ * activo; `shouldSkip(path)` aplica la unión de skipSegments comunes +
+ * los del adapter. Devuelve también `extensions` por si el caller quiere
+ * inspeccionarlas (p.ej. tests).
+ */
+export function buildMatchers(adapters) {
+  const extSet = new Set();
+  const skipSet = new Set(COMMON_SKIP_SEGMENTS);
+  for (const a of adapters) {
+    for (const e of a.extensions) extSet.add(e.toLowerCase());
+    for (const s of a.skipSegments || []) skipSet.add(s);
+  }
+  return {
+    isCodeFile: (p) => extSet.has(extname(p).toLowerCase()),
+    shouldSkip: (p) => p.split("/").some((seg) => skipSet.has(seg)),
+    extensions: [...extSet],
+  };
+}
+
+/**
+ * Unión de extensiones de TODOS los adapters registrados. Útil para
+ * `detectKind` en el indexer, que recibe un path suelto sin saber el
+ * projectDir y necesita reconocer una extensión de código aunque venga
+ * de un adapter no detectado en el proyecto actual.
+ */
+export function getAllCodeExtensions() {
+  const out = new Set();
+  for (const a of REGISTRY) for (const e of a.extensions) out.add(e.toLowerCase());
+  return [...out];
+}
+
+/**
+ * KJC-PCS-0052 PR-B — devuelve el adapter cuya `extensions` cubre el
+ * path, o `null` si ninguno matchea. Lo consume el chunker para delegar
+ * a un chunker específico por lenguaje (p.ej. Python).
+ */
+export function adapterForPath(path) {
+  if (!path) return null;
+  const ext = extname(path).toLowerCase();
+  for (const a of REGISTRY) if (a.extensions.includes(ext)) return a;
+  return null;
+}

package/src/lang/rust.js

@@ -0,0 +1,14 @@
+// KJC-PCS-0052 PR-B.2.2 — Rust adapter. Detección por Cargo.toml; target/
+// y skip segments evitan que el indexer recorra builds. chunk-rust usa
+// AST (tree-sitter) cuando el caller hizo `await prepareRust()` y cae a
+// regex en otro caso (mismo patrón que PYTHON_ADAPTER).
+import { chunkRust, prepareRust } from "./chunk-rust.js";
+
+export const RUST_ADAPTER = {
+  id: "rust",
+  extensions: [".rs"],
+  skipSegments: ["target", ".cargo"],
+  manifests: ["Cargo.toml", "Cargo.lock"],
+  chunkSource: chunkRust,
+  prepare: prepareRust,
+};

package/src/lang/tree-sitter-loader.js

@@ -0,0 +1,49 @@
+// KJC-PCS-0052 PR-B.2.1 — Lazy loader for web-tree-sitter parsers.
+// Async init (Parser.init + Language.load) is paid once per language id
+// and cached. Callers that want AST chunking must `await loadLanguage(...)`
+// during pre-loop; the per-file chunker then reads the cached entry
+// synchronously via `getLoaded(id)` and falls back to regex if not ready.
+//
+// Pure WASM (web-tree-sitter) over native bindings: no node-gyp build, no
+// per-platform .node files — works inside the SEA binary because the
+// grammar `.wasm` files travel with the npm package under
+// `vendor/tree-sitter-grammars/` (see ../../vendor/.../README.md).
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+
+import { Language, Parser } from "web-tree-sitter";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const GRAMMAR_DIR = resolve(HERE, "../../vendor/tree-sitter-grammars");
+
+const cache = new Map();
+let runtimePromise = null;
+
+async function initRuntime() {
+  if (!runtimePromise) runtimePromise = Parser.init();
+  return runtimePromise;
+}
+
+export function grammarPath(id) {
+  return resolve(GRAMMAR_DIR, `${id}.wasm`);
+}
+
+export async function loadLanguage(id, wasmPath = grammarPath(id)) {
+  if (cache.has(id)) return cache.get(id);
+  await initRuntime();
+  const language = await Language.load(wasmPath);
+  const parser = new Parser();
+  parser.setLanguage(language);
+  const entry = { parser, language };
+  cache.set(id, entry);
+  return entry;
+}
+
+export function getLoaded(id) {
+  return cache.get(id) || null;
+}
+
+export function resetForTests() {
+  cache.clear();
+  runtimePromise = null;
+}