@mrclrchtr/supi-code-intelligence 1.16.1 → 2.0.0

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

@@ -0,0 +1,89 @@
+// 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/health/tui.ts

@@ -0,0 +1,137 @@
+/**
+ * TUI renderer for code_health — renderCall + renderResult.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { formatEvidenceBadge } from "@mrclrchtr/supi-code-runtime/api";
+import {
+  type EvidenceEntry,
+  type ResultOptios,
+  renderEvidenceLines,
+  renderMarkdownDetail,
+  renderPartial,
+  type ToolResult,
+} from "../../ui/tui/common.ts";
+import type { CodeHealthToolParams } from "./execute.ts";
+
+/** ── renderCall ────────────────────────────────────────────────── */
+
+export function renderHealthCall(args: unknown, theme: Theme, _context: unknown): Text {
+  const params = (args ?? {}) as CodeHealthToolParams;
+  const sections = params.include?.length ? params.include.join(", ") : "diag, servers";
+
+  let content = theme.fg("toolTitle", "code_health");
+  content += ` ${theme.fg("accent", sections)}`;
+
+  if (params.scope) {
+    content += ` ${theme.fg("dim", params.scope)}`;
+  }
+
+  return new Text(content, 0, 0);
+}
+
+/** ── renderResult ──────────────────────────────────────────────── */
+
+export function renderHealthResult(
+  result: ToolResult,
+  options: ResultOptios,
+  theme: Theme,
+  _context: unknown,
+): Container | Text {
+  if (options.isPartial) {
+    return renderPartial("Gathering workspace health…", theme);
+  }
+
+  const container = new Container();
+  const data =
+    result.details?.type === "health" ? (result.details.data as Record<string, unknown>) : null;
+
+  if (result.isError) {
+    container.addChild(new Text(theme.fg("error", "code_health failed"), 0, 0));
+    return container;
+  }
+
+  if (!options.expanded) {
+    container.addChild(buildCompactSummary(data, theme));
+    return container;
+  }
+
+  // Expanded view
+  container.addChild(buildStatusBar(data, theme));
+  container.addChild(new Spacer(1));
+  container.addChild(buildDiagnosticSummary(data, theme));
+
+  const lists = data?.evidenceLists as EvidenceEntry[] | undefined;
+  if (lists && lists.length > 0) {
+    container.addChild(new Spacer(1));
+    renderEvidenceLines(container, lists, theme);
+  }
+
+  renderMarkdownDetail(container, result, theme);
+
+  return container;
+}
+
+/** ── Helpers ───────────────────────────────────────────────────── */
+
+function buildCompactSummary(data: Record<string, unknown> | null, theme: Theme): Text {
+  if (!data) {
+    return new Text(theme.fg("dim", "No health data"), 0, 0);
+  }
+
+  const diagCount = (data.diagnosticFileCount as number) ?? 0;
+  const serverCount = (data.serverCount as number) ?? 0;
+  const lspStatus = (data.lspStatus as string) ?? "unknown";
+
+  const statusColor = lspStatus === "ready" ? "success" : "warning";
+  const dot = theme.fg("dim", "·");
+
+  const segments = [
+    `${theme.fg("dim", "diag")} ${theme.fg("success", theme.bold(`${diagCount}`))}${theme.fg("muted", " with issues")}`,
+    `${theme.fg("dim", "servers")} ${theme.fg("muted", `${serverCount}`)}`,
+    `${theme.fg("dim", "lsp")} ${theme.fg(statusColor, lspStatus)}`,
+  ];
+
+  return new Text(segments.join(` ${dot} `), 0, 0);
+}
+
+function buildStatusBar(data: Record<string, unknown> | null, theme: Theme): Text {
+  if (!data) return new Text("", 0, 0);
+
+  const lspStatus = (data.lspStatus as string) ?? "unknown";
+  const structuralStatus = (data.structuralStatus as string) ?? "unknown";
+  const recovered = data.recovered;
+
+  const lspColor = lspStatus.startsWith("ready") ? "success" : "warning";
+  const structuralColor = structuralStatus === "ready" ? "success" : "muted";
+
+  const lspLabel =
+    lspStatus.includes("(recovered)") || !recovered ? lspStatus : `${lspStatus} (recovered)`;
+
+  const lines: string[] = [
+    `LSP: ${theme.fg(lspColor, lspLabel)}`,
+    `Tree-sitter: ${theme.fg(structuralColor, structuralStatus)}`,
+  ];
+
+  return new Text(lines.join("  "), 0, 0);
+}
+
+function buildDiagnosticSummary(data: Record<string, unknown> | null, theme: Theme): Text {
+  if (!data) return new Text("", 0, 0);
+
+  const diagCount = (data.diagnosticFileCount as number) ?? 0;
+  if (diagCount === 0) {
+    return new Text(theme.fg("success", "No diagnostics found"), 0, 0);
+  }
+
+  const badge = formatEvidenceBadge({
+    shownCount: diagCount,
+    totalCount: diagCount,
+    omittedCount: 0,
+    partialReason: null,
+    label: "files with issues",
+  });
+
+  return new Text(theme.fg("warning", theme.bold(badge)), 0, 0);
+}

package/src/tool/impact/analysis.ts

@@ -0,0 +1,247 @@
+// 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 { EvidenceListMetadata } from "../../analysis/evidence.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 { AffectedDetails, ImpactDetails } from "../../types/index.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));
+}
+
+// biome-ignore lint/complexity/useMaxParams: detail assembly keeps shared counts, queries, and signals explicit for both surfaces
+export function buildDetailsData(
+  analysis: ImpactAnalysis,
+  directCount: number,
+  omittedCount: number,
+  nextQueries: string[],
+  prioritySignals: AffectedDetails["prioritySignals"],
+  evidenceLists: EvidenceListMetadata[] = [],
+): AffectedDetails | ImpactDetails {
+  return {
+    confidence: analysis.confidence,
+    directCount,
+    downstreamCount: analysis.downstreamCount,
+    riskLevel: analysis.riskLevel,
+    checkNext: analysis.checkNext,
+    likelyTests: analysis.likelyTests,
+    likelyTestCommands: analysis.likelyTestCommands,
+    omittedCount,
+    evidenceLists,
+    nextQueries,
+    prioritySignals,
+    tests: analysis.tests,
+  };
+}

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

@@ -0,0 +1,151 @@
+// 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 { analyzeChangeSet, buildDetailsData, 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 = buildDetailsData(
+    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>")\`.`;
+}