@moda-ai/cli 1.55.92 → 1.55.94

package/dist/change-impact-2hqk7kj0.js

@@ -0,0 +1,867 @@
+import {
+  calleeChain,
+  clearExtractCache,
+  enumerateAgents,
+  extractHarnessWithContext,
+  isEvalPath,
+  isTestPath,
+  receiverClasses,
+  relPath,
+  resolvePromptArguments,
+  resolvedSymbol,
+  returnExpressions,
+  valueDeclaration
+} from "./cli-5c37h7n5.js";
+import"./cli-k0vxtzxb.js";
+import"./cli-97fnztpy.js";
+import {
+  detectBoundRuntimeClasses
+} from "./cli-krm4w2v9.js";
+import"./cli-6ga6kmdp.js";
+import"./cli-dxajrq9h.js";
+import"./cli-13zdcv4w.js";
+import"./cli-e0kbye4s.js";
+import"./cli-1nd4339b.js";
+import"./cli-k4tqwah4.js";
+import {
+  require_typescript
+} from "./cli-r0pkdy83.js";
+import"./cli-9kfxkxmk.js";
+import"./cli-0semcakc.js";
+import {
+  __toESM
+} from "./cli-0v6na3yp.js";
+
+// src/change-impact.ts
+var import_typescript2 = __toESM(require_typescript(), 1);
+import { z } from "zod";
+import { execFileSync } from "node:child_process";
+import { lstatSync, mkdtempSync, mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+// src/change-impact-closure.ts
+var import_typescript = __toESM(require_typescript(), 1);
+import { relative } from "node:path";
+var owner = (node) => import_typescript.default.isFunctionLike(node) || import_typescript.default.isVariableDeclaration(node) || import_typescript.default.isClassLike(node) || import_typescript.default.isPropertyDeclaration(node) || import_typescript.default.isPropertyAssignment(node) || import_typescript.default.isInterfaceDeclaration(node) || import_typescript.default.isTypeAliasDeclaration(node) || import_typescript.default.isEnumDeclaration(node) || import_typescript.default.isParameter(node) || import_typescript.default.isBindingElement(node);
+function enclosing(node) {
+  for (let at = node;at && !import_typescript.default.isSourceFile(at); at = at.parent)
+    if (owner(at))
+      return at;
+  return;
+}
+var named = (node) => node.name;
+function identity(root, node) {
+  return `${relative(root, node.getSourceFile().fileName).replaceAll("\\", "/")}:${node.getStart()}`;
+}
+function coordinate(root, node) {
+  const source = node.getSourceFile();
+  return {
+    path: relPath(root, source.fileName),
+    line: source.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+    endLine: source.getLineAndCharacterOfPosition(node.getEnd()).line + 1
+  };
+}
+function contains(root, node, path, line, col = 1, offset) {
+  const source = node.getSourceFile();
+  if (relPath(root, source.fileName) !== path)
+    return false;
+  const position = offset ?? source.getPositionOfLineAndCharacter(line - 1, col - 1);
+  return node.getStart() <= position && position < node.getEnd();
+}
+function referenceClosure(ctx, extracted, ranges, limits = {}) {
+  const root = ctx.rootDir, maxSymbols = limits.maxSymbols ?? 5000, maxReferences = limits.maxReferences ?? 1e5;
+  const warnings = [], reached = new Map, nodes = new Map;
+  const queue = [];
+  const boundaryClasses = new Set;
+  const files = ctx.sourceFiles().filter((source) => {
+    const path = coordinate(root, source).path;
+    return !isTestPath(path) && !isEvalPath(path);
+  });
+  const available = new Set(files.map((source) => source.fileName));
+  const classes = new Map;
+  for (const source of files) {
+    const visit = (node) => {
+      if (import_typescript.default.isClassLike(node) && node.name)
+        classes.set(node.name.text, [...classes.get(node.name.text) ?? [], node]);
+      import_typescript.default.forEachChild(node, visit);
+    };
+    visit(source);
+  }
+  const bindings = new Map;
+  for (const bound of detectBoundRuntimeClasses(root)) {
+    const targets = bindings.get(bound.binding) ?? new Set;
+    targets.add(bound.className);
+    bindings.set(bound.binding, targets);
+  }
+  const rpcClasses = (expression, checker, depth = 0) => {
+    if (depth > 4)
+      return [];
+    const typed = receiverClasses(expression, checker);
+    if (typed.length)
+      return typed;
+    if (!import_typescript.default.isCallExpression(expression))
+      return [];
+    const callee = expression.expression;
+    if (!import_typescript.default.isPropertyAccessExpression(callee))
+      return [];
+    const namespace = callee.expression;
+    if (/^(get|getByName)$/.test(callee.name.text) && import_typescript.default.isPropertyAccessExpression(namespace) && import_typescript.default.isPropertyAccessExpression(namespace.expression) && namespace.expression.name.text === "env" && namespace.expression.expression.kind === import_typescript.default.SyntaxKind.ThisKeyword) {
+      const targets = bindings.get(namespace.name.text);
+      if (targets?.size === 1) {
+        const candidates = classes.get([...targets][0]) ?? [];
+        return candidates.length === 1 ? candidates : [];
+      }
+    }
+    const fn = valueDeclaration(resolvedSymbol(callee.name, checker));
+    return fn && (import_typescript.default.isMethodDeclaration(fn) || import_typescript.default.isFunctionDeclaration(fn)) ? returnExpressions(fn).flatMap((value) => rpcClasses(value, checker, depth + 1)) : [];
+  };
+  const add = (node, via) => {
+    if (!node || !available.has(node.getSourceFile().fileName))
+      return;
+    const id = identity(root, node);
+    if (reached.has(id))
+      return;
+    if (reached.size >= maxSymbols) {
+      if (!warnings.includes("symbol closure budget reached"))
+        warnings.push("symbol closure budget reached");
+      return;
+    }
+    reached.set(id, { ...coordinate(root, node), id, name: named(node)?.getText() ?? import_typescript.default.SyntaxKind[node.kind], ...via ? { via } : {} });
+    nodes.set(id, node);
+    queue.push(node);
+  };
+  const seedImportUses = (declaration, source) => {
+    const clause = declaration.importClause;
+    if (!clause)
+      return;
+    const bindings2 = [
+      clause.name,
+      ...clause.namedBindings && import_typescript.default.isNamespaceImport(clause.namedBindings) ? [clause.namedBindings.name] : [],
+      ...clause.namedBindings && import_typescript.default.isNamedImports(clause.namedBindings) ? clause.namedBindings.elements.map((element) => element.name) : []
+    ].filter((name) => Boolean(name));
+    const checker = ctx.checkerFor(source.fileName);
+    const symbols = new Set(bindings2.map((name) => checker?.getSymbolAtLocation(name)).filter(Boolean));
+    const names = new Set(bindings2.map((name) => name.text));
+    const visit = (node) => {
+      if (import_typescript.default.isImportDeclaration(node))
+        return;
+      if (import_typescript.default.isIdentifier(node) && names.has(node.text) && (checker ? symbols.has(checker.getSymbolAtLocation(node)) : true))
+        add(enclosing(node));
+      import_typescript.default.forEachChild(node, visit);
+    };
+    visit(source);
+  };
+  for (const range of ranges) {
+    const source = files.find((file) => coordinate(root, file).path === range.path);
+    if (!source)
+      continue;
+    const starts = source.getLineStarts();
+    if (range.endLine - range.line > 5000)
+      warnings.push(`changed-line budget reached: ${range.path}`);
+    for (let line = range.line;line <= Math.min(range.endLine, range.line + 5000, starts.length); line++) {
+      let position = starts[line - 1] + (range.startColumn !== undefined && line === range.line ? range.startColumn - 1 : 0);
+      while (position < source.text.length && /[ \t]/.test(source.text[position]))
+        position++;
+      let innermost = source;
+      const find = (node) => {
+        if (node.getFullStart() <= position && position < node.getEnd()) {
+          innermost = node;
+          import_typescript.default.forEachChild(node, find);
+        }
+      };
+      find(source);
+      let importDeclaration = innermost;
+      while (importDeclaration && !import_typescript.default.isImportDeclaration(importDeclaration) && !import_typescript.default.isSourceFile(importDeclaration))
+        importDeclaration = importDeclaration.parent;
+      if (importDeclaration && import_typescript.default.isImportDeclaration(importDeclaration)) {
+        seedImportUses(importDeclaration, source);
+        continue;
+      }
+      let seed = enclosing(innermost);
+      if (!seed) {
+        const findDeclaration = (node) => {
+          if (seed)
+            return;
+          const startLine = source.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+          if (startLine > line || source.getLineAndCharacterOfPosition(node.getEnd()).line + 1 < line)
+            return;
+          if (owner(node))
+            seed = node;
+          else
+            import_typescript.default.forEachChild(node, findDeclaration);
+        };
+        import_typescript.default.forEachChild(source, findDeclaration);
+      }
+      if (range.addedOnly)
+        while (seed && !import_typescript.default.isFunctionLike(seed))
+          seed = enclosing(seed.parent);
+      add(seed);
+    }
+  }
+  const references = new Map;
+  for (const source of files) {
+    const checker = ctx.checkerFor(source.fileName);
+    if (!checker)
+      continue;
+    const visit = (node) => {
+      if (import_typescript.default.isIdentifier(node) || import_typescript.default.isStringLiteralLike(node)) {
+        const symbol = resolvedSymbol(node, checker);
+        const declarations = [...symbol?.declarations ?? []];
+        if (import_typescript.default.isIdentifier(node) && import_typescript.default.isPropertyAccessExpression(node.parent) && node.parent.name === node && import_typescript.default.isCallExpression(node.parent.parent) && node.parent.parent.expression === node.parent) {
+          for (const cls of rpcClasses(node.parent.expression, checker)) {
+            for (const member of cls.members)
+              if (import_typescript.default.isMethodDeclaration(member) && member.name.getText() === node.text)
+                declarations.push(member);
+          }
+        }
+        for (const declaration of new Set(declarations)) {
+          if (!available.has(declaration.getSourceFile().fileName))
+            continue;
+          const id = identity(root, declaration);
+          const list = references.get(id) ?? [];
+          list.push(node);
+          references.set(id, list);
+        }
+      }
+      import_typescript.default.forEachChild(node, visit);
+    };
+    visit(source);
+  }
+  let visits = 0;
+  for (let index = 0;index < queue.length; index++) {
+    const node = queue[index], id = identity(root, node);
+    if (import_typescript.default.isMethodDeclaration(node)) {
+      const cls = enclosing(node.parent);
+      if (cls && import_typescript.default.isClassLike(cls) && extracted.callSites.some((site) => contains(root, cls, site.path, site.line, site.col) && !contains(root, node, site.path, site.line, site.col))) {
+        boundaryClasses.add(cls);
+        add(cls, id);
+      }
+    }
+    if (import_typescript.default.isVariableDeclaration(node) && (import_typescript.default.isArrayBindingPattern(node.name) || import_typescript.default.isObjectBindingPattern(node.name))) {
+      const bindings2 = (pattern) => {
+        for (const element of pattern.elements)
+          if (import_typescript.default.isBindingElement(element)) {
+            add(element, id);
+            if (import_typescript.default.isArrayBindingPattern(element.name) || import_typescript.default.isObjectBindingPattern(element.name))
+              bindings2(element.name);
+          }
+      };
+      bindings2(node.name);
+    }
+    if ((import_typescript.default.isArrowFunction(node) || import_typescript.default.isFunctionExpression(node)) && owner(node.parent))
+      add(node.parent, id);
+    for (const reference of boundaryClasses.has(node) ? [] : references.get(id) ?? []) {
+      visits++;
+      if (visits > maxReferences) {
+        warnings.push("reference closure budget reached");
+        break;
+      }
+      if (reference === named(node))
+        continue;
+      add(enclosing(reference), id);
+    }
+    if (visits > maxReferences)
+      break;
+    if (import_typescript.default.isPropertyAssignment(node) || import_typescript.default.isPropertyDeclaration(node) || import_typescript.default.isParameter(node))
+      add(enclosing(node.parent), id);
+  }
+  const affected = (path, line, col, offset) => [...nodes.values()].some((node) => contains(root, node, path, line, col, offset));
+  return {
+    symbols: [...reached.values()],
+    callsites: extracted.callSites.filter((site) => !site.isTest && !site.isEval && affected(site.path, site.line, site.col)).map((site) => site.id),
+    toolIds: extracted.toolDefinitions.filter((tool) => affected(tool.definition.path, tool.definition.line, undefined, tool.definition.start) || ranges.some((range) => range.path === tool.definition.path && range.line <= tool.definition.line && range.endLine >= tool.definition.line)).map((tool) => tool.toolId),
+    warnings
+  };
+}
+
+// src/change-impact.ts
+function descendants(tree) {
+  return [
+    tree,
+    ...(tree.children ?? []).flatMap(descendants),
+    ...(tree.bindings ?? []).flatMap(descendants),
+    ...tree.callee ? descendants(tree.callee) : []
+  ];
+}
+var overlaps = (a, b) => a.path === b.path && a.line <= b.endLine && b.line <= a.endLine;
+var normalize = (text) => text.replace(/\s+/g, " ").trim().toLowerCase();
+function changedOldRanges(diff) {
+  const ranges = [];
+  let path;
+  let pending;
+  const finish = () => {
+    if (!pending || pending.range.addedOnly || pending.range.line !== pending.range.endLine || pending.old.length !== 1 || pending.next.length !== 1)
+      return;
+    const before = pending.old[0], after = pending.next[0];
+    let prefix = 0, suffix = 0;
+    while (prefix < Math.min(before.length, after.length) && before[prefix] === after[prefix])
+      prefix++;
+    while (suffix < Math.min(before.length, after.length) - prefix && before[before.length - suffix - 1] === after[after.length - suffix - 1])
+      suffix++;
+    pending.range.startColumn = prefix + 1;
+    pending.range.endColumn = before.length - suffix + 1;
+  };
+  for (const line of diff.split(`
+`)) {
+    if (line.startsWith("diff --git ")) {
+      finish();
+      pending = undefined;
+      path = undefined;
+    }
+    if (line.startsWith("--- a/"))
+      path = line.slice(6);
+    if (line.startsWith('--- "'))
+      throw new Error("Quoted diff paths are unsupported; use paths without tabs or newlines.");
+    const hunk = /^@@ -(\d+)(?:,(\d+))? \+\d+(?:,\d+)? @@/.exec(line);
+    if (hunk) {
+      finish();
+      pending = undefined;
+      if (!path)
+        continue;
+      const count = hunk[2] === undefined ? 1 : Number(hunk[2]);
+      const start = Math.max(1, Number(hunk[1]));
+      const range = { path, line: start, endLine: count ? start + count - 1 : start, ...count ? {} : { addedOnly: true } };
+      ranges.push(range);
+      pending = { range, old: [], next: [] };
+    } else if (pending && line.startsWith("-") && !line.startsWith("--- "))
+      pending.old.push(line.slice(1));
+    else if (pending && line.startsWith("+") && !line.startsWith("+++ "))
+      pending.next.push(line.slice(1));
+  }
+  finish();
+  return ranges;
+}
+function changedNode(node, range, ctx) {
+  if (range.addedOnly || !overlaps(node, range))
+    return false;
+  if (range.startColumn === undefined || range.endColumn === undefined || !ctx)
+    return true;
+  const source = ctx.nodeAt({ path: node.path, start: node.start, end: node.end })?.getSourceFile();
+  if (!source)
+    return true;
+  const start = source.getPositionOfLineAndCharacter(range.line - 1, range.startColumn - 1);
+  const end = source.getPositionOfLineAndCharacter(range.endLine - 1, range.endColumn - 1);
+  return start === end ? node.start <= start && node.end >= end : node.start < end && node.end > start;
+}
+var LOG_CALL = /^(?:console|logger|log|Sentry)$|^(?:log|warn|error|info|debug|trace|captureException|captureMessage)$/;
+var MODEL_KEY = /^(?:model|modelId|model_id|provider)$/;
+function nonPromptLiteral(node) {
+  let child = node;
+  for (let parent = node.parent;parent; child = parent, parent = parent.parent) {
+    if (import_typescript2.default.isParenthesizedExpression(parent) || import_typescript2.default.isAsExpression(parent) || import_typescript2.default.isTemplateSpan(parent) || import_typescript2.default.isTemplateExpression(parent) || import_typescript2.default.isBinaryExpression(parent) && parent.operatorToken.kind === import_typescript2.default.SyntaxKind.PlusToken)
+      continue;
+    if (import_typescript2.default.isThrowStatement(parent) || import_typescript2.default.isCaseClause(parent) || import_typescript2.default.isElementAccessExpression(parent))
+      return true;
+    if (import_typescript2.default.isBinaryExpression(parent))
+      return [
+        import_typescript2.default.SyntaxKind.EqualsEqualsEqualsToken,
+        import_typescript2.default.SyntaxKind.ExclamationEqualsEqualsToken,
+        import_typescript2.default.SyntaxKind.EqualsEqualsToken,
+        import_typescript2.default.SyntaxKind.ExclamationEqualsToken
+      ].includes(parent.operatorToken.kind);
+    if (import_typescript2.default.isNewExpression(parent))
+      return /Error$/.test(parent.expression.getText());
+    if (import_typescript2.default.isCallExpression(parent) && parent.expression !== child) {
+      const chain = calleeChain(parent.expression) ?? [];
+      return chain.some((part) => LOG_CALL.test(part)) && (LOG_CALL.test(chain[0] ?? "") || LOG_CALL.test(chain[chain.length - 1] ?? ""));
+    }
+    if (import_typescript2.default.isPropertyAssignment(parent))
+      return MODEL_KEY.test(parent.name.getText());
+    return false;
+  }
+  return false;
+}
+function sliceChangeImpact(extracted, ranges, affectedCallsites = new Set, agentForScope = () => [], ctx, budget = {}) {
+  const units = new Map;
+  let textBytes = 0;
+  const literalOnlyRanges = new Set;
+  const contextPerSite = new Map;
+  let contextUnits = 0;
+  const store = (unit) => {
+    const key = JSON.stringify(unit);
+    if (units.has(key))
+      return true;
+    const bytes = Buffer.byteLength(unit.oldText, "utf8");
+    if (unit.via === "symbol-reference") {
+      const perSite = contextPerSite.get(unit.callsite) ?? 0;
+      if (perSite >= (budget.maxContextPerCallsite ?? 20) || contextUnits >= (budget.maxContextUnits ?? 400)) {
+        budget.contextTruncated = true;
+        return false;
+      }
+      contextPerSite.set(unit.callsite, perSite + 1);
+    }
+    if (units.size >= (budget.maxUnits ?? 2000) || textBytes + bytes > (budget.maxTextBytes ?? 2 * 1024 * 1024)) {
+      if (unit.via === "changed-text")
+        budget.truncated = true;
+      else
+        budget.contextTruncated = true;
+      return false;
+    }
+    if (unit.via === "symbol-reference")
+      contextUnits++;
+    units.set(key, unit);
+    textBytes += bytes;
+    return true;
+  };
+  if (ctx)
+    for (const path of new Set(ranges.filter((range) => !range.addedOnly).map((range) => range.path))) {
+      const source = ctx.sourceFiles().find((source2) => relPath(ctx.rootDir, source2.fileName) === path);
+      if (!source)
+        continue;
+      const visit = (node) => {
+        const line = source.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+        const endLine = source.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
+        const location = { path, line, endLine, start: node.getStart(), end: node.getEnd() };
+        if (!ranges.some((range) => overlaps(location, range)))
+          return;
+        const parts = import_typescript2.default.isTemplateExpression(node) ? [node.head.text, ...node.templateSpans.map((span) => span.literal.text)] : undefined;
+        const text = import_typescript2.default.isStringLiteralLike(node) ? node.text : parts?.join("{{slot}}");
+        if (import_typescript2.default.isStringLiteralLike(node))
+          for (const range of ranges) {
+            if (range.path !== path || range.addedOnly || range.line !== range.endLine || range.startColumn === undefined || range.endColumn === undefined)
+              continue;
+            const start = source.getPositionOfLineAndCharacter(range.line - 1, range.startColumn - 1);
+            const end = source.getPositionOfLineAndCharacter(range.line - 1, range.endColumn - 1);
+            if (node.getStart() <= start && node.getEnd() >= end)
+              literalOnlyRanges.add(range);
+          }
+        if (text && normalize(text) && ranges.some((range) => changedNode(location, range, ctx)) && !(import_typescript2.default.isPropertyAssignment(node.parent) && node.parent.name === node) && !(import_typescript2.default.isImportDeclaration(node.parent) || import_typescript2.default.isExportDeclaration(node.parent)) && !nonPromptLiteral(node)) {
+          const tools = extracted.toolDefinitions.filter((tool) => tool.definition.path === path && tool.definition.start <= node.getStart() && tool.definition.end >= node.getEnd());
+          const implementationText = tools.some((tool) => {
+            for (let parent = node.parent;parent && parent.getStart() >= tool.definition.start; parent = parent.parent) {
+              if (import_typescript2.default.isFunctionLike(parent))
+                return true;
+              if (parent.getStart() === tool.definition.start)
+                break;
+            }
+            return false;
+          });
+          for (const site of implementationText ? [] : extracted.callSites.filter((site2) => affectedCallsites.has(site2.id) && !site2.isTest && !site2.isEval)) {
+            const agents = site.agentIds ?? agentForScope(site.scope);
+            const sameOwnerTools = tools.filter((tool) => (tool.agentIds ?? agentForScope(tool.scope)).some((id) => agents.includes(id)));
+            const role = sameOwnerTools.length ? "tools" : site.promptArgs.some((arg) => ["system", "instructions", "messages"].includes(arg.role)) ? "instructions" : undefined;
+            if (role)
+              store({
+                path,
+                line,
+                endLine,
+                callsite: site.id,
+                scope: site.scope,
+                role,
+                oldText: text,
+                ...parts ? { literalParts: parts } : {},
+                agentIds: agents,
+                toolIds: sameOwnerTools.map((tool) => tool.toolId),
+                via: "changed-text",
+                evidence: "reference-closure"
+              });
+          }
+        }
+        if (!import_typescript2.default.isTemplateExpression(node))
+          import_typescript2.default.forEachChild(node, visit);
+      };
+      import_typescript2.default.forEachChild(source, visit);
+    }
+  if (ctx) {
+    const sites = extracted.callSites.filter((site) => affectedCallsites.has(site.id) && !site.isTest && !site.isEval);
+    const selected = sites.slice(0, 100);
+    if (sites.length > selected.length)
+      budget.truncated = true;
+    const resolution = resolvePromptArguments(selected, ctx, { keepAll: true });
+    const touchedLiterals = (range) => {
+      if (range.line !== range.endLine || range.startColumn === undefined || range.endColumn === undefined)
+        return;
+      const source = ctx.sourceFiles().find((file) => relPath(ctx.rootDir, file.fileName) === range.path);
+      if (!source)
+        return;
+      const start = source.getPositionOfLineAndCharacter(range.line - 1, range.startColumn - 1);
+      const end = source.getPositionOfLineAndCharacter(range.line - 1, range.endColumn - 1);
+      const texts = [];
+      const visit = (node) => {
+        if (node.getEnd() < start || node.getStart() > end)
+          return;
+        const touches = start === end ? node.getStart() <= start && node.getEnd() >= end : node.getStart() < end && node.getEnd() > start;
+        if (touches && import_typescript2.default.isStringLiteralLike(node))
+          texts.push(node.text);
+        else if (touches && import_typescript2.default.isTemplateExpression(node))
+          texts.push(...[node.head, ...node.templateSpans.map((span) => span.literal)].filter((part) => part.getStart() < end && part.getEnd() > start).map((part) => part.text));
+        else
+          import_typescript2.default.forEachChild(node, visit);
+      };
+      visit(source);
+      const found = texts.map(normalize).filter(Boolean);
+      return found.length ? found : undefined;
+    };
+    const refChanged = (ref) => ranges.some((range) => {
+      if (range.addedOnly || !overlaps(ref, range))
+        return false;
+      const literals = touchedLiterals(range);
+      return !literals || literals.some((text) => normalize(ref.text).includes(text));
+    });
+    for (const ref of resolution.refs) {
+      if (!refChanged(ref) || !normalize(ref.text))
+        continue;
+      for (const id of ref.callSiteIds) {
+        const site = selected.find((site2) => site2.id === id);
+        if (!site)
+          continue;
+        store({
+          path: ref.path,
+          line: ref.line,
+          endLine: ref.endLine,
+          callsite: id,
+          scope: site.scope,
+          role: ref.role,
+          oldText: ref.text,
+          ...ref.text.includes("{{") ? { literalParts: ref.text.split(/\{\{[^}]*\}\}/) } : {},
+          agentIds: site.agentIds ?? agentForScope(site.scope),
+          toolIds: [],
+          via: "changed-text"
+        });
+      }
+    }
+  }
+  for (const directOnly of literalOnlyRanges.size === ranges.length && ranges.length ? [true] : [true, false]) {
+    for (const role of extracted.roles) {
+      if (role.sink.isTest || role.sink.isEval)
+        continue;
+      for (const node of descendants(role.tree)) {
+        const changed = ranges.some((range) => changedNode(node, range, ctx));
+        if (changed !== directOnly || !changed && !affectedCallsites.has(role.sink.id))
+          continue;
+        const texts = node.kind === "literal" && !node.note ? [node.text ?? ""] : node.kind === "template" && node.parts?.some((part) => normalize(part)) ? [node.parts.join("{{slot}}")] : [];
+        for (const oldText of texts) {
+          if (!normalize(oldText))
+            continue;
+          const unit = {
+            path: node.path,
+            line: node.line,
+            endLine: node.endLine,
+            callsite: role.sink.id,
+            scope: role.sink.scope,
+            role: role.role,
+            oldText,
+            ...node.kind === "template" ? { literalParts: node.parts } : {},
+            agentIds: role.sink.agentIds ?? agentForScope(role.sink.scope),
+            toolIds: role.role === "tools" ? extracted.toolDefinitions.filter((tool) => tool.definition.path === node.path && tool.definition.start <= node.start && tool.definition.end >= node.end).map((tool) => tool.toolId) : [],
+            via: changed ? "changed-text" : "symbol-reference"
+          };
+          store(unit);
+        }
+      }
+    }
+    if (ctx)
+      for (const tool of extracted.toolDefinitions) {
+        const definition = ctx.nodeAt(tool.definition);
+        if (!definition)
+          continue;
+        const agentIds = tool.agentIds ?? agentForScope(tool.scope);
+        const sites = extracted.callSites.filter((site) => affectedCallsites.has(site.id) && (agentIds.length ? (site.agentIds ?? agentForScope(site.scope)).some((id) => agentIds.includes(id)) : site.scope === tool.scope));
+        if (!sites.length)
+          continue;
+        const visit = (node) => {
+          if (import_typescript2.default.isFunctionLike(node))
+            return;
+          if ((import_typescript2.default.isPropertyAssignment(node) || import_typescript2.default.isMethodDeclaration(node)) && /^(execute|handler|run)$/.test(node.name.getText()))
+            return;
+          const parts = import_typescript2.default.isTemplateExpression(node) ? [node.head.text, ...node.templateSpans.map((span) => span.literal.text)] : undefined;
+          const text = import_typescript2.default.isStringLiteralLike(node) ? node.text : parts?.some((part) => normalize(part)) ? parts.join("{{slot}}") : undefined;
+          if (text !== undefined && !(import_typescript2.default.isPropertyAssignment(node.parent) && node.parent.name === node)) {
+            const source = node.getSourceFile();
+            const range = {
+              path: tool.definition.path,
+              line: source.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+              endLine: source.getLineAndCharacterOfPosition(node.getEnd()).line + 1
+            };
+            for (const site of sites) {
+              const unit = {
+                ...range,
+                callsite: site.id,
+                scope: site.scope,
+                role: "tools",
+                oldText: text,
+                ...parts ? { literalParts: parts } : {},
+                agentIds: (site.agentIds ?? agentForScope(site.scope)).filter((id) => !agentIds.length || agentIds.includes(id)),
+                toolIds: [tool.toolId],
+                via: ranges.some((changed) => changedNode({ ...range, start: node.getStart(), end: node.getEnd() }, changed, ctx)) ? "changed-text" : "symbol-reference"
+              };
+              if (unit.via === "changed-text" === directOnly)
+                store(unit);
+            }
+          }
+          import_typescript2.default.forEachChild(node, visit);
+        };
+        visit(definition);
+      }
+  }
+  return [...units.values()];
+}
+function unitTextMatches(unit, text) {
+  const haystack = normalize(text);
+  let cursor = 0;
+  for (const part of unit.literalParts ?? [unit.oldText]) {
+    const needle = normalize(part);
+    if (!needle)
+      continue;
+    const at = haystack.indexOf(needle, cursor);
+    if (at < 0)
+      return false;
+    cursor = at + needle.length;
+  }
+  return true;
+}
+var replayRole = (role) => ["tools", "system", "developer", "instructions", "prompt"].includes(role);
+function replayCandidates(units, calls) {
+  const result = new Map;
+  const directSites = new Set(units.filter((unit) => unit.via === "changed-text" && replayRole(unit.role)).map((unit) => unit.callsite));
+  for (const call of calls) {
+    if (call.candidate.status !== "ready")
+      continue;
+    const matches = units.filter((unit) => {
+      if (directSites.has(unit.callsite) && unit.via !== "changed-text")
+        return false;
+      if (call.agentIds?.length && unit.agentIds.length && !unit.agentIds.some((id) => call.agentIds.includes(id)))
+        return false;
+      const sections = unit.role === "tools" ? call.tools : ["system", "developer", "instructions", "prompt"].includes(unit.role) ? call.sections : [];
+      return sections.some((section) => section.sources.some((source) => overlaps(source, unit)) && unitTextMatches(unit, section.text));
+    });
+    if (matches.length)
+      result.set(call.candidate.span_id, {
+        ...call.candidate,
+        reason: `Old source text matched ${matches.length} source-proven instruction/tool unit(s).`
+      });
+  }
+  return [...result.values()];
+}
+function joinRecordedTools(tools, units, definitions, agentIds, catalog = tools) {
+  const strings = (value) => {
+    if (typeof value === "string")
+      return [value];
+    if (Array.isArray(value))
+      return value.flatMap(strings);
+    return value && typeof value === "object" ? Object.values(value).flatMap(strings) : [];
+  };
+  return definitions.flatMap((recorded) => {
+    const matches = catalog.filter((tool2) => tool2.name === recorded.name && (!agentIds?.length || tool2.agentIds.some((id) => agentIds.includes(id))));
+    const distinct = [...new Map(matches.map((tool2) => [`${tool2.id}:${tool2.path}:${tool2.line}`, tool2])).values()];
+    if (distinct.length !== 1 || !tools.some((tool2) => tool2.id === distinct[0].id))
+      return [];
+    const tool = distinct[0];
+    let definition = recorded.definition;
+    if (typeof definition === "string") {
+      try {
+        definition = JSON.parse(definition);
+      } catch {
+        return [];
+      }
+    }
+    const text = strings(definition).join(`
+`);
+    const sources = units.filter((unit) => unit.role === "tools" && unit.toolIds.includes(tool.id) && unit.path === tool.path && (!agentIds?.length || unit.agentIds.some((id) => agentIds.includes(id))) && normalize(unit.oldText) && unitTextMatches(unit, text)).map((unit) => ({ path: unit.path, line: unit.line, endLine: unit.endLine }));
+    return sources.length ? [{ text, sources }] : [];
+  });
+}
+var SNAPSHOT_SOURCE = /\.(?:[cm]?[jt]sx?|svelte|jsonc?|md|txt|ya?ml|toml)$/i;
+function diffWithout(diff, paths) {
+  const out = [];
+  let section = [];
+  let drop = false;
+  const flush = () => {
+    if (!drop)
+      out.push(...section);
+    section = [];
+    drop = false;
+  };
+  const lines = diff.split(`
+`);
+  lines.forEach((line, i) => {
+    const starts = line.startsWith("diff --git ") || line.startsWith("--- ") && lines[i + 1]?.startsWith("+++ ") === true && section.some((l) => l.startsWith("--- "));
+    if (starts)
+      flush();
+    if (line.startsWith("--- a/") && paths.has(line.slice(6)))
+      drop = true;
+    section.push(line);
+  });
+  flush();
+  return out.join(`
+`);
+}
+var NON_PROMPT_ASSET = /\.(?:css|scss|sass|less|png|jpe?g|gif|webp|avif|ico|bmp|tiff?|svg|mp[34]|mov|webm|wav|ogg|woff2?|ttf|otf|eot|pdf|zip|gz|map)$/i;
+function assertNoLinks(dir) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory())
+      assertNoLinks(path);
+    else if (!entry.isFile() || lstatSync(path).isSymbolicLink())
+      throw new Error(`Refusing a non-regular file in the source snapshot: ${entry.name}`);
+  }
+}
+function localChangeImpact(options) {
+  if (options.to && options.diff !== undefined)
+    throw new Error("Supply either --to or --diff, not both.");
+  const started = performance.now();
+  const checkout = resolve(options.checkout);
+  const git = (args) => execFileSync("git", ["-C", checkout, ...args], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+  const from = git(["rev-parse", "--verify", "--end-of-options", `${options.from}^{commit}`]).trim();
+  const to = options.to ? git(["rev-parse", "--verify", "--end-of-options", `${options.to}^{commit}`]).trim() : undefined;
+  if (!to && options.diff === undefined)
+    throw new Error("Supply --to or --diff with an explicit old-side --from revision.");
+  const skippedFiles = [];
+  const ignoredFiles = [];
+  let diff = options.diff;
+  const size = (revision, path) => {
+    const output = execFileSync("git", ["-C", checkout, "cat-file", "--batch-check=%(objectsize)"], {
+      input: `${revision}:${path}
+`,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: 1024 * 1024
+    }).trim();
+    const bytes = Number(output);
+    return Number.isFinite(bytes) ? bytes : 0;
+  };
+  if (diff !== undefined) {
+    const paths = [...new Set(changedOldRanges(diff).map((range) => range.path))];
+    const dropped = new Set;
+    for (const path of paths) {
+      if (NON_PROMPT_ASSET.test(path)) {
+        ignoredFiles.push(path);
+        dropped.add(path);
+      } else if (!SNAPSHOT_SOURCE.test(path)) {
+        skippedFiles.push({ path, reason: "unsupported source format" });
+        dropped.add(path);
+      } else if (size(from, path) > 1024 * 1024) {
+        skippedFiles.push({ path, reason: "source size budget exceeded" });
+        dropped.add(path);
+      }
+    }
+    if (dropped.size)
+      diff = diffWithout(diff, dropped);
+  } else {
+    const paths = git(["diff", "--name-only", "--no-renames", "-z", from, to, "--"]).split("\x00").filter(Boolean);
+    const selected = [];
+    let bytes = 0;
+    for (const path of paths) {
+      if (!/[\r\n]/.test(path) && NON_PROMPT_ASSET.test(path)) {
+        ignoredFiles.push(path);
+        continue;
+      }
+      if (/[\r\n]/.test(path) || !SNAPSHOT_SOURCE.test(path)) {
+        skippedFiles.push({ path, reason: "unsupported source format" });
+        continue;
+      }
+      const oldBytes = size(from, path), newBytes = size(to, path);
+      if (Math.max(oldBytes, newBytes) > 1024 * 1024 || bytes + oldBytes + newBytes > 16 * 1024 * 1024) {
+        skippedFiles.push({ path, reason: "source size budget exceeded" });
+        continue;
+      }
+      bytes += oldBytes + newBytes;
+      selected.push(`:(literal)${path}`);
+    }
+    diff = selected.length ? git(["diff", "--no-ext-diff", "--no-textconv", "--unified=0", "--no-renames", from, to, "--", ...selected]) : "";
+  }
+  const ranges = changedOldRanges(diff);
+  const temporary = mkdtempSync(join(tmpdir(), "moda-impact-"));
+  try {
+    const tree = join(temporary, "checkout");
+    if (ranges.length) {
+      mkdirSync(tree);
+      const archive = join(temporary, "source.tar.gz");
+      const entries = git(["ls-tree", "-rl", "-z", from]).split("\x00").filter(Boolean);
+      const paths = entries.flatMap((entry) => {
+        const match = /^100(?:644|755) blob [a-f0-9]+\s+(\d+)\t([\s\S]+)$/.exec(entry);
+        return match && Number(match[1]) <= 1024 * 1024 && /\.(?:[cm]?[jt]sx?|svelte|jsonc?|md|txt|ya?ml|toml|prompt|hbs|jinja2?)$/i.test(match[2]) ? [match[2]] : [];
+      });
+      if (paths.length) {
+        execFileSync("git", ["-C", checkout, "archive", "--format=tar.gz", `--output=${archive}`, from, "--", ...paths.map((path) => `:(literal)${path}`)]);
+        execFileSync("tar", ["-xzf", archive, "-C", tree]);
+        assertNoLinks(tree);
+      }
+      const archived = new Set(paths);
+      const reported = new Set(skippedFiles.map((file) => file.path));
+      for (const path of new Set(ranges.map((range) => range.path))) {
+        if (!archived.has(path) && !reported.has(path))
+          skippedFiles.push({ path, reason: "not a regular file in the old revision" });
+      }
+    }
+    const output = ranges.length ? extractHarnessWithContext(tree, { status: false, fresh: true }) : undefined;
+    const extracted = output?.result;
+    const closure = output ? referenceClosure(output.ctx, output.result, ranges, options.limits) : { symbols: [], callsites: [], toolIds: [], warnings: [] };
+    const owners = output ? enumerateAgents(output.result, output.ctx) : undefined;
+    const unitBudget = { ...options.limits };
+    const units = extracted ? sliceChangeImpact(extracted, ranges, new Set(closure.callsites), owners?.agentForScope, output?.ctx, unitBudget) : [];
+    const agentIds = new Set(units.flatMap((unit) => unit.agentIds));
+    const toolIds = new Set([...closure.toolIds, ...units.flatMap((unit) => unit.toolIds)]);
+    const catalog = extracted?.toolDefinitions.map((tool) => ({
+      id: tool.toolId,
+      name: tool.name,
+      path: tool.definition.path,
+      line: tool.definition.line,
+      agentIds: tool.agentIds ?? owners?.agentForScope(tool.scope) ?? [],
+      scope: tool.scope
+    })) ?? [];
+    const tools = catalog.filter((tool) => toolIds.has(tool.id));
+    const calls = (options.calls ?? []).filter((call) => call.sourceCommit === from).map((call) => ({
+      ...call,
+      tools: [...call.tools, ...joinRecordedTools(tools, units, call.toolDefinitions ?? [], call.agentIds, catalog)]
+    }));
+    return {
+      schemaVersion: 1,
+      from,
+      to: to ?? null,
+      durationMs: Math.round(performance.now() - started),
+      ranges,
+      skippedFiles,
+      ignoredFiles,
+      units,
+      closure,
+      unitSliceTruncated: unitBudget.truncated ?? false,
+      contextTruncated: unitBudget.contextTruncated ?? false,
+      agents: owners?.runtimeAgents.filter((agent) => agentIds.has(agent.id)) ?? [],
+      tools,
+      candidates: replayCandidates(units, calls),
+      warnings: [...extracted?.warnings ?? [], ...closure.warnings, ...unitBudget.truncated ? ["impact unit/text budget reached; result is incomplete"] : [], ...skippedFiles.length ? [`${skippedFiles.length} changed file(s) outside supported source/size budgets`] : []],
+      limitations: [
+        "TypeScript/JavaScript extractor only; dynamic unresolved values are not attributed. Source snapshots omit assets and files above 1 MiB.",
+        "Calls with a sourceCommit different from the resolved old commit are excluded. Additions use old enclosing context, not invented old text. Call records must carry same-agent backend source proofs.",
+        "No production precision/recall measurement is implied by this local result."
+      ]
+    };
+  } finally {
+    clearExtractCache(join(temporary, "checkout"));
+    rmSync(temporary, { recursive: true, force: true });
+  }
+}
+var sourceSchema = z.object({ path: z.string().min(1), line: z.number().int().positive(), endLine: z.number().int().positive() }).refine((source) => source.endLine >= source.line, "endLine must be at least line");
+var recordedCallSchema = z.object({
+  agentIds: z.array(z.string()).optional(),
+  toolDefinitions: z.array(z.object({ name: z.string(), definition: z.unknown() })).optional(),
+  sourceCommit: z.string().regex(/^[a-f0-9]{40,64}$/),
+  candidate: z.object({
+    id: z.string(),
+    conversation_id: z.string().min(1),
+    span_id: z.string().min(1),
+    started_at: z.string(),
+    model: z.string(),
+    status: z.enum(["ready", "skipped"]),
+    reason: z.string(),
+    ask: z.string(),
+    tail: z.array(z.object({ role: z.string(), text: z.string() })),
+    production: z.object({ text: z.string(), toolCalls: z.array(z.object({ name: z.string(), args: z.unknown() })) })
+  }).passthrough(),
+  sections: z.array(z.object({ text: z.string(), sources: z.array(sourceSchema) })),
+  tools: z.array(z.object({ text: z.string(), sources: z.array(sourceSchema) }))
+});
+function readRecordedImpactCalls(path) {
+  return z.array(recordedCallSchema).parse(JSON.parse(readFileSync(path, "utf8")));
+}
+export {
+  sliceChangeImpact,
+  replayCandidates,
+  readRecordedImpactCalls,
+  nonPromptLiteral,
+  localChangeImpact,
+  joinRecordedTools,
+  changedOldRanges
+};