@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/tool/health/sections/signals.ts

@@ -1,89 +0,0 @@
-// Coverage, unused, and server collection for code_health.
-// Extracted from orchestrate.ts.
-
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { isWithinOrEqual } from "@mrclrchtr/supi-core/api";
-import type { SessionLspService } from "@mrclrchtr/supi-lsp/api";
-import { gatherGitContext } from "../../../analysis/signals/git.ts";
-import type { LoadedSignals } from "../../../analysis/signals/project.ts";
-import type {
-  HealthCoverageData,
-  HealthData,
-  HealthSection,
-  HealthUnusedData,
-} from "../markdown.ts";
-
-// ── Servers ───────────────────────────────────────────────────────────
-
-export function collectServers(
-  service: SessionLspService | null,
-  included: string[],
-): HealthData["servers"] {
-  if (!included.includes("servers") || !service) return [];
-
-  return service.getProjectServers().map((s) => ({
-    name: s.name,
-    root: s.root,
-    fileTypes: s.fileTypes,
-    status: s.status,
-  }));
-}
-
-// ── Coverage ──────────────────────────────────────────────────────────
-
-export function needsPrioritizationSignals(included: HealthSection[]): boolean {
-  return included.includes("coverage") || included.includes("unused");
-}
-
-export function collectCoverageSection(
-  loaded: LoadedSignals | null,
-  cwd: string,
-  scopeFilter: string | null,
-  coveragePath?: string,
-): HealthCoverageData {
-  const reportPath = resolve(cwd, coveragePath ?? "coverage/coverage-summary.json");
-  if (!existsSync(reportPath) || !loaded) {
-    return { available: false, entries: [] };
-  }
-
-  const entries = [...loaded.coverageByFile.entries()]
-    .filter(([file, pct]) => pct < 50 && isWithinOptionalScope(scopeFilter, file))
-    .sort((left, right) => left[1] - right[1] || left[0].localeCompare(right[0]))
-    .map(([file, pct]) => ({ file, pct }));
-
-  return { available: true, entries };
-}
-
-export function collectUnusedSection(
-  loaded: LoadedSignals | null,
-  cwd: string,
-  scopeFilter: string | null,
-  unusedPath?: string,
-): HealthUnusedData {
-  const reportPath = resolve(cwd, unusedPath ?? "knip.json");
-  if (!existsSync(reportPath) || !loaded) {
-    return { available: false, files: [], exports: [] };
-  }
-
-  const files = [...loaded.unusedFiles]
-    .filter((file) => isWithinOptionalScope(scopeFilter, file))
-    .sort((left, right) => left.localeCompare(right));
-  const exports = loaded.unusedExports
-    .filter((entry) => isWithinOptionalScope(scopeFilter, entry.file))
-    .sort((left, right) => left.name.localeCompare(right.name));
-
-  return { available: true, files, exports };
-}
-
-// ── Git context ───────────────────────────────────────────────────────
-
-export function collectGitContext(included: string[], cwd: string) {
-  return included.includes("dirty") ? gatherGitContext(cwd) : null;
-}
-
-// ── Helpers ───────────────────────────────────────────────────────────
-
-function isWithinOptionalScope(scopeFilter: string | null, file: string): boolean {
-  return !scopeFilter || isWithinOrEqual(scopeFilter, file);
-}

package/src/tool/impact/analysis.ts

@@ -1,220 +0,0 @@
-// Impact analysis — shared analysis functions for impact orchestration.
-// Extracted from orchestrate.ts to keep per-mode files focused.
-
-import * as path from "node:path";
-import type { buildArchitectureModel } from "../../analysis/architecture/discovery.ts";
-import { findModuleForPath, getDependents } from "../../analysis/architecture/model.ts";
-import type { CodeProvider } from "../../analysis/provider.ts";
-import type { ReferenceCollection } from "../../analysis/references/semantic-refs.ts";
-import type { ResolvedTargetData } from "../../analysis/target/types.ts";
-import {
-  buildLikelyTestCommands,
-  buildTestAnchorMap,
-  type ChangeSetFileEntry,
-  collectLikelyTests,
-  type TestAnchorMap,
-} from "../../analysis/tests/likely-tests.ts";
-import { buildTestSurfaceDetails } from "../../analysis/tests/test-discovery.ts";
-import type { ImpactAnalysis } from "./types.ts";
-
-// ── Shared analysis ────────────────────────────────────────────────────
-
-/** Seed files parameter is explicit for testability. */
-// biome-ignore lint/complexity/useMaxParams: explicit params for testability
-export async function analyzeReferenceImpact(
-  result: ReferenceCollection,
-  model: Awaited<ReturnType<typeof buildArchitectureModel>>,
-  cwd: string,
-  includeTests: boolean,
-  references: CodeProvider["references"] | undefined,
-  seedFiles?: string[],
-  testAnchors?: TestAnchorMap,
-  outline?: CodeProvider["outline"],
-): Promise<ImpactAnalysis> {
-  const affectedFiles = new Set(result.refs.map((r) => path.resolve(cwd, r.file)));
-
-  // Seed the target file(s) so zero-reference targets still have affected evidence
-  if (seedFiles) {
-    for (const f of seedFiles) {
-      affectedFiles.add(path.resolve(cwd, f));
-    }
-  }
-
-  const { affectedModules, checkNext, downstreamCount } = analyzeModelImpact(
-    affectedFiles,
-    model,
-    cwd,
-  );
-
-  const likelyTestsResult = includeTests
-    ? await collectLikelyTests(affectedFiles, cwd, references, testAnchors, undefined, outline)
-    : null;
-  const likelyTests = likelyTestsResult?.paths ?? [];
-  const likelyTestCommands = buildLikelyTestCommands(cwd, likelyTests);
-  const tests =
-    likelyTestsResult === null
-      ? undefined
-      : buildTestSurfaceDetails(
-          {
-            status: likelyTestsResult.files.length > 0 ? "found" : "empty",
-            provenance: likelyTestsResult.provenance,
-            files: likelyTestsResult.files,
-          },
-          cwd,
-        );
-
-  return {
-    confidence: result.confidence,
-    affectedFiles,
-    affectedModules,
-    downstreamCount,
-    checkNext,
-    likelyTests,
-    likelyTestCommands,
-    tests,
-    riskLevel: assessRisk(
-      result.refs.length + result.externalCount,
-      affectedModules.size,
-      downstreamCount,
-    ),
-    externalRefs: result.externalCount,
-  };
-}
-
-export interface AnalyzeChangeSetOptions {
-  changeSetFiles: ChangeSetFileEntry[];
-  model: Awaited<ReturnType<typeof buildArchitectureModel>>;
-  cwd: string;
-  includeTests: boolean;
-  semanticImpact: ChangeSetSemanticImpact | null;
-}
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: change-set impact merges structural, semantic, test, and risk evidence in one staged result.
-export async function analyzeChangeSet(options: AnalyzeChangeSetOptions): Promise<ImpactAnalysis> {
-  const { changeSetFiles, model, cwd, includeTests, semanticImpact } = options;
-  const affectedFiles = new Set(changeSetFiles.map((entry) => entry.absPath));
-  if (semanticImpact) {
-    for (const ref of semanticImpact.refs.refs) {
-      affectedFiles.add(path.resolve(cwd, ref.file));
-    }
-  }
-
-  const { affectedModules, checkNext, downstreamCount } = analyzeModelImpact(
-    affectedFiles,
-    model,
-    cwd,
-  );
-
-  const likelyTestsResult = includeTests
-    ? await collectLikelyTests(
-        affectedFiles,
-        cwd,
-        semanticImpact?.references,
-        semanticImpact ? buildTestAnchorMap(semanticImpact.targets) : undefined,
-        semanticImpact ? undefined : "conventions-only",
-        semanticImpact?.outline,
-      )
-    : null;
-  const likelyTests = likelyTestsResult?.paths ?? [];
-  const likelyTestCommands = buildLikelyTestCommands(cwd, likelyTests);
-  const tests =
-    likelyTestsResult === null
-      ? undefined
-      : buildTestSurfaceDetails(
-          {
-            status: likelyTestsResult.files.length > 0 ? "found" : "empty",
-            provenance: likelyTestsResult.provenance,
-            files: likelyTestsResult.files,
-          },
-          cwd,
-        );
-
-  const semanticRefCount = semanticImpact ? semanticImpact.refs.refs.length : 0;
-  const externalRefs = semanticImpact ? semanticImpact.refs.externalCount : 0;
-  const semanticRefFiles = semanticImpact ? collectUniqueRefFiles(semanticImpact.refs) : undefined;
-
-  return {
-    confidence: semanticImpact ? "semantic" : "structural",
-    affectedFiles,
-    affectedModules,
-    downstreamCount,
-    checkNext,
-    likelyTests,
-    likelyTestCommands,
-    tests,
-    riskLevel: assessRisk(
-      changeSetFiles.length + semanticRefCount,
-      affectedModules.size,
-      downstreamCount,
-    ),
-    externalRefs,
-    semanticRefFiles,
-  };
-}
-
-export interface ChangeSetSemanticImpact {
-  targets: ResolvedTargetData[];
-  refs: ReferenceCollection;
-  references: CodeProvider["references"];
-  outline?: CodeProvider["outline"];
-}
-
-export function collectUniqueRefFiles(refs: ReferenceCollection): string[] {
-  return [...new Set(refs.refs.map((ref) => ref.file))].sort((a, b) => a.localeCompare(b));
-}
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: module-impact traversal keeps affected/downstream/check-next logic together
-export function analyzeModelImpact(
-  affectedFiles: Set<string>,
-  model: Awaited<ReturnType<typeof buildArchitectureModel>>,
-  cwd: string,
-): Pick<ImpactAnalysis, "affectedModules" | "checkNext" | "downstreamCount"> {
-  const affectedModules = new Set<string>();
-  const checkNext: string[] = [];
-  let downstreamCount = 0;
-
-  if (model) {
-    for (const file of affectedFiles) {
-      const mod = findModuleForPath(model, path.resolve(cwd, file));
-      if (mod) affectedModules.add(mod.name);
-    }
-
-    const downstreamModules = new Set<string>();
-    const queue = [...affectedModules];
-    while (queue.length > 0) {
-      const modName = queue.shift() as string;
-      for (const dep of getDependents(model, modName)) {
-        if (!affectedModules.has(dep.name) && !downstreamModules.has(dep.name)) {
-          downstreamModules.add(dep.name);
-          queue.push(dep.name);
-        }
-      }
-    }
-    downstreamCount = downstreamModules.size;
-
-    for (const modName of [...affectedModules, ...downstreamModules].slice(0, 3)) {
-      const mod = model.modules.find((m) => m.name === modName);
-      if (mod) checkNext.push(`${mod.name.replace(/^@[^/]+\//, "")} (\`${mod.relativePath}\`)`);
-    }
-  }
-
-  return { affectedModules, checkNext, downstreamCount };
-}
-
-export function assessRisk(
-  totalRefs: number,
-  moduleCount: number,
-  downstreamCount: number,
-): "low" | "medium" | "high" {
-  if (totalRefs > 10 || moduleCount > 3 || downstreamCount > 1) return "high";
-  if (totalRefs > 3 || moduleCount > 1 || downstreamCount >= 1) return "medium";
-  return "low";
-}
-
-export function computeOmittedCount(
-  externalRefs: number,
-  affectedFileCount: number,
-  maxResults?: number,
-): number {
-  return externalRefs + Math.max(0, affectedFileCount - (maxResults ?? 8));
-}

package/src/tool/impact/change-set-impact.ts

@@ -1,152 +0,0 @@
-// Change-set 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 { resolveFileTargetGroup } from "../../analysis/target/file.ts";
-import type { ResolvedTargetData } from "../../analysis/target/types.ts";
-import type { ChangeSetFileEntry } from "../../analysis/tests/likely-tests.ts";
-import { normalizeChangeSet } from "../../analysis/tests/likely-tests.ts";
-import type { CodeIntelResult } from "../../types/index.ts";
-import { assembleImpactDetails } from "../result/impact.ts";
-import { analyzeChangeSet, type ChangeSetSemanticImpact } from "./analysis.ts";
-import { renderChangeSetImpact } from "./markdown.ts";
-import { unavailableImpactResult } from "./result.ts";
-import type { ImpactAnalysis, ImpactInput } from "./types.ts";
-
-export async function executeChangeSetImpact(
-  input: ImpactInput,
-  cwd: string,
-  provider: CodeProvider | null,
-  lspService: import("@mrclrchtr/supi-lsp/api").SessionLspServiceState,
-): Promise<CodeIntelResult> {
-  const changeSetFiles = normalizeChangeSet(input.changeSetFiles ?? [], cwd);
-  if (changeSetFiles.length === 0) {
-    return unavailableImpactResult(
-      "**Unavailable:** No readable change-set files were provided for impact analysis.",
-      [
-        "Provide `changeSetFiles` with workspace-relative file paths",
-        "Use `code_resolve` when you want symbol-level impact instead",
-      ],
-    );
-  }
-
-  const model = await buildArchitectureModel(cwd);
-  const semanticImpact = await collectChangeSetSemanticImpact(changeSetFiles, cwd, provider);
-  const analysis = await analyzeChangeSet({
-    changeSetFiles,
-    model,
-    cwd,
-    includeTests: input.includeTests === true,
-    semanticImpact,
-  });
-  const prioritySignals = summarizePrioritySignalsForFiles(
-    cwd,
-    changeSetFiles.map((entry) => entry.absPath),
-    lspService,
-  );
-  const nextQueries = buildChangeSetNextQueries(changeSetFiles, analysis, semanticImpact);
-  const upgradeSuggestion = buildSemanticUpgradeSuggestion(changeSetFiles, semanticImpact);
-  const evidenceNote =
-    analysis.confidence === "semantic"
-      ? "\n**Evidence: semantic+structural** — semantic references for symbols defined in change-set files were merged with file-level module analysis and bounded test discovery.\n"
-      : `\n**Evidence: structural** — impact limited to file-level module analysis and path-based test discovery.\n${upgradeSuggestion}\n`;
-  const content =
-    renderChangeSetImpact({
-      changeSetFiles: changeSetFiles.map((entry) => entry.relPath),
-      analysis,
-      prioritySignals,
-    }) + evidenceNote;
-
-  const detailsData = assembleImpactDetails(
-    analysis,
-    changeSetFiles.length,
-    0,
-    nextQueries,
-    prioritySignals,
-  );
-
-  return {
-    content,
-    details: {
-      type: "impact",
-      data: detailsData,
-    },
-  };
-}
-
-async function collectChangeSetSemanticImpact(
-  changeSetFiles: ChangeSetFileEntry[],
-  cwd: string,
-  provider: CodeProvider | null,
-): Promise<ChangeSetSemanticImpact | null> {
-  if (!provider?.references) return null;
-
-  const targets: ResolvedTargetData[] = [];
-  for (const entry of changeSetFiles) {
-    try {
-      const outcome = await resolveFileTargetGroup(entry.relPath, cwd, {
-        semantic: provider,
-        structural: provider,
-      });
-      if (outcome.kind === "resolved") {
-        targets.push(...outcome.group.targets);
-      }
-    } catch {
-      // Keep change-set analysis best-effort: structural impact still applies.
-    }
-  }
-
-  const cappedTargets = targets.slice(0, 25);
-  if (cappedTargets.length === 0) return null;
-
-  const refs = await aggregatePerTarget(cappedTargets, (target) =>
-    collectReferences(target, cwd, provider),
-  );
-  if (refs.confidence !== "semantic" || (refs.refs.length === 0 && refs.externalCount === 0)) {
-    return null;
-  }
-
-  return {
-    targets: cappedTargets,
-    refs,
-    references: provider.references,
-    outline: provider.outline,
-  };
-}
-
-function buildChangeSetNextQueries(
-  changeSetFiles: ChangeSetFileEntry[],
-  analysis: ImpactAnalysis,
-  semanticImpact: ChangeSetSemanticImpact | null,
-): string[] {
-  const firstFile = changeSetFiles[0]?.relPath;
-  const next: string[] = [];
-  if (firstFile) {
-    next.push(
-      `\`code_orientation\` with \`focus: "${firstFile}"\` for focused orientation on the change-set file`,
-    );
-  }
-  if (analysis.checkNext.length > 0) {
-    next.push("`code_orientation` on the most-affected module for broader orientation");
-  }
-  if (analysis.confidence !== "semantic" && firstFile) {
-    const symbolHint = semanticImpact?.targets[0]?.name ?? "<primary exported symbol>";
-    next.push(
-      `For semantic impact, run \`code_resolve(query="${symbolHint}", scope="${firstFile}")\` then \`code_impact(targetId="<result>", change="<your change>")\``,
-    );
-  }
-  return next;
-}
-
-function buildSemanticUpgradeSuggestion(
-  changeSetFiles: ChangeSetFileEntry[],
-  semanticImpact: ChangeSetSemanticImpact | null,
-): string {
-  const firstFile = changeSetFiles[0]?.relPath;
-  if (!firstFile) return "";
-  const symbolHint = semanticImpact?.targets[0]?.name ?? "<primary exported symbol>";
-  return `For semantic impact, run \`code_resolve(query="${symbolHint}", scope="${firstFile}")\` then \`code_impact(targetId="<result>", change="<your change>")\`.`;
-}

package/src/tool/impact/execute.ts

@@ -1,125 +0,0 @@
-/**
- * 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. */
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: target workflow + pipeline orchestration stays together for clarity
-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);
-
-  // ── Deep seam: resolve targetId through the session target workflow ──
-  // Replaces expandTargetId pipeline stage for targetId expansion.
-  if (!hasChangeSetInputs && params.targetId) {
-    const outcome = await ctx.session.resolveTarget(
-      { targetId: params.targetId },
-      { fileLevelAllowed: false, nameAnchorRequired: false, waitForSemantic: false },
-    );
-
-    if (outcome.kind === "resolved") {
-      params.file = outcome.entry.file;
-      params.line = outcome.entry.displayLine;
-      params.character = outcome.entry.displayCharacter;
-      params.symbol = outcome.entry.name ?? undefined;
-    } else if (outcome.kind !== "no-target") {
-      const msg =
-        outcome.kind === "invalid-input"
-          ? outcome.message
-          : outcome.kind === "unavailable"
-            ? outcome.reason
-            : "Target resolution failed. Verify the targetId is valid.";
-      return impactErrorResult(msg, {
-        nextQueries: ["Use `code_resolve` to resolve a target first"],
-      });
-    }
-  }
-
-  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

@@ -1,82 +0,0 @@
-// 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 { assembleImpactDetails } from "../result/impact.ts";
-import { analyzeReferenceImpact, 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 = assembleImpactDetails(
-    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,
-    },
-  };
-}