@mrclrchtr/supi-code-intelligence 1.16.1 → 2.0.1

package/src/tool/impact/execute.ts

@@ -0,0 +1,98 @@
+/**
+ * Tool executor for code_impact — blast radius and downstream impact.
+ */
+
+import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
+import { focusedToolRules } from "../infra/cross-field.ts";
+import { impactErrorResult } from "../infra/error-results.ts";
+import {
+  expandTargetId,
+  gateCapability,
+  gateSemanticReadiness,
+  runPipe,
+  validateParams,
+} from "../infra/pipeline.ts";
+import { emitToolProgress } from "../infra/progress.ts";
+import { renderSemanticReadinessTimeout } from "../infra/readiness-message.ts";
+import { executeImpact } from "./orchestrate.ts";
+
+export interface CodeImpactToolParams {
+  targetId?: string;
+  file?: string;
+  line?: number;
+  character?: number;
+  symbol?: string;
+  exportedOnly?: boolean;
+  maxResults?: number;
+  change?: string;
+  changeSetFiles?: string[];
+  includeTests?: boolean;
+}
+
+/** Execute the public code_impact tool. */
+export async function executeImpactTool(
+  params: CodeImpactToolParams,
+  ctx: CodeIntelToolExecCtx,
+): Promise<CodeIntelResult> {
+  emitToolProgress(ctx.onUpdate, "code_impact: analyzing blast radius...");
+
+  const hasChangeSetInputs = (params.changeSetFiles?.length ?? 0) > 0 || Boolean(params.change);
+
+  return runPipe(
+    params,
+    ctx,
+    [
+      expandTargetId((msg) =>
+        impactErrorResult(msg, { nextQueries: ["Use `code_resolve` to resolve a target first"] }),
+      ),
+      validateParams(focusedToolRules(), (msg) =>
+        impactErrorResult(msg, { nextQueries: ["Fix the input parameters and retry"] }),
+      ),
+      // Semantic readiness and capability only for target-based (non-changeSet) impact
+      ...(!hasChangeSetInputs
+        ? [
+            gateSemanticReadiness("code_impact", {
+              fileParam: "file",
+              onTimeout: () =>
+                impactErrorResult(renderSemanticReadinessTimeout("code_impact", 15_000), {
+                  nextQueries: ["Check `code_health` for LSP status"],
+                }),
+              onUnavailable: () =>
+                impactErrorResult(
+                  "**Error:** No semantic analysis provider is available for this workspace. Check `code_health` for LSP status or enable an LSP server.",
+                  {
+                    nextQueries: [
+                      "Use `code_resolve` to resolve a target first",
+                      "Check `code_health` for LSP status or enable an LSP server.",
+                    ],
+                  },
+                ),
+            }),
+            gateCapability("code_impact"),
+          ]
+        : []),
+    ],
+    async (p, c) => {
+      if (!p.file && !p.symbol && !hasChangeSetInputs) {
+        return impactErrorResult(
+          "**Error:** Impact analysis currently requires either anchored coordinates (`file`, `line`, `character`) or a `symbol` for discovery.",
+          { nextQueries: ["Use `code_resolve` to resolve a target first"] },
+        );
+      }
+
+      const providerState = c.session.getProviders();
+      const provider = providerState.kind === "ready" ? providerState.provider : null;
+      const lspService =
+        providerState.kind === "ready"
+          ? providerState.lspService
+          : { kind: "unavailable" as const, reason: "No provider" };
+
+      if (hasChangeSetInputs) {
+        emitToolProgress(c.onUpdate, "code_impact: analyzing impact input...");
+      } else {
+        emitToolProgress(c.onUpdate, "code_impact: sweeping references...");
+      }
+      return executeImpact(p, { cwd: c.cwd, provider, lspService });
+    },
+  );
+}

package/src/tool/impact/file-level-impact.ts

@@ -0,0 +1,81 @@
+// File-level target-group impact execution.
+// Extracted from orchestrate.ts.
+
+import { buildArchitectureModel } from "../../analysis/architecture/discovery.ts";
+import type { CodeProvider } from "../../analysis/provider.ts";
+import { aggregatePerTarget, collectReferences } from "../../analysis/references/semantic-refs.ts";
+import { summarizePrioritySignalsForFiles } from "../../analysis/signals/project.ts";
+import type { ResolvedTargetGroupData } from "../../analysis/target/types.ts";
+import { buildTestAnchorMap } from "../../analysis/tests/likely-tests.ts";
+import type { CodeIntelResult } from "../../types/index.ts";
+import { analyzeReferenceImpact, buildDetailsData, computeOmittedCount } from "./analysis.ts";
+import { renderImpactFileLevel } from "./markdown.ts";
+import type { ImpactInput } from "./types.ts";
+
+// biome-ignore lint/complexity/useMaxParams: shared impact orchestration keeps related substrate inputs explicit
+export async function executeFileLevelImpact(
+  targetGroup: ResolvedTargetGroupData,
+  input: ImpactInput,
+  cwd: string,
+  semantic: CodeProvider,
+  lspService: import("@mrclrchtr/supi-lsp/api").SessionLspServiceState,
+): Promise<CodeIntelResult> {
+  const perTarget = await Promise.all(
+    targetGroup.targets.map(async (t) => ({
+      target: t,
+      refs: await collectReferences(t, cwd, semantic),
+    })),
+  );
+
+  const aggregated = await aggregatePerTarget(targetGroup.targets, (t) =>
+    collectReferences(t, cwd, semantic),
+  );
+
+  const model = await buildArchitectureModel(cwd);
+  const analysis = await analyzeReferenceImpact(
+    aggregated,
+    model,
+    cwd,
+    input.includeTests === true,
+    semantic.references,
+    targetGroup.targets.map((t) => t.file), // seed all target files
+    buildTestAnchorMap(targetGroup.targets.map((t) => ({ file: t.file, position: t.position }))),
+    semantic.outline,
+  );
+
+  const prioritySignals = summarizePrioritySignalsForFiles(
+    cwd,
+    analysis.affectedFiles.size > 0 ? [...analysis.affectedFiles] : [targetGroup.file],
+    lspService,
+  );
+
+  const maxResults = input.maxResults ?? 8;
+  const content = renderImpactFileLevel({
+    targetGroup,
+    perTarget,
+    aggregated,
+    analysis,
+    maxResults,
+    prioritySignals,
+    cwd,
+  });
+
+  const detailsData = buildDetailsData(
+    analysis,
+    aggregated.refs.length,
+    computeOmittedCount(analysis.externalRefs, analysis.affectedFiles.size, input.maxResults),
+    [
+      "`code_orientation` on the most-affected module for deeper orientation",
+      "Use `code_inspect` with file + line + character to inspect one exported target precisely",
+    ],
+    prioritySignals,
+  );
+
+  return {
+    content,
+    details: {
+      type: "impact",
+      data: detailsData,
+    },
+  };
+}

package/src/tool/impact/markdown.ts

@@ -0,0 +1,283 @@
+// Impact markdown renderer — consumes analysis data and produces markdown content.
+
+import * as path from "node:path";
+import { readNextAround, renderReadNextSection } from "../../analysis/read-next.ts";
+import type { ReferenceCollection } from "../../analysis/references/semantic-refs.ts";
+import { formatReferenceList } from "../../analysis/references/semantic-refs.ts";
+import type { PrioritySignalsSummary } from "../../analysis/signals/project.ts";
+import { appendPrioritySignalsSection } from "../../analysis/signals/project.ts";
+import type { ResolvedTargetData, ResolvedTargetGroupData } from "../../analysis/target/types.ts";
+import type { TestSurfaceDetails } from "../../analysis/tests/test-discovery.ts";
+
+// ── Types ────────────────────────────────────────────────────────────
+
+export interface ImpactAnalysis {
+  confidence: "semantic" | "structural" | "heuristic" | "unavailable";
+  affectedFiles: Set<string>;
+  affectedModules: Set<string>;
+  downstreamCount: number;
+  checkNext: string[];
+  likelyTests: string[];
+  likelyTestCommands: string[];
+  riskLevel: "low" | "medium" | "high";
+  externalRefs: number;
+  semanticRefFiles?: string[];
+  tests?: TestSurfaceDetails;
+}
+
+interface RenderSingleParams {
+  symbolName: string;
+  refs: ReferenceCollection;
+  analysis: ImpactAnalysis;
+  maxResults: number;
+  prioritySignals: PrioritySignalsSummary | null;
+  target: ResolvedTargetData;
+  cwd: string;
+}
+
+// ── Single target renderer ───────────────────────────────────────────
+
+export function renderImpactSingle(params: RenderSingleParams): string {
+  const { symbolName, refs, analysis, maxResults, prioritySignals } = params;
+  const totalRefs = refs.refs.length + analysis.externalRefs;
+  const lines: string[] = [];
+
+  lines.push(`# Impact: \`${symbolName}\``);
+  lines.push("");
+
+  const refSummary =
+    analysis.externalRefs > 0
+      ? `${totalRefs} refs (${refs.refs.length} direct + ${analysis.externalRefs} external)`
+      : `${totalRefs} ref${totalRefs !== 1 ? "s" : ""}`;
+  lines.push(
+    `**Risk: ${analysis.riskLevel.toUpperCase()}** | ${refSummary} | ${analysis.affectedFiles.size} file${analysis.affectedFiles.size !== 1 ? "s" : ""} | ${analysis.affectedModules.size} module${analysis.affectedModules.size !== 1 ? "s" : ""} | ${analysis.downstreamCount} downstream (${analysis.confidence})`,
+  );
+  if (analysis.externalRefs > 0) {
+    lines.push(
+      "_External references are not listed individually (node_modules, .pnpm, or out-of-tree)_",
+    );
+  }
+  lines.push("");
+
+  addRiskSection(lines, analysis, totalRefs);
+  formatReferenceList(lines, refs.refs, maxResults);
+  lines.push(
+    ...renderReadNextSection([
+      readNextAround(
+        path.relative(params.cwd, params.target.file) || params.target.file,
+        params.target.displayLine,
+        "inspect the target before editing",
+      ),
+      ...refs.refs
+        .slice(0, Math.min(2, maxResults))
+        .map((ref) => readNextAround(ref.file, ref.line, "inspect a reference site")),
+    ]),
+  );
+  appendPrioritySignalsSection(lines, prioritySignals);
+  addCheckNextSection(lines, analysis.checkNext);
+  addTestsSection(lines, analysis.likelyTests, analysis.tests);
+  addLikelyTestCommandsSection(lines, analysis.likelyTestCommands);
+
+  return lines.join("\n");
+}
+
+// ── File-level target group renderer ─────────────────────────────────
+
+interface RenderFileLevelParams {
+  targetGroup: ResolvedTargetGroupData;
+  perTarget: Array<{ target: ResolvedTargetData; refs: ReferenceCollection }>;
+  aggregated: ReferenceCollection;
+  analysis: ImpactAnalysis;
+  maxResults: number;
+  prioritySignals: PrioritySignalsSummary | null;
+  cwd: string;
+}
+
+export function renderImpactFileLevel(params: RenderFileLevelParams): string {
+  const { targetGroup, perTarget, aggregated, analysis, maxResults, prioritySignals, cwd } = params;
+  const totalRefs = aggregated.refs.length + aggregated.externalCount;
+  const refSummary =
+    aggregated.externalCount > 0
+      ? `${totalRefs} refs (${aggregated.refs.length} direct + ${aggregated.externalCount} external)`
+      : `${totalRefs} ref${totalRefs !== 1 ? "s" : ""}`;
+
+  const lines: string[] = [];
+  lines.push(`# Impact: \`${targetGroup.displayName}\``);
+  lines.push("");
+  lines.push(
+    `**Risk: ${analysis.riskLevel.toUpperCase()}** | ${targetGroup.targets.length} exported target${targetGroup.targets.length !== 1 ? "s" : ""} | ${refSummary} | ${analysis.affectedFiles.size} file${analysis.affectedFiles.size !== 1 ? "s" : ""} | ${analysis.affectedModules.size} module${analysis.affectedModules.size !== 1 ? "s" : ""} | ${analysis.downstreamCount} downstream (${analysis.confidence})`,
+  );
+  lines.push("");
+
+  lines.push("## Exported Targets");
+  for (const entry of perTarget) {
+    lines.push(
+      `- \`${entry.target.name ?? "symbol"}\` — ${entry.refs.refs.length} ref${entry.refs.refs.length !== 1 ? "s" : ""}`,
+    );
+  }
+  lines.push("");
+
+  addRiskSection(lines, analysis, totalRefs);
+  formatReferenceList(lines, aggregated.refs, maxResults);
+  lines.push(
+    ...renderReadNextSection([
+      readNextAround(
+        path.relative(cwd, targetGroup.file) || targetGroup.file,
+        1,
+        "inspect the target file exports before editing",
+      ),
+      ...aggregated.refs
+        .slice(0, Math.min(2, maxResults))
+        .map((ref) => readNextAround(ref.file, ref.line, "inspect a reference site")),
+    ]),
+  );
+  appendPrioritySignalsSection(lines, prioritySignals);
+  addCheckNextSection(lines, analysis.checkNext);
+  addTestsSection(lines, analysis.likelyTests, analysis.tests);
+  addLikelyTestCommandsSection(lines, analysis.likelyTestCommands);
+
+  return lines.join("\n");
+}
+
+// ── Change-set renderer ──────────────────────────────────────────────
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: shared change-set renderer combines risk, files, tests, and priority signals in one function
+export function renderChangeSetImpact(params: {
+  changeSetFiles: string[];
+  analysis: ImpactAnalysis;
+  prioritySignals: PrioritySignalsSummary | null;
+}): string {
+  const lines: string[] = [];
+
+  lines.push("# Impact: change set");
+  lines.push("");
+
+  lines.push(
+    `**Risk: ${params.analysis.riskLevel.toUpperCase()}** | ${params.changeSetFiles.length} change-set file${params.changeSetFiles.length !== 1 ? "s" : ""} | ${params.analysis.affectedModules.size} module${params.analysis.affectedModules.size !== 1 ? "s" : ""} | ${params.analysis.downstreamCount} downstream (${params.analysis.confidence})`,
+  );
+  lines.push("");
+
+  lines.push("## Change Set Files");
+  for (const file of params.changeSetFiles) {
+    lines.push(`- \`${file}\``);
+  }
+  lines.push("");
+
+  lines.push(
+    ...renderReadNextSection(
+      params.changeSetFiles
+        .slice(0, 3)
+        .map((file) => readNextAround(file, 1, "inspect the change-set file before editing")),
+    ),
+  );
+
+  if (params.analysis.checkNext.length > 0) {
+    lines.push("## Check Next");
+    for (const item of params.analysis.checkNext.slice(0, 3)) {
+      lines.push(`- ${item}`);
+    }
+    lines.push("");
+  }
+
+  if (params.analysis.semanticRefFiles && params.analysis.semanticRefFiles.length > 0) {
+    lines.push("## Semantic Reference Files");
+    for (const file of params.analysis.semanticRefFiles.slice(0, 5)) {
+      lines.push(`- \`${file}\``);
+    }
+    if (params.analysis.semanticRefFiles.length > 5) {
+      lines.push(`- _+${params.analysis.semanticRefFiles.length - 5} more_`);
+    }
+    lines.push("");
+  }
+
+  if (params.analysis.likelyTests.length > 0) {
+    const testHeading = params.analysis.tests?.provenance
+      ? `Likely Tests (${params.analysis.tests.provenance})`
+      : "Likely Tests";
+    lines.push(`## ${testHeading}`);
+    for (const file of params.analysis.likelyTests) {
+      lines.push(`- \`${file}\``);
+    }
+    lines.push("");
+  } else if (params.analysis.tests) {
+    // Test discovery was explicitly requested but found nothing.
+    lines.push("## Likely Tests");
+    lines.push("No likely tests found by bounded companion/package discovery.");
+    lines.push("");
+  }
+
+  if (params.analysis.likelyTestCommands.length > 0) {
+    lines.push("## Likely Test Commands");
+    for (const cmd of params.analysis.likelyTestCommands.slice(0, 3)) {
+      lines.push(`- \`${cmd}\``);
+    }
+    lines.push("");
+  }
+
+  appendPrioritySignalsSection(lines, params.prioritySignals);
+
+  return lines.join("\n");
+}
+
+// ── Shared formatting helpers ────────────────────────────────────────
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: risk-level formatting with branching per level is clearer as one function
+function addRiskSection(lines: string[], analysis: ImpactAnalysis, directCount: number): void {
+  lines.push("## Risk Assessment");
+  const { riskLevel, affectedFiles, affectedModules, downstreamCount } = analysis;
+  if (riskLevel === "low") {
+    lines.push(
+      `\`low\` — ${directCount} ref${directCount !== 1 ? "s" : ""}, local, no downstream dependents.`,
+    );
+  } else if (riskLevel === "medium") {
+    lines.push(
+      `\`medium\` — ${directCount} ref${directCount !== 1 ? "s" : ""} across ${affectedFiles.size} file${affectedFiles.size !== 1 ? "s" : ""}${downstreamCount > 0 ? `, ${downstreamCount} downstream` : ""}.`,
+    );
+  } else {
+    lines.push(
+      `\`high\` — ${directCount} ref${directCount !== 1 ? "s" : ""} across ${affectedFiles.size} file${affectedFiles.size !== 1 ? "s" : ""} in ${affectedModules.size} module${affectedModules.size !== 1 ? "s" : ""}${downstreamCount > 0 ? `, ${downstreamCount} downstream` : ""}.`,
+    );
+  }
+  lines.push("");
+}
+
+function addCheckNextSection(lines: string[], checkNext: string[]): void {
+  if (checkNext.length === 0) return;
+  lines.push("## Check Next");
+  for (const item of checkNext.slice(0, 3)) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+}
+
+function addTestsSection(lines: string[], tests: string[], details?: TestSurfaceDetails): void {
+  if (tests.length > 0) {
+    const heading = details?.provenance
+      ? `## Likely Tests (${details.provenance})`
+      : "## Likely Tests";
+    lines.push(heading);
+    for (const t of tests.slice(0, 3)) {
+      lines.push(`- \`${t}\``);
+    }
+    lines.push("");
+    return;
+  }
+
+  // When test discovery was explicitly requested but found nothing,
+  // render an honest note instead of silently omitting test information.
+  if (details) {
+    lines.push("## Likely Tests");
+    lines.push("No likely tests found by bounded companion/package discovery.");
+    lines.push("");
+  }
+}
+
+/** Render the Likely Test Commands section when commands are available. */
+function addLikelyTestCommandsSection(lines: string[], commands: string[]): void {
+  if (commands.length === 0) return;
+  lines.push("## Likely Test Commands");
+  for (const cmd of commands.slice(0, 3)) {
+    lines.push(`- \`${cmd}\``);
+  }
+  lines.push("");
+}

package/src/tool/impact/orchestrate.ts

@@ -0,0 +1,97 @@
+// Impact orchestration use-case — workflow-oriented blast-radius analysis.
+//
+// Thin dispatcher: validates input, resolves targets, and delegates to
+// per-mode execution modules. Analysis functions live in ./analysis.ts;
+// per-mode execution in ./single-impact.ts, ./file-level-impact.ts,
+// and ./change-set-impact.ts.
+
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { isResolvedTargetGroup } from "../../analysis/helpers.ts";
+import { resolveTarget } from "../../analysis/target/bridge.ts";
+import { isTestFilePath } from "../../analysis/tests/test-discovery.ts";
+import type { CodeIntelResult } from "../../types/index.ts";
+import { executeChangeSetImpact } from "./change-set-impact.ts";
+import { executeFileLevelImpact } from "./file-level-impact.ts";
+import { unavailableImpactResult } from "./result.ts";
+import { executeSingleImpact } from "./single-impact.ts";
+import type { ImpactDeps, ImpactInput } from "./types.ts";
+
+// ── Legacy helper ───────────────────────────────────────────────────────
+
+/** Exported for backward-compatible unit-test access. Prefer `discoverTestFilesForSource` from tests.ts. */
+export function findLikelyTests(
+  affectedFiles: Set<string>,
+  _cwd: string,
+): Array<{ path: string; provenance: string }> {
+  const seen = new Set<string>();
+  const results: Array<{ path: string; provenance: string }> = [];
+
+  for (const file of affectedFiles) {
+    if (isTestFilePath(file)) {
+      seen.add(file);
+      results.push({ path: file, provenance: "name heuristic" });
+    }
+  }
+
+  const remaining = [...affectedFiles].filter((f) => !seen.has(f));
+  for (const sourceFile of remaining) {
+    const ext = path.extname(sourceFile);
+    const stem = sourceFile.slice(0, ext.length > 0 ? -ext.length : undefined);
+    for (const suffix of [".test", ".spec"]) {
+      const candidate = `${stem}${suffix}${ext}`;
+      if (!seen.has(candidate) && existsSync(candidate)) {
+        seen.add(candidate);
+        results.push({ path: candidate, provenance: "companion file" });
+      }
+    }
+  }
+
+  results.sort((a, b) => a.path.localeCompare(b.path));
+  return results.slice(0, 3);
+}
+
+// ── Main dispatch ───────────────────────────────────────────────────────
+
+/** Execute the shared impact use-case. */
+export async function executeImpact(
+  input: ImpactInput,
+  deps: ImpactDeps,
+): Promise<CodeIntelResult> {
+  if (input.changeSetFiles && input.changeSetFiles.length > 0) {
+    return executeChangeSetImpact(input, deps.cwd, deps.provider, deps.lspService);
+  }
+
+  if (input.change && !input.file && !input.symbol) {
+    return unavailableImpactResult(
+      "**Unavailable:** `code_impact` has insufficient evidence for a change-only request. Provide `changeSetFiles` or resolve a target with `code_resolve` first.",
+      [
+        "Use `code_resolve` to resolve a precise target first",
+        "Provide `changeSetFiles` with the workspace-relative files in the change set",
+      ],
+    );
+  }
+
+  const semantic = deps.provider;
+
+  if (!semantic) {
+    return unavailableImpactResult(
+      "**Error:** Impact analysis requires an active code provider (LSP). Enable LSP and retry.",
+      ["Use `code_resolve` to resolve a target first"],
+    );
+  }
+
+  const target = await resolveTarget(input, deps.cwd, semantic);
+
+  if (typeof target === "string") {
+    return unavailableImpactResult(target, ["Use `code_resolve` to resolve a target first"]);
+  }
+
+  if (isResolvedTargetGroup(target)) {
+    return executeFileLevelImpact(target, input, deps.cwd, semantic, deps.lspService);
+  }
+
+  const symbolName =
+    target.name ?? `symbol at ${path.relative(deps.cwd, target.file)}:${target.displayLine}`;
+  return executeSingleImpact(target, symbolName, input, deps.cwd, semantic, deps.lspService);
+}

package/src/tool/impact/result.ts

@@ -0,0 +1,21 @@
+import type { CodeIntelResult } from "../../types/index.ts";
+
+export function unavailableImpactResult(content: string, nextQueries: string[]): CodeIntelResult {
+  return {
+    content,
+    details: {
+      type: "impact",
+      data: {
+        confidence: "unavailable",
+        directCount: 0,
+        downstreamCount: 0,
+        riskLevel: "low" as const,
+        checkNext: [],
+        likelyTests: [],
+        likelyTestCommands: [],
+        omittedCount: 0,
+        nextQueries,
+      },
+    },
+  };
+}

package/src/tool/impact/single-impact.ts

@@ -0,0 +1,89 @@
+// Single-target impact execution.
+// Extracted from orchestrate.ts.
+
+import * as path from "node:path";
+import { buildArchitectureModel } from "../../analysis/architecture/discovery.ts";
+import { createEvidenceList } from "../../analysis/evidence.ts";
+import type { CodeProvider } from "../../analysis/provider.ts";
+import { collectReferences } from "../../analysis/references/semantic-refs.ts";
+import { summarizePrioritySignalsForFiles } from "../../analysis/signals/project.ts";
+import type { ResolvedTargetData } from "../../analysis/target/types.ts";
+import { buildTestAnchorMap } from "../../analysis/tests/likely-tests.ts";
+import type { CodeIntelResult } from "../../types/index.ts";
+import { analyzeReferenceImpact, buildDetailsData, computeOmittedCount } from "./analysis.ts";
+import { renderImpactSingle } from "./markdown.ts";
+import type { ImpactInput } from "./types.ts";
+
+// biome-ignore lint/complexity/useMaxParams: shared impact orchestration keeps substrate inputs explicit
+export async function executeSingleImpact(
+  target: ResolvedTargetData,
+  symbolName: string,
+  input: ImpactInput,
+  cwd: string,
+  semantic: CodeProvider,
+  lspService: import("@mrclrchtr/supi-lsp/api").SessionLspServiceState,
+): Promise<CodeIntelResult> {
+  const refs = await collectReferences(target, cwd, semantic);
+  const model = await buildArchitectureModel(cwd);
+  const analysis = await analyzeReferenceImpact(
+    refs,
+    model,
+    cwd,
+    input.includeTests === true,
+    semantic.references,
+    [target.file], // seed the target file itself as affected
+    buildTestAnchorMap([{ file: target.file, position: target.position }]),
+    semantic.outline,
+  );
+
+  const prioritySignals = summarizePrioritySignalsForFiles(
+    cwd,
+    analysis.affectedFiles.size > 0 ? [...analysis.affectedFiles] : [target.file],
+    lspService,
+  );
+
+  const maxResults = input.maxResults ?? 8;
+  const content = renderImpactSingle({
+    symbolName,
+    refs,
+    analysis,
+    maxResults,
+    prioritySignals,
+    target,
+    cwd,
+  });
+
+  const referenceEvidence = createEvidenceList({
+    key: "references.locations",
+    items: refs.refs,
+    maxResults,
+  }).metadata;
+  const detailsData = buildDetailsData(
+    analysis,
+    refs.refs.length,
+    computeOmittedCount(analysis.externalRefs, analysis.affectedFiles.size, input.maxResults),
+    buildTargetNextQueries(target, symbolName, cwd),
+    prioritySignals,
+    [referenceEvidence],
+  );
+
+  return {
+    content,
+    details: {
+      type: "impact",
+      data: detailsData,
+    },
+  };
+}
+
+function buildTargetNextQueries(
+  target: ResolvedTargetData,
+  symbolName: string,
+  cwd: string,
+): string[] {
+  const relPath = path.relative(cwd, target.file);
+  return [
+    `\`code_inspect\` with \`file: "${relPath}"\`, \`line: ${target.displayLine}\`, and \`character: ${target.displayCharacter}\` for point facts around ${symbolName}`,
+    `\`code_graph\`, \`file: "${relPath}"\`, \`line: ${target.displayLine}\`, and \`character: ${target.displayCharacter}\` for reference sites`,
+  ];
+}