dsh-code-index 0.10.2 → 0.11.0

package/dist/index.js

@@ -3881,6 +3881,229 @@ var RepoContextManager = class {
   }
 };
 
+// src/impact-xray-model.ts
+var XRAY_LIMITS = { nodes: 32, edges: 48, paths: 12, evidenceChars: 900, metadataBytes: 96e3 };
+
+// src/impact-xray.ts
+async function buildImpactXray(index, result) {
+  const view = {
+    card: "impact-xray",
+    version: 2,
+    root: result.root,
+    source: result.source,
+    nodes: [],
+    edges: [],
+    tests: [],
+    imports: [],
+    paths: [],
+    unmapped: [],
+    gaps: result.warnings.slice(0, 12),
+    truncated: false,
+    bounds: { analysis: { ...result.truncated }, projection: false, totals: {
+      changed: result.changed.length,
+      callers: result.directCallers.length,
+      impact: result.impact.length,
+      imports: result.importDependents.length,
+      tests: result.tests.length,
+      paths: result.paths.length,
+      unmapped: result.unmapped.length
+    } }
+  };
+  const read = sourceReader(index);
+  const files = new Map(index.files.map((f) => [f.path, f]));
+  const symbols = new Map(index.files.flatMap((f) => f.symbols.map((s) => [s.id, s])));
+  const changedFiles = new Set(result.changed.map((r) => r.symbol.file).concat(result.unmapped.map((r) => r.file)));
+  const impactFiles = new Set([...result.directCallers, ...result.impact].map((r) => r.symbol.file));
+  const fileSet = /* @__PURE__ */ new Set([...files.keys(), ...changedFiles]);
+  const testFiles = new Set(result.tests.map((t) => t.file));
+  const changed = new Set(result.changed.filter((r) => r.side === "current").map((r) => r.symbol.id));
+  const depths = new Map([...result.directCallers, ...result.impact].map((r) => [r.symbol.id, r.depth]));
+  const nodes = /* @__PURE__ */ new Map();
+  const clip = () => {
+    view.bounds.projection = true;
+  };
+  const evidence = async (file, line, type, side = "current") => {
+    const ref = side === "base" ? result.baseRef : void 0;
+    const entry = { file, line, startLine: Math.max(1, line - 2), side, type, ...ref ? { ref } : {} };
+    const lines = await read(file, side, ref);
+    if (!lines) return { ...entry, gap: "source-unavailable" };
+    if (line < 1 || line > lines.length) return { ...entry, gap: "line-unavailable" };
+    const code = lines.slice(entry.startLine - 1, line + 3).join("\n");
+    return code.length <= XRAY_LIMITS.evidenceChars ? { ...entry, code } : { ...entry, gap: "source-budget" };
+  };
+  const addNode = async (s, reason, side = "current", extra = {}) => {
+    const id = `${side}:${s.id}`;
+    if (nodes.has(id)) return id;
+    if (view.nodes.length >= XRAY_LIMITS.nodes) {
+      clip();
+      return null;
+    }
+    const isChanged = side === "base" || changed.has(s.id);
+    const node = {
+      id,
+      name: s.name,
+      kind: s.kind,
+      file: s.file,
+      line: s.line,
+      changed: isChanged,
+      category: isChanged ? "change" : testFiles.has(s.file) ? "test" : (depths.get(s.id) ?? 1) > 1 ? "impact" : "caller",
+      depth: isChanged ? 0 : depths.get(s.id) ?? 1,
+      reason,
+      evidence: await evidence(s.file, s.line, "declaration", side),
+      ...extra
+    };
+    nodes.set(id, node);
+    view.nodes.push(node);
+    return id;
+  };
+  for (const row of result.changed.slice(0, 12)) await addNode(
+    row.symbol,
+    result.source === "files" || result.source === "symbols" ? "explicit-selection" : "diff-mapping",
+    row.side,
+    { change: row.change }
+  );
+  if (result.changed.length > 12) clip();
+  const hopKeys = /* @__PURE__ */ new Map();
+  const keyOf = (hop) => JSON.stringify([hop.fromId, hop.toId, hop.callSite, hop.resolution, hop.reason]);
+  const hops = [...result.directCallers, ...result.impact].map((r) => r.via).concat(result.paths.flatMap((r) => r.hops));
+  for (const hop of hops) {
+    const key = keyOf(hop);
+    if (hopKeys.has(key)) continue;
+    if (view.edges.length >= 32) {
+      clip();
+      continue;
+    }
+    const from = hop.fromId === null ? void 0 : symbols.get(hop.fromId), to = symbols.get(hop.toId);
+    if (!from || !to) {
+      view.gaps.push("endpoint-unavailable");
+      continue;
+    }
+    const missing = new Set([from.id, to.id].filter((id) => !nodes.has(`current:${id}`))).size;
+    if (view.nodes.length + missing > 24) {
+      clip();
+      continue;
+    }
+    const fromId = await addNode(from, hop.reason), toId = await addNode(to, hop.reason);
+    if (fromId && toId) {
+      const id = `call:${view.edges.length}`;
+      view.edges.push({
+        id,
+        from: fromId,
+        to: toId,
+        kind: "call",
+        resolution: hop.resolution,
+        reason: hop.reason,
+        evidence: await evidence(hop.callSite.file, hop.callSite.line, "call-site")
+      });
+      hopKeys.set(key, id);
+    }
+  }
+  for (const p of result.paths.slice(0, XRAY_LIMITS.paths)) {
+    const edgeIds = p.hops.map((h) => hopKeys.get(keyOf(h))).filter((id) => id !== void 0);
+    view.paths.push({
+      id: `path:${view.paths.length}`,
+      from: p.entry.name,
+      to: p.changed.name,
+      edgeIds,
+      resolution: p.resolution,
+      omitted: edgeIds.length !== p.hops.length
+    });
+  }
+  if (result.paths.length > XRAY_LIMITS.paths) clip();
+  const fileNode = async (file, line = 1, reason = "module", supplied) => {
+    const side = files.has(file) ? "current" : "base";
+    const id = `file:${side}:${file}`;
+    if (nodes.has(id)) return id;
+    if (view.nodes.length >= XRAY_LIMITS.nodes) {
+      clip();
+      return null;
+    }
+    const n = {
+      id,
+      name: file,
+      kind: "module",
+      file,
+      line,
+      changed: changedFiles.has(file),
+      category: testFiles.has(file) ? "test" : "module",
+      reason,
+      evidence: supplied ?? await evidence(file, line, "declaration", side)
+    };
+    nodes.set(id, n);
+    view.nodes.push(n);
+    return id;
+  };
+  for (const row of result.importDependents.slice(0, 8)) {
+    const site = files.get(row.file)?.importDetails?.find((i) => i.specifier === row.specifier);
+    const from = await fileNode(row.file, site?.line ?? 1, "import-dependent");
+    const to = await fileNode(row.changedFile, 1, "changed-module");
+    let edgeId;
+    if (site && from && to && view.edges.length < XRAY_LIMITS.edges) {
+      edgeId = `import:${view.edges.length}`;
+      view.edges.push({
+        id: edgeId,
+        from,
+        to,
+        kind: "import",
+        resolution: row.resolution,
+        reason: "imports-changed-file",
+        evidence: await evidence(row.file, site.line, "import-site")
+      });
+    } else view.gaps.push("import-site-unavailable");
+    view.imports.push({ ...row, ...edgeId ? { edgeId } : {} });
+  }
+  for (const row of result.tests.slice(0, 8)) {
+    const file = files.get(row.file);
+    const targets = row.reason === "imports-changed-file" ? changedFiles : row.reason === "imports-impact-file" ? impactFiles : /* @__PURE__ */ new Set();
+    const site = file?.importDetails?.find((i) => {
+      const target = resolveImport(i.specifier, row.file, fileSet);
+      return target !== null && targets.has(target);
+    });
+    const call = row.reason === "references-symbol-name" ? file?.calls?.find((c) => result.changed.some((s) => s.symbol.name === c.name)) : void 0;
+    const line = site?.line ?? call?.line ?? 1;
+    const e = await evidence(row.file, line, site ? "import-site" : "test-lead");
+    const nodeId = await fileNode(row.file, line, row.reason, e);
+    if (nodeId) {
+      const n = nodes.get(nodeId);
+      n.reason = row.reason;
+      n.resolution = row.resolution;
+      n.evidence = e;
+      n.line = line;
+    }
+    view.tests.push({ ...row, ...nodeId ? { nodeId } : {} });
+  }
+  if (result.importDependents.length > 8 || result.tests.length > 8) clip();
+  for (const row of result.unmapped.slice(0, 8)) view.unmapped.push({
+    ...row,
+    ranges: row.ranges.slice(0, 16),
+    evidence: await evidence(row.file, row.ranges[0]?.startLine ?? 1, "unmapped-change", row.side)
+  });
+  if (result.unmapped.length > 8 || result.unmapped.some((r) => r.ranges.length > 16)) clip();
+  view.gaps = [...new Set(view.gaps)].slice(0, 20);
+  view.truncated = view.bounds.projection || Object.values(result.truncated).some(Boolean);
+  if (Buffer.byteLength(JSON.stringify(view)) > XRAY_LIMITS.metadataBytes) {
+    for (const e of [...view.nodes.map((n) => n.evidence), ...view.edges.map((e2) => e2.evidence), ...view.unmapped.map((u) => u.evidence)]) {
+      delete e.code;
+      e.gap = "source-budget";
+    }
+    clip();
+    view.truncated = true;
+    if (Buffer.byteLength(JSON.stringify(view)) > XRAY_LIMITS.metadataBytes) return {
+      card: "impact-xray",
+      version: 2,
+      root: "",
+      source: result.source,
+      nodes: [],
+      edges: [],
+      tests: [],
+      imports: [],
+      gaps: ["metadata-budget"],
+      truncated: true
+    };
+  }
+  return view;
+}
+
 // src/tools.ts
 var activeRepoContexts = null;
 function activateRepoContextManager(manager) {
@@ -4171,6 +4394,11 @@ var tools = [
     name: "code_change_context",
     description: "Return the smallest change-aware context for the current diff: changed symbols, direct callers, import dependents, shortest paths to entry points, transitive impact, and likely affected tests. Every relation is labeled exact / import-scoped / name-only, so confidence is explicit. Select the change with an explicit diff, a list of files, a list of symbol ids, or (default) the working tree against baseRef.",
     parameters: {
+      outputFormat: {
+        type: "string",
+        enum: ["text", "xray"],
+        description: "Default text preserves the canonical string. xray requests the experimental bounded Impact X-Ray evidence snapshot."
+      },
       repoRoot: {
         type: "string",
         description: "Optional absolute repo path; defaults to the session workspace root."
@@ -4211,8 +4439,9 @@ var tools = [
       }
     },
     output: {
-      schema: { type: "string" },
-      render: (_args, value) => [{ type: "text", text: value }]
+      schema: { oneOf: [{ type: "string" }, { type: "object", additionalProperties: true }] },
+      render: (_args, value) => [{ type: "text", text: typeof value === "string" ? value : String(value.text) }],
+      presentationMeta: (_args, value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value.xray ?? null : null
     },
     presentCall: (args) => ({
       card: "generic",
@@ -4236,6 +4465,15 @@ var tools = [
           maxPaths: args.maxPaths,
           maxTests: args.maxTests
         });
+        if (args.outputFormat === "xray") {
+          const xray = await buildImpactXray(index, result);
+          let text = renderChangeContext(result);
+          if (text.length > 24e3) {
+            text = text.slice(0, 23800).split("\n").slice(0, -1).join("\n") + "\n[X-Ray text budget reached; default text output remains available.]";
+            if (xray.bounds) xray.bounds.text = true;
+          }
+          return { text, xray: JSON.parse(JSON.stringify(xray)) };
+        }
         return renderChangeContext(result);
       } catch (error) {
         return `code_change_context: ${error.message ?? String(error)}`;
@@ -4487,8 +4725,10 @@ export {
   Config,
   DEFAULT_EXCLUDED_DIRS,
   SUPPORTED_EXTS,
+  XRAY_LIMITS,
   apply,
   buildChangeContext,
+  buildImpactXray,
   buildIndex,
   buildIndexWithCache,
   buildModuleGraph,