@mrclrchtr/supi-code-intelligence 2.0.6 → 2.1.0

package/src/tool/health/markdown.ts

@@ -5,77 +5,19 @@
  * readable markdown sections keyed by requested `include` values.
  */
 
-import type { CoverageWarningReport } from "../../analysis/coverage/coverage-warnings.ts";
-import type { GitContext } from "../../analysis/signals/git.ts";
 import { formatGitContext } from "../../analysis/signals/git.ts";
-
-export type HealthSection = "diagnostics" | "servers" | "dirty" | "coverage" | "unused";
-
-export interface HealthServerInfo {
-  name: string;
-  root: string;
-  fileTypes: string[];
-  status: string;
-}
-
-export interface HealthDiagnosticEntry {
-  file: string;
-  errors: number;
-  warnings: number;
-}
-
-export interface HealthCoverageEntry {
-  file: string;
-  pct: number;
-}
-
-export interface HealthCoverageData {
-  available: boolean;
-  entries: HealthCoverageEntry[];
-}
-
-export interface HealthUnusedExportEntry {
-  file: string;
-  name: string;
-}
-
-export interface HealthUnusedData {
-  available: boolean;
-  files: string[];
-  exports: HealthUnusedExportEntry[];
-}
-
-/** A suggested code action at a specific diagnostic location. */
-export interface CodeActionSuggestion {
-  file: string;
-  line: number;
-  title: string;
-  kind?: string;
-}
-
-export interface HealthData {
-  includedSections: HealthSection[];
-  lspAvailable: boolean;
-  lspStatus: string;
-  recovered: boolean;
-  /** Structural (tree-sitter) substrate readiness. Undefined when not evaluated. */
-  structuralStatus?: string;
-  diagnostics: HealthDiagnosticEntry[];
-  servers: HealthServerInfo[];
-  gitContext: GitContext | null;
-  scopeFilter: string | null;
-  level: "summary" | "detailed";
-  /** Code action suggestions collected from LSP (only populated in detailed mode). */
-  codeActions: CodeActionSuggestion[] | null;
-  coverage: HealthCoverageData | null;
-  unused: HealthUnusedData | null;
-  /** Coverage warnings for degraded semantic/structural substrate. Undefined when fully healthy. */
-  degradedCoverage?: CoverageWarningReport;
-  /** Seconds since diagnostics were last refreshed, or undefined if never refreshed. */
-  diagnosticAgeSeconds?: number;
-}
-
-export function renderHealthResult(data: HealthData, cwd: string): string {
+import type { HealthData, HealthResultAssembly } from "../result/health.ts";
+
+export type {
+  CodeActionSuggestion,
+  HealthCoverageData,
+  HealthData,
+  HealthSection,
+  HealthUnusedData,
+} from "../result/health.ts";
+
+export function renderHealthResult(result: HealthResultAssembly, cwd: string): string {
+  const data = result.data;
   const lines: string[] = ["## Code Health", ""];
 
   renderStatusLine(lines, data);

package/src/tool/health/orchestrate.ts

@@ -15,8 +15,8 @@ import {
   gatherCoverageEvalInput,
 } from "../../analysis/coverage/coverage-warnings.ts";
 import { loadPrioritizationSignals } from "../../analysis/signals/project.ts";
-import type { CodeIntelResult, HealthDetails } from "../../types/index.ts";
-import type { HealthData, HealthSection } from "./markdown.ts";
+import type { CodeIntelResult } from "../../types/index.ts";
+import { assembleHealthResult, type HealthData, type HealthSection } from "../result/health.ts";
 import { renderHealthResult } from "./markdown.ts";
 import { collectCodeActions, collectDiagnostics } from "./sections/diagnostics.ts";
 import {
@@ -138,22 +138,14 @@ export async function executeHealth(
     diagnosticAgeSeconds,
   };
 
-  const evidenceLists = buildHealthEvidenceLists(gitContext);
-  const content = renderHealthResult(data, cwd);
+  const assembly = assembleHealthResult(data, buildHealthEvidenceLists(gitContext));
+  const content = renderHealthResult(assembly, cwd);
 
   return {
     content,
     details: {
       type: "health",
-      data: {
-        lspAvailable: data.lspAvailable,
-        lspStatus: data.lspStatus,
-        recovered: data.recovered,
-        structuralStatus: data.structuralStatus,
-        diagnosticFileCount: data.diagnostics.length,
-        serverCount: data.servers.length,
-        evidenceLists,
-      } satisfies HealthDetails,
+      data: assembly.details,
     },
   };
 }

package/src/tool/impact/analysis.ts

@@ -4,7 +4,6 @@
 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";
@@ -16,7 +15,6 @@ import {
   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 ────────────────────────────────────────────────────
@@ -220,28 +218,3 @@ export function computeOmittedCount(
 ): 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

@@ -10,7 +10,8 @@ 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 { 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";
@@ -59,7 +60,7 @@ export async function executeChangeSetImpact(
       prioritySignals,
     }) + evidenceNote;
 
-  const detailsData = buildDetailsData(
+  const detailsData = assembleImpactDetails(
     analysis,
     changeSetFiles.length,
     0,

package/src/tool/impact/execute.ts

@@ -30,6 +30,7 @@ export interface CodeImpactToolParams {
 }
 
 /** 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,
@@ -38,6 +39,32 @@ export async function executeImpactTool(
 
   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,

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

@@ -8,7 +8,8 @@ import { summarizePrioritySignalsForFiles } from "../../analysis/signals/project
 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 { assembleImpactDetails } from "../result/impact.ts";
+import { analyzeReferenceImpact, computeOmittedCount } from "./analysis.ts";
 import { renderImpactFileLevel } from "./markdown.ts";
 import type { ImpactInput } from "./types.ts";
 
@@ -60,7 +61,7 @@ export async function executeFileLevelImpact(
     cwd,
   });
 
-  const detailsData = buildDetailsData(
+  const detailsData = assembleImpactDetails(
     analysis,
     aggregated.refs.length,
     computeOmittedCount(analysis.externalRefs, analysis.affectedFiles.size, input.maxResults),

package/src/tool/impact/result.ts

@@ -1,21 +1,2 @@
-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,
-      },
-    },
-  };
-}
+/** Compatibility export for impact result assembly. */
+export { unavailableImpactResult } from "../result/impact.ts";

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

@@ -10,7 +10,8 @@ import { summarizePrioritySignalsForFiles } from "../../analysis/signals/project
 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 { assembleImpactDetails } from "../result/impact.ts";
+import { analyzeReferenceImpact, computeOmittedCount } from "./analysis.ts";
 import { renderImpactSingle } from "./markdown.ts";
 import type { ImpactInput } from "./types.ts";
 
@@ -58,7 +59,7 @@ export async function executeSingleImpact(
     items: refs.refs,
     maxResults,
   }).metadata;
-  const detailsData = buildDetailsData(
+  const detailsData = assembleImpactDetails(
     analysis,
     refs.refs.length,
     computeOmittedCount(analysis.externalRefs, analysis.affectedFiles.size, input.maxResults),

package/src/tool/infra/error-results.ts

@@ -1,199 +1,21 @@
 /**
- * Unified error-result factories for code-intelligence tool executors.
+ * Compatibility export for code-intelligence error result assembly.
  *
- * Every factory returns a complete {@link CodeIntelResult} (content + typed
- * details) so executors never need to inline the `{ content, details }`
- * wrapper. The old `unavailableXxxDetails()` functions are kept as thin
- * wrappers — prefer the combined `xxxErrorResult()` factories in new code.
+ * Returned tool errors are assembled behind `src/tool/result/` with the rest
+ * of public tool evidence. New tool code should import from
+ * `../result/errors.ts` directly.
  */
-
-import type {
-  CodeIntelResult,
-  ContextDetails,
-  HealthDetails,
-  ImpactDetails,
-  InspectDetails,
-  ResolveDetails,
-  SearchDetails,
-} from "../../types/index.ts";
-
-// ── Combined error-result factories (preferred) ──────────────────────
-
-/** Full error result for search-family tools (code_find, code_graph, code_find, code_refactor_plan). */
-export function searchErrorResult(
-  content: string,
-  opts?: { scope?: string | null; nextQueries?: string[] },
-): CodeIntelResult {
-  return {
-    content,
-    details: {
-      type: "search" as const,
-      data: {
-        confidence: "unavailable" as const,
-        scope: opts?.scope ?? null,
-        candidateCount: 0,
-        omittedCount: 0,
-        nextQueries: opts?.nextQueries ?? [],
-      },
-    },
-  };
-}
-
-/** Full error result for code_orientation (context-type details). */
-export function contextErrorResult(
-  content: string,
-  opts?: { nextQueries?: string[] },
-): CodeIntelResult {
-  return {
-    content,
-    details: {
-      type: "context" as const,
-      data: {
-        confidence: "unavailable" as const,
-        task: null,
-        focusTarget: null,
-        requestedSections: [],
-        renderedSections: [],
-        omittedCount: 0,
-        nextQueries: opts?.nextQueries ?? [],
-      },
-    },
-  };
-}
-
-/** Full error result for code_resolve. */
-export function resolveErrorResult(
-  content: string,
-  opts?: { nextQueries?: string[] },
-): CodeIntelResult {
-  return {
-    content,
-    details: {
-      type: "resolve" as const,
-      data: {
-        confidence: "unavailable" as const,
-        targetCount: 0,
-        omittedCount: 0,
-        targets: [],
-        nextQueries: opts?.nextQueries ?? [],
-      },
-    },
-  };
-}
-
-/** Full error result for code_inspect. */
-export function inspectErrorResult(
-  content: string,
-  opts?: { focusTarget?: string; nextQueries?: string[] },
-): CodeIntelResult {
-  return {
-    content,
-    details: {
-      type: "inspect" as const,
-      data: {
-        confidence: "unavailable" as const,
-        focusTarget: opts?.focusTarget ?? "",
-        unavailableSections: [],
-        nextQueries: opts?.nextQueries ?? [],
-      },
-    },
-  };
-}
-
-/** Full error result for code_impact. */
-export function impactErrorResult(
-  content: string,
-  opts?: { nextQueries?: string[] },
-): CodeIntelResult {
-  const data: ImpactDetails = {
-    confidence: "unavailable",
-    directCount: 0,
-    downstreamCount: 0,
-    riskLevel: "low",
-    checkNext: [],
-    likelyTests: [],
-    likelyTestCommands: [],
-    omittedCount: 0,
-    nextQueries: opts?.nextQueries ?? [],
-  };
-  return { content, details: { type: "impact" as const, data } };
-}
-
-/** Full error result for code_health. */
-export function healthErrorResult(content: string, reason?: string): CodeIntelResult {
-  return {
-    content,
-    details: {
-      type: "health" as const,
-      data: {
-        lspAvailable: false,
-        lspStatus: reason ?? content,
-        recovered: false,
-        diagnosticFileCount: 0,
-        serverCount: 0,
-      },
-    },
-  };
-}
-
-// ── Details-only helpers (thin wrappers — prefer combined factories above) ─
-
-export function unavailableSearchDetails(
-  scope: string | null,
-  nextQueries: string[],
-): { type: "search"; data: SearchDetails } {
-  return searchErrorResult("", { scope, nextQueries }).details as {
-    type: "search";
-    data: SearchDetails;
-  };
-}
-
-export function unavailableContextDetails(nextQueries: string[]): {
-  type: "context";
-  data: ContextDetails;
-} {
-  return contextErrorResult("", { nextQueries }).details as {
-    type: "context";
-    data: ContextDetails;
-  };
-}
-
-export function unavailableResolveDetails(nextQueries: string[]): {
-  type: "resolve";
-  data: ResolveDetails;
-} {
-  return resolveErrorResult("", { nextQueries }).details as {
-    type: "resolve";
-    data: ResolveDetails;
-  };
-}
-
-export function unavailableInspectDetails(
-  focusTarget: string,
-  nextQueries: string[],
-): { type: "inspect"; data: InspectDetails } {
-  return inspectErrorResult("", { focusTarget, nextQueries }).details as {
-    type: "inspect";
-    data: InspectDetails;
-  };
-}
-
-export function unavailableImpactDetails(nextQueries: string[]): {
-  type: "impact";
-  data: ImpactDetails;
-} {
-  return impactErrorResult("", { nextQueries }).details as {
-    type: "impact";
-    data: ImpactDetails;
-  };
-}
-
-export function unavailableHealthDetails(reason: string): {
-  type: "health";
-  data: HealthDetails;
-} {
-  return healthErrorResult("", reason).details as {
-    type: "health";
-    data: HealthDetails;
-  };
-}
+export {
+  contextErrorResult,
+  healthErrorResult,
+  impactErrorResult,
+  inspectErrorResult,
+  resolveErrorResult,
+  searchErrorResult,
+  unavailableContextDetails,
+  unavailableHealthDetails,
+  unavailableImpactDetails,
+  unavailableInspectDetails,
+  unavailableResolveDetails,
+  unavailableSearchDetails,
+} from "../result/errors.ts";

package/src/tool/infra/pipeline.ts

@@ -23,7 +23,7 @@
 
 import { match } from "ts-pattern";
 import { ensureSemanticReadiness } from "../../analysis/readiness.ts";
-import { resolveScope } from "../../analysis/search/ripgrep.ts";
+import { resolveScope, resolveScopeSet } from "../../analysis/search/ripgrep.ts";
 import { routeFor } from "../../analysis/target/planner.ts";
 import type {
   CodeIntelligenceToolName,
@@ -150,6 +150,15 @@ export interface HasScopeParam {
   scope?: string;
 }
 
+/** Minimum parameter shape needed by `resolveScopeSetParam`. */
+export interface HasScopeSetParam {
+  scope?: string | string[];
+  /** Set by resolveScopeSetParam — absolute search roots for code_find. */
+  _resolvedScopePaths?: string[];
+  /** Set by resolveScopeSetParam — display label for requested search roots. */
+  _resolvedScopeDisplay?: string | null;
+}
+
 /**
  * Resolve the `scope` parameter to an absolute path.
  *
@@ -175,6 +184,20 @@ export function resolveScopeParam<P extends HasScopeParam>(
   };
 }
 
+/** Resolve code_find's one-or-many `scope` input to absolute search roots. */
+export function resolveScopeSetParam<P extends HasScopeSetParam>(
+  onError: (reason: string) => CodeIntelResult,
+): PipeStage<P> {
+  return (params, ctx) => {
+    const result = resolveScopeSet(params.scope, ctx.cwd);
+    if (result.kind === "error") return { kind: "error", result: onError(result.reason) };
+
+    params._resolvedScopePaths = [...result.paths];
+    params._resolvedScopeDisplay = result.display;
+    return { kind: "continue" };
+  };
+}
+
 /**
  * Apply cross-field validation rules after TypeBox schema validation.
  *

package/src/tool/inspect/markdown.ts

@@ -1,46 +1,9 @@
-import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
-import {
-  type EvidenceListMetadata,
-  renderEvidenceListMetadataDisclosure,
-} from "../../analysis/evidence.ts";
-
-export interface InspectRenderInput {
-  relPath: string;
-  line: number;
-  character: number;
-  confidence: ConfidenceMode;
-  node: {
-    type: string;
-    text: string;
-    startLine: number;
-    startCharacter: number;
-    ancestry?: Array<
-      | string
-      | {
-          type: string;
-          startLine: number;
-          startCharacter: number;
-          endLine?: number;
-          endCharacter?: number;
-        }
-    >;
-  } | null;
-  enclosingSymbol: {
-    name: string;
-    kind: string;
-    startLine: number;
-    endLine: number;
-  } | null;
-  hover: string | null;
-  definitions: Array<{ file: string; line: number; character: number }>;
-  diagnostics: Array<{ line: number; severity: number | string; message: string }>;
-  codeActions: Array<{ title: string; kind?: string }>;
-  codeActionEvidence?: EvidenceListMetadata;
-  unavailableSections: string[];
-}
+import { renderEvidenceListMetadataDisclosure } from "../../analysis/evidence.ts";
+import type { InspectResultAssembly } from "../result/inspect.ts";
 
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: inspect rendering keeps section ordering and unavailable-state handling explicit
-export function renderInspectResult(input: InspectRenderInput): string {
+export function renderInspectResult(assembly: InspectResultAssembly): string {
+  const input = assembly.data;
   const lines: string[] = [];
   lines.push(`# Inspect: ${input.relPath}:${input.line}:${input.character}`);
   lines.push("");

package/src/tool/inspect/orchestrate.ts

@@ -4,6 +4,7 @@ import { createEvidenceList } from "../../analysis/evidence.ts";
 import { normalizePath } from "../../analysis/search/ripgrep.ts";
 import { gatherNearbyDiagnostics, gatherTreeSitterContext } from "../../ui/markdown/gather.ts";
 import type { InspectDeps, InspectInput, InspectUseCaseResult } from "../../ui/markdown/types.ts";
+import { assembleInspectResult } from "../result/inspect.ts";
 import { renderInspectResult } from "./markdown.ts";
 
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: inspect orchestration keeps data gathering and unavailable-section derivation in one place
@@ -89,37 +90,35 @@ export async function executeInspect(
   });
 
   const nextQueries = buildNextQueries(relPath, input.line, input.character, confidence);
-  const content = renderInspectResult({
-    relPath,
-    line: input.line,
-    character: input.character,
-    confidence,
-    node: context.nodeInfo,
-    enclosingSymbol: enclosing
-      ? {
-          name: enclosing.name,
-          kind: enclosing.kind,
-          startLine: enclosing.startLine,
-          endLine: enclosing.endLine,
-        }
-      : null,
-    hover: context.hover?.contents ?? null,
-    definitions,
-    diagnostics,
-    codeActions: codeActions.items,
-    codeActionEvidence: codeActions.metadata,
-    unavailableSections: dedupe(unavailableSections),
-  });
-
-  return {
-    content,
-    details: {
+  const assembly = assembleInspectResult(
+    {
+      relPath,
+      line: input.line,
+      character: input.character,
       confidence,
-      focusTarget: `${relPath}:${input.line}:${input.character}`,
+      node: context.nodeInfo,
+      enclosingSymbol: enclosing
+        ? {
+            name: enclosing.name,
+            kind: enclosing.kind,
+            startLine: enclosing.startLine,
+            endLine: enclosing.endLine,
+          }
+        : null,
+      hover: context.hover?.contents ?? null,
+      definitions,
+      diagnostics,
+      codeActions: codeActions.items,
+      codeActionEvidence: codeActions.metadata,
       unavailableSections: dedupe(unavailableSections),
-      evidenceLists: [codeActions.metadata],
-      nextQueries,
     },
+    nextQueries,
+  );
+  const content = renderInspectResult(assembly);
+
+  return {
+    content,
+    details: assembly.details,
   };
 }