@mrclrchtr/supi-code-intelligence 3.2.0 → 4.0.0

package/src/tool/inspect/markdown.ts

@@ -1,122 +1,141 @@
-import { renderEvidenceListMetadataDisclosure } from "../../analysis/evidence.ts";
+import { renderEvidenceListDisclosure } from "../../analysis/evidence.ts";
+import type { InspectObservation } from "../../session/inspect-types.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(assembly: InspectResultAssembly): string {
   const input = assembly.data;
-  const lines: string[] = [];
-  lines.push(`# Inspect: ${input.relPath}:${input.line}:${input.character}`);
-  lines.push("");
-  lines.push(`**Confidence:** \`${input.confidence}\``);
-  lines.push("");
+  const lines = [
+    `# Inspect: ${input.relPath}:${input.line}:${input.character}`,
+    "",
+    `**Confidence:** \`${input.confidence}\``,
+    "",
+  ];
 
-  if (input.node) {
-    lines.push("## Node");
-    lines.push(
-      `- Type: \`${input.node.type}\` at ${input.relPath}:${input.node.startLine}:${input.node.startCharacter}`,
-    );
-    if (input.node.text) {
-      lines.push("```ts");
-      lines.push(input.node.text);
-      lines.push("```");
-    }
-    const ancestry = normalizeAncestry(input.node.ancestry ?? []);
-    if (ancestry.length > 0) {
-      lines.push("");
-      lines.push("### Ancestry");
-      for (const ancestor of ancestry) {
-        lines.push(`- \`${ancestor}\``);
-      }
+  renderNode(lines, input, input.sections.node);
+  renderEnclosingSymbol(lines, input.sections.enclosingSymbol);
+  renderHover(lines, input.sections.hover);
+  renderDefinitions(lines, assembly);
+  renderDiagnostics(lines, assembly);
+  return lines.join("\n");
+}
+
+function renderNode(
+  lines: string[],
+  input: InspectResultAssembly["data"],
+  observation: InspectResultAssembly["data"]["sections"]["node"],
+): void {
+  lines.push("## Syntax node");
+  if (observation.kind === "unavailable") {
+    appendUnavailable(lines, observation);
+    return;
+  }
+  appendPartial(lines, observation);
+  const node = observation.data;
+  if (!node) {
+    lines.push("_No syntax node at this point._", "");
+    return;
+  }
+  lines.push(
+    `- Type: \`${node.type}\` at ${input.relPath}:${node.startLine}:${node.startCharacter}–${node.endLine}:${node.endCharacter}`,
+  );
+  if (node.text) lines.push("```ts", node.text, "```");
+  if (node.ancestry.length > 0) {
+    lines.push("", "### Ancestry");
+    for (const ancestor of node.ancestry) {
+      lines.push(
+        `- \`${ancestor.type} L${ancestor.startLine}:${ancestor.startCharacter}–L${ancestor.endLine}:${ancestor.endCharacter}\``,
+      );
     }
-    lines.push("");
   }
+  lines.push("");
+}
 
-  if (input.enclosingSymbol) {
-    lines.push("## Enclosing symbol");
-    lines.push(
-      `- \`${input.enclosingSymbol.name}\` (${input.enclosingSymbol.kind}) L${input.enclosingSymbol.startLine}–${input.enclosingSymbol.endLine}`,
-    );
-    lines.push("");
+function renderEnclosingSymbol(
+  lines: string[],
+  observation: InspectResultAssembly["data"]["sections"]["enclosingSymbol"],
+): void {
+  lines.push("## Enclosing symbol");
+  if (observation.kind === "unavailable") {
+    appendUnavailable(lines, observation);
+    return;
   }
+  appendPartial(lines, observation);
+  const symbol = observation.data;
+  if (!symbol) {
+    lines.push("_No provider-reported declaration encloses this point._", "");
+    return;
+  }
+  lines.push(
+    `- \`${symbol.name}\` (${symbol.kind}) L${symbol.startLine}:${symbol.startCharacter}–L${symbol.endLine}:${symbol.endCharacter}`,
+    "",
+  );
+}
 
-  if (input.hover) {
-    lines.push("## Hover");
-    lines.push(input.hover);
-    lines.push("");
+function renderHover(
+  lines: string[],
+  observation: InspectResultAssembly["data"]["sections"]["hover"],
+): void {
+  lines.push("## Hover");
+  if (observation.kind === "unavailable") {
+    appendUnavailable(lines, observation);
+    return;
   }
+  appendPartial(lines, observation);
+  lines.push(observation.data ?? "_No hover result at this point._", "");
+}
 
-  if (input.definitions.length > 0) {
-    lines.push("## Definition");
-    for (const def of input.definitions) {
-      lines.push(`- \`${def.file}:${def.line}:${def.character}\``);
+function renderDefinitions(lines: string[], assembly: InspectResultAssembly): void {
+  const observation = assembly.data.sections.definition;
+  lines.push("## Definition");
+  if (appendUnavailable(lines, observation)) return;
+  appendPartial(lines, observation);
+  if (assembly.displayedDefinitions.length === 0) {
+    lines.push("_No definition result at this point._");
+  } else {
+    for (const definition of assembly.displayedDefinitions) {
+      lines.push(`- \`${definition.file}:${definition.line}:${definition.character}\``);
     }
-    lines.push("");
   }
+  const disclosure = assembly.definitionEvidence
+    ? renderEvidenceListDisclosure(assembly.definitionEvidence)
+    : null;
+  if (disclosure) lines.push("", disclosure);
+  lines.push("");
+}
 
-  if (input.diagnostics.length > 0) {
-    lines.push("## Diagnostics");
-    for (const diagnostic of input.diagnostics) {
+function renderDiagnostics(lines: string[], assembly: InspectResultAssembly): void {
+  const observation = assembly.data.sections.diagnostics;
+  const window = assembly.data.diagnosticWindow;
+  lines.push(`## Diagnostics (L${window.startLine}–L${window.endLine})`);
+  if (appendUnavailable(lines, observation)) return;
+  appendPartial(lines, observation);
+  if (assembly.displayedDiagnostics.length === 0) {
+    lines.push("_No diagnostics intersect the nearby window._");
+  } else {
+    for (const diagnostic of assembly.displayedDiagnostics) {
       lines.push(
-        `- L${diagnostic.line}: ${formatSeverity(diagnostic.severity)}: ${diagnostic.message}`,
+        `- L${diagnostic.line}:${diagnostic.character}: ${formatSeverity(diagnostic.severity)}: ${diagnostic.message}`,
       );
     }
-    lines.push("");
-  }
-
-  if (input.codeActions.length > 0) {
-    lines.push("## Code Actions");
-    for (const action of input.codeActions) {
-      const kind = action.kind ? ` (${action.kind})` : "";
-      lines.push(`- "${action.title}"${kind}`);
-    }
-    if (input.codeActionEvidence) {
-      const disclosure = renderEvidenceListMetadataDisclosure(input.codeActionEvidence);
-      if (disclosure) {
-        lines.push(disclosure);
-      }
-    }
-    lines.push("");
-  }
-
-  if (input.unavailableSections.length > 0) {
-    lines.push("## Unavailable");
-    for (const section of input.unavailableSections) {
-      lines.push(`- ${section}`);
-    }
-    lines.push("");
   }
-
-  return lines.join("\n");
+  const disclosure = assembly.diagnosticEvidence
+    ? renderEvidenceListDisclosure(assembly.diagnosticEvidence)
+    : null;
+  if (disclosure) lines.push("", disclosure);
+  lines.push("");
 }
 
-function normalizeAncestry(
-  ancestry: Array<
-    | string
-    | {
-        type: string;
-        startLine: number;
-        startCharacter: number;
-        endLine?: number;
-        endCharacter?: number;
-      }
-  >,
-): string[] {
-  return ancestry.map((entry) => {
-    if (typeof entry === "string") return entry;
-    const start = `L${entry.startLine}:${entry.startCharacter}`;
-    const end =
-      entry.endLine != null && entry.endCharacter != null
-        ? `–L${entry.endLine}:${entry.endCharacter}`
-        : "";
-    return `${entry.type} ${start}${end}`;
-  });
+function appendUnavailable(lines: string[], observation: InspectObservation<unknown>): boolean {
+  if (observation.kind !== "unavailable") return false;
+  lines.push(`_Unavailable — ${observation.reason}_`, "");
+  return true;
 }
 
-function formatSeverity(severity: number | string): string {
-  if (typeof severity === "string") {
-    return severity.charAt(0).toUpperCase() + severity.slice(1);
-  }
+function appendPartial(lines: string[], observation: InspectObservation<unknown>): void {
+  if (observation.kind === "partial") lines.push(`_Partial — ${observation.reason}_`, "");
+}
 
+function formatSeverity(severity: number): string {
   switch (severity) {
     case 1:
       return "Error";

package/src/tool/inspect/tui.ts

@@ -8,17 +8,17 @@ import { type ResultOptios, renderSimpleResult, type ToolResult } from "../../ui
 /** ── renderCall ────────────────────────────────────────────────── */
 
 export function renderInspectCall(args: unknown, theme: Theme, _context: unknown): Text {
-  const params = (args ?? {}) as { file?: string; line?: number; character?: number };
+  const params = (args ?? {}) as {
+    point?: { file: string; line: number; character: number };
+  };
 
   let content = theme.fg("toolTitle", "code_inspect");
 
-  if (params.file) {
-    const file = params.file.split("/").pop() ?? params.file;
+  if (params.point) {
+    const file = params.point.file.split("/").pop() ?? params.point.file;
     content += ` ${theme.fg("accent", file)}`;
-    if (params.line) {
-      content += theme.fg("warning", `:${params.line}`);
-      if (params.character) content += theme.fg("dim", `:${params.character}`);
-    }
+    content += theme.fg("warning", `:${params.point.line}`);
+    content += theme.fg("dim", `:${params.point.character}`);
   }
 
   return new Text(content, 0, 0);

package/src/tool/orientation/execute.ts

@@ -1,50 +1,63 @@
-/**
- * code_orientation tool executor.
- *
- * Thin orchestrator: dispatches to precise-target resolution or
- * orientation-mode depending on whether targetId/coordinates or
- * a plain focus is provided.
- */
+/** Thin Pi adapter for the session-owned Orientation workflow. */
 
+import type {
+  OrientationFocusInput,
+  OrientationWorkflowInput,
+} from "../../session/orientation-types.ts";
 import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
-import { runOrientationMode } from "./mode.ts";
-import { resolvePreciseTarget } from "./precise-target.ts";
+import { unavailableContextDetails } from "../infra/error-results.ts";
+import { toWorkflowControl } from "../infra/workflow-control.ts";
+import { assembleOrientationDetails, assembleOrientationResult } from "../result/orientation.ts";
+import { renderOrientationResult } from "./markdown.ts";
 
 export interface CodeOrientationToolParams {
-  /** Workspace-relative path or discovered module name for orientation. */
-  focus?: string;
-  /** Resolved target handle from code_resolve. Wins over focus/coordinates. */
-  targetId?: string;
-  /** 1-based line for symbol orientation. Requires focus. */
-  line?: number;
-  /** 1-based UTF-16 column for symbol orientation. Requires focus and line. */
-  character?: number;
-  /** Maximum results per rendered list. Defaults to 10. */
+  focus?: OrientationFocusInput;
   maxResults?: number;
-  // Internal-only expansion fields populated from targetId or coordinate resolution.
-  file?: string;
-  targetName?: string | null;
-  targetKind?: string | null;
-  targetAnchorKind?: "name" | "declaration";
 }
 
-/**
- * Execute the public code_orientation tool.
- *
- * When `targetId` or `line`/`character` coordinates are provided,
- * resolves a precise symbol target and runs symbol-centered sections.
- * Otherwise runs project/module/directory/file orientation mode.
- */
 export async function executeOrientationTool(
   params: CodeOrientationToolParams,
   ctx: CodeIntelToolExecCtx,
 ): Promise<CodeIntelResult> {
-  const hasCoords = params.line !== undefined || params.character !== undefined;
-  const hasTargetId = params.targetId !== undefined && params.targetId !== null;
-
-  if (hasTargetId || hasCoords) {
-    const outcome = await resolvePreciseTarget(params, ctx, hasCoords);
-    if (outcome.kind === "resolved") return outcome.result;
+  const outcome = await ctx.session.orient(
+    params as OrientationWorkflowInput,
+    toWorkflowControl(ctx),
+  );
+  if (outcome.kind === "unavailable") throw new Error(outcome.reason);
+  if (outcome.kind === "invalid-input") {
+    return {
+      content: `**Error:** ${outcome.message}`,
+      details: unavailableContextDetails(["Choose an existing path, module, or precise target"]),
+    };
+  }
+  if (outcome.kind === "disambiguation" || outcome.kind === "kind-mismatch") {
+    const candidates = outcome.candidates ?? [];
+    const lines = [
+      outcome.kind === "kind-mismatch"
+        ? `# No Orientation target matched provider kind \`${outcome.requestedKind}\``
+        : "# Multiple Orientation targets",
+      "",
+    ];
+    for (const candidate of candidates) {
+      lines.push(
+        `${candidate.rank}. **${candidate.name}** (\`${candidate.kind ?? "unknown"}\`) — \`${candidate.file}\`:${candidate.line}:${candidate.character} — \`${candidate.targetId}\``,
+      );
+    }
+    const nextQueries =
+      outcome.kind === "kind-mismatch"
+        ? ["Retry without symbolKind, use an observed provider kind, or focus one handle"]
+        : ["Use one candidate handle as focus.target.handle"];
+    const details = assembleOrientationDetails({
+      confidence: "semantic",
+      omittedCount: outcome.omittedCount,
+      candidates,
+      nextQueries,
+    });
+    return { content: lines.join("\n"), details: { type: "context", data: details } };
   }
-  return runOrientationMode(params, ctx);
+  const assembly = assembleOrientationResult(outcome.data);
+  return {
+    content: renderOrientationResult(assembly),
+    details: { type: "context", data: assembly.details },
+  };
 }

package/src/tool/orientation/markdown.ts

@@ -1,35 +1,30 @@
-import { type ReadNextItem, renderReadNextSection } from "../../analysis/read-next.ts";
-import type { OrientationSection } from "../../ui/markdown/types.ts";
+import { renderReadNextSection } from "../../analysis/read-next.ts";
+import { assembledReadNext } from "../result/assembly.ts";
+import type { OrientationResultAssembly } from "../result/orientation.ts";
 
-export interface RenderedOrientationSection {
-  key: OrientationSection;
-  title: string;
-  lines: string[];
-}
-
-export interface RenderOrientationParams {
-  focusTarget: string | null;
-  sections: RenderedOrientationSection[];
-  readNext?: ReadNextItem[];
-}
-
-/** Render a symbol-centered code_orientation result into markdown. */
-export function renderOrientationResult(params: RenderOrientationParams): string {
-  const lines: string[] = ["# Code Orientation", ""];
-
-  if (params.focusTarget) {
-    lines.push("## Focus", `- \`${params.focusTarget}\``, "");
-  }
-
-  for (const section of params.sections) {
-    lines.push(`## ${section.title}`);
-    if (section.lines.length > 0) {
-      lines.push(...section.lines);
+/** Render assembled Orientation blocks into the model-facing markdown adapter. */
+export function renderOrientationResult(assembly: OrientationResultAssembly): string {
+  const data = assembly.assembled.data;
+  const lines: string[] = [];
+  for (const block of data.blocks) {
+    switch (block.kind) {
+      case "heading":
+        lines.push(`${"#".repeat(block.level)} ${block.text}`);
+        break;
+      case "paragraph":
+        lines.push(block.text);
+        break;
+      case "list-item":
+        lines.push(`- ${block.text}`);
+        break;
+      case "code":
+        lines.push(`\`\`\`${block.language ?? ""}`, ...block.lines, "```");
+        break;
+      case "blank":
+        lines.push("");
+        break;
     }
-    lines.push("");
   }
-
-  lines.push(...renderReadNextSection(params.readNext ?? []));
-
-  return lines.join("\n");
+  lines.push(...renderReadNextSection(assembledReadNext(assembly.assembled)));
+  return lines.join("\n").trimEnd();
 }

package/src/tool/orientation/tui.ts

@@ -1,7 +1,13 @@
 import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
-import { formatEvidenceBadge } from "@mrclrchtr/supi-code-runtime/api";
-import { type ResultOptios, renderPartial, type ToolResult } from "../../ui/tui/common.ts";
+import {
+  type EvidenceEntry,
+  formatEvidenceEntry,
+  type ResultOptios,
+  readEvidenceEntries,
+  renderPartial,
+  type ToolResult,
+} from "../../ui/tui/common.ts";
 import type { CodeOrientationToolParams } from "./execute.ts";
 
 /** ── renderCall ────────────────────────────────────────────────── */
@@ -11,14 +17,15 @@ export function renderOrientationCall(args: unknown, theme: Theme, _context: unk
 
   let content = theme.fg("toolTitle", "code_orientation");
 
-  if (params.targetId) {
-    content += ` ${theme.fg("accent", "target")}`;
-  } else if (params.focus) {
-    const focus = params.focus.split("/").pop() ?? params.focus;
+  if (!params.focus) {
+    content += ` ${theme.fg("muted", "workspace")}`;
+  } else if ("path" in params.focus) {
+    const focus = params.focus.path.split("/").pop() ?? params.focus.path;
     content += ` ${theme.fg("accent", focus)}`;
-    if (params.line) content += theme.fg("warning", `:${params.line}`);
+  } else if ("module" in params.focus) {
+    content += ` ${theme.fg("accent", params.focus.module)}`;
   } else {
-    content += ` ${theme.fg("muted", "project")}`;
+    content += ` ${theme.fg("accent", "target")}`;
   }
 
   return new Text(content, 0, 0);
@@ -74,17 +81,6 @@ export function renderOrientationResult(
     container.addChild(new Text(theme.fg("dim", `Sections: ${sections.join(", ")}`), 0, 0));
   }
 
-  if (data?.omittedCount) {
-    const badge = formatEvidenceBadge({
-      shownCount: sections.length,
-      totalCount: sections.length + Number(data.omittedCount),
-      omittedCount: Number(data.omittedCount),
-      partialReason: null,
-      label: "sections",
-    });
-    container.addChild(new Text(theme.fg("dim", badge), 0, 0));
-  }
-
   if (markdownText) {
     container.addChild(new Spacer(1));
     container.addChild(new Text(theme.fg("dim", "▸ raw markdown"), 0, 0));
@@ -99,33 +95,39 @@ export function renderOrientationResult(
 function buildCompactSummary(data: Record<string, unknown> | null, theme: Theme): Text {
   if (!data) return new Text(theme.fg("dim", "No orientation"), 0, 0);
 
-  const sections = (data?.renderedSections as string[] | undefined) ?? [];
-  const confidence = (data.confidence as string) ?? "";
-  const dot = theme.fg("dim", "·");
-  const segments: string[] = [
-    `${theme.fg("dim", "sections")} ${theme.fg("success", theme.bold(`${sections.length}`))}`,
-  ];
+  const segments = summarySegments(data, theme, "success");
+  if (segments.length === 0) return new Text(theme.fg("dim", "No assembled evidence"), 0, 0);
+  return new Text(segments.join(` ${theme.fg("dim", "·")} `), 0, 0);
+}
 
-  if (confidence) {
+function buildHeader(data: Record<string, unknown> | null, theme: Theme): Text {
+  if (!data) return new Text("", 0, 0);
+  return new Text(summarySegments(data, theme, "accent").join(` ${theme.fg("dim", "·")} `), 0, 0);
+}
+
+function summarySegments(
+  data: Record<string, unknown>,
+  theme: Theme,
+  badgeColor: "accent" | "success",
+): string[] {
+  const segments: string[] = [];
+  const evidence = orientationEvidence(data);
+  if (evidence) {
+    segments.push(theme.fg(badgeColor, theme.bold(formatEvidenceEntry(evidence))));
+  }
+
+  const confidence = typeof data.confidence === "string" ? data.confidence : "";
+  if (confidence && confidence !== "unavailable") {
     segments.push(`${theme.fg("dim", "confidence")} ${theme.fg("muted", confidence)}`);
   }
 
   const target = data.target as Record<string, unknown> | undefined;
   if (target?.name) segments.push(theme.fg("muted", String(target.name)));
 
-  return new Text(segments.join(` ${dot} `), 0, 0);
+  return segments;
 }
 
-function buildHeader(data: Record<string, unknown> | null, theme: Theme): Text {
-  if (!data) return new Text("", 0, 0);
-
-  const sections = (data?.renderedSections as string[] | undefined) ?? [];
-  const confidence = (data.confidence as string) ?? "";
-  const dot = theme.fg("dim", "·");
-  const parts = [
-    `${theme.fg("dim", "sections")} ${theme.fg("accent", theme.bold(`${sections.length}`))}`,
-  ];
-  if (confidence) parts.push(`${theme.fg("dim", "confidence")} ${theme.fg("muted", confidence)}`);
-
-  return new Text(parts.join(` ${dot} `), 0, 0);
+function orientationEvidence(data: Record<string, unknown>): EvidenceEntry | null {
+  const evidence = readEvidenceEntries(data.evidenceLists);
+  return evidence.find((entry) => entry.shownCount > 0) ?? evidence[0] ?? null;
 }

package/src/tool/refactor-apply/execute.ts

@@ -1,12 +1,10 @@
-/**
- * Tool executor for the stored-plan application path.
- *
- * Thin executor: delegates to the refactor apply use-case for plan lookup,
- * freshness checking, safety validation, and workspace edit application.
- */
+/** Thin Pi adapter for session-owned refactor application. */
 
 import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
-import { executeRefactorApply } from "./orchestrate.ts";
+import { unavailableSearchDetails } from "../infra/error-results.ts";
+import { toWorkflowControl } from "../infra/workflow-control.ts";
+import { renderRefactorApplyResult } from "../refactor-plan/markdown.ts";
+import { assembleRefactorApplyDetails } from "../result/refactor.ts";
 
 export interface CodeRefactorApplyToolParams {
   planId: string;
@@ -14,7 +12,23 @@ export interface CodeRefactorApplyToolParams {
 
 export async function executeRefactorApplyTool(
   params: CodeRefactorApplyToolParams,
-  _ctx: CodeIntelToolExecCtx,
+  ctx: CodeIntelToolExecCtx,
 ): Promise<CodeIntelResult> {
-  return executeRefactorApply({ planId: params.planId }, { session: _ctx.session });
+  const outcome = await ctx.session.applyRefactor(params, toWorkflowControl(ctx));
+  if (outcome.kind === "unavailable") throw new Error(outcome.reason);
+  if (outcome.kind === "invalid-input") {
+    return {
+      content: `**Error:** ${outcome.message}`,
+      details: unavailableSearchDetails(null, ["Generate a fresh plan with code_refactor_plan"]),
+    };
+  }
+
+  const assembly = assembleRefactorApplyDetails(outcome.result, outcome.plan);
+  return {
+    content: renderRefactorApplyResult(assembly),
+    details: {
+      type: "search",
+      data: assembly.details,
+    },
+  };
 }

package/src/tool/refactor-apply/tui.ts

@@ -36,10 +36,14 @@ export function renderRefactorApplyResult(
   }
 
   if (!options.expanded) {
+    const applied =
+      !result.isError &&
+      result.details?.type === "search" &&
+      result.details.data.confidence === "semantic";
     return new Text(
-      result.isError
-        ? theme.fg("error", "Refactor apply failed")
-        : theme.fg("success", theme.bold("Plan applied")),
+      applied
+        ? theme.fg("success", theme.bold("Plan applied"))
+        : theme.fg("error", "Refactor apply failed"),
       0,
       0,
     );