@mrclrchtr/supi-code-intelligence 4.9.0 → 5.0.0

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

@@ -1,55 +1,73 @@
-/**
- * TUI renderer for code_refactor_apply — renderCall + renderResult.
- *
- * Has a custom result renderer (not using renderSimpleResult) because
- * its compact view shows success/error status rather than a count badge.
- */
+/** TUI renderer for code_refactor_apply. */
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { Container, Text } from "@earendil-works/pi-tui";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import {
+  formatCallValue,
   type ResultOptios,
+  renderDomainError,
+  renderDomainResult,
+  renderExecutionError,
   renderMarkdownDetail,
   renderPartial,
+  renderToolDisplaySections,
+  renderTruncationDisclosure,
+  type ToolRendererContext,
   type ToolResult,
 } from "../../ui/tui/common.ts";
 
-/** ── renderCall ────────────────────────────────────────────────── */
-
-export function renderRefactorApplyCall(_args: unknown, theme: Theme, _context: unknown): Text {
-  return new Text(
-    `${theme.fg("toolTitle", "code_refactor_apply")} ${theme.fg("accent", "apply plan")}`,
-    0,
-    0,
-  );
+/** Render the compact code_refactor_apply call header. */
+export function renderRefactorApplyCall(
+  args: unknown,
+  theme: Theme,
+  _context: ToolRendererContext | undefined,
+): Text {
+  const params = (args ?? {}) as { planId?: unknown };
+  const planId = formatCallValue(params.planId);
+  const suffix = planId ? ` ${theme.fg("accent", planId)}` : "";
+  return new Text(`${theme.fg("toolTitle", "code_refactor_apply")}${suffix}`, 0, 0);
 }
 
-/** ── renderResult ──────────────────────────────────────────────── */
-
+/** Render code_refactor_apply progress, status, and structured result details. */
 export function renderRefactorApplyResult(
   result: ToolResult,
   options: ResultOptios,
   theme: Theme,
-  _context: unknown,
+  context: ToolRendererContext | undefined,
 ): Container | Text {
-  if (options.isPartial) {
-    return renderPartial("Applying…", theme);
-  }
+  if (options.isPartial) return renderPartial("Applying…", theme);
+
+  const executionError = renderExecutionError(context, "code_refactor_apply failed", theme);
+  if (executionError) return executionError;
+  const domainError = renderDomainError(result, theme);
+  if (domainError) return renderDomainResult(result, options, theme, domainError);
 
   if (!options.expanded) {
     const applied =
-      !result.isError &&
-      result.details?.type === "search" &&
-      result.details.data.confidence === "semantic";
-    return new Text(
+      result.details?.status === "completed" ||
+      (result.details?.status === undefined && result.details?.data?.confidence === "semantic");
+    const status = new Text(
       applied
         ? theme.fg("success", theme.bold("Plan applied"))
         : theme.fg("error", "Refactor apply failed"),
       0,
       0,
     );
+    const truncation = renderTruncationDisclosure(result, theme);
+    if (!truncation) return status;
+    const container = new Container();
+    container.addChild(status);
+    container.addChild(new Spacer(1));
+    container.addChild(truncation);
+    return container;
   }
 
   const container = new Container();
+  renderToolDisplaySections(container, result.details?.displaySections, theme);
+  const truncation = renderTruncationDisclosure(result, theme);
+  if (truncation) {
+    container.addChild(new Spacer(1));
+    container.addChild(truncation);
+  }
   renderMarkdownDetail(container, result, theme);
   return container;
 }

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

@@ -29,6 +29,7 @@ export async function executeRefactorPlanTool(
   if (outcome.kind === "invalid-input") {
     return searchErrorResult(`**Error:** ${outcome.message}`, {
       nextQueries: ["Fix the target or operation and retry"],
+      message: outcome.message,
     });
   }
   if (outcome.kind === "ambiguous") {
@@ -40,6 +41,7 @@ export async function executeRefactorPlanTool(
       .join("\n");
     return searchErrorResult(`**Refactor ambiguous:**\n${candidates}`, {
       nextQueries: ["Use a precise target handle or anchor"],
+      message: "The refactor target is ambiguous.",
     });
   }
 
@@ -49,6 +51,8 @@ export async function executeRefactorPlanTool(
     details: {
       type: "search",
       data: assembly.details,
+      status: "completed",
+      displaySections: assembly.displaySections,
     },
   };
 }

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

@@ -1,41 +1,54 @@
-/**
- * TUI renderer for code_refactor_plan — renderCall + renderResult.
- */
+/** TUI renderer for code_refactor_plan. */
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import { type ResultOptios, renderSimpleResult, type ToolResult } from "../../ui/tui/common.ts";
+import {
+  formatCallPath,
+  formatCallValue,
+  type ResultOptios,
+  renderSimpleResult,
+  type ToolRendererContext,
+  type ToolResult,
+} from "../../ui/tui/common.ts";
 
-/** ── renderCall ────────────────────────────────────────────────── */
-
-export function renderRefactorPlanCall(args: unknown, theme: Theme, _context: unknown): Text {
+/** Render the compact code_refactor_plan call header. */
+export function renderRefactorPlanCall(
+  args: unknown,
+  theme: Theme,
+  _context: ToolRendererContext | undefined,
+): Text {
   const params = (args ?? {}) as {
-    operation?: Record<string, { newName?: string }>;
-    target?: { anchor?: { file: string }; handle?: string };
+    operation?: Record<string, { newName?: unknown } | undefined>;
+    target?: { anchor?: { file?: unknown }; handle?: unknown };
   };
 
   let content = theme.fg("toolTitle", "code_refactor_plan");
   const operation = params.operation ? Object.entries(params.operation)[0] : undefined;
   if (operation) {
-    content += ` ${theme.fg("accent", operation[0])}`;
-    if (operation[1].newName) content += ` ${theme.fg("muted", operation[1].newName)}`;
+    content += ` ${theme.fg("accent", formatCallValue(operation[0], 40) ?? "operation")}`;
+    const newName =
+      operation[1] && typeof operation[1] === "object"
+        ? formatCallValue(operation[1].newName)
+        : null;
+    if (newName) content += ` ${theme.fg("muted", newName)}`;
   }
-  if (params.target?.anchor) {
-    const file = params.target.anchor.file.split("/").pop() ?? params.target.anchor.file;
-    content += ` ${theme.fg("muted", file)}`;
-  } else if (params.target?.handle) {
-    content += ` ${theme.fg("muted", params.target.handle)}`;
+
+  const anchorFile = formatCallPath(params.target?.anchor?.file);
+  if (anchorFile) {
+    content += ` ${theme.fg("muted", anchorFile)}`;
+  } else {
+    const handle = formatCallValue(params.target?.handle);
+    if (handle) content += ` ${theme.fg("muted", handle)}`;
   }
 
   return new Text(content, 0, 0);
 }
 
-/** ── renderResult ──────────────────────────────────────────────── */
-
+/** Render code_refactor_plan progress, status, and structured result details. */
 export function renderRefactorPlanResult(
   result: ToolResult,
   options: ResultOptios,
   theme: Theme,
-  _context: unknown,
+  context: ToolRendererContext | undefined,
 ): ReturnType<typeof renderSimpleResult> {
-  return renderSimpleResult(result, options, theme, "Planning…");
+  return renderSimpleResult(result, options, theme, "Planning…", context);
 }

package/src/tool/register.ts

@@ -1,9 +1,13 @@
+import { createHmac, randomBytes } from "node:crypto";
 import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
+import { recordDebugEvent, startDebugTimer } from "@mrclrchtr/supi-core/debug";
+import { truncateIdentity } from "@mrclrchtr/supi-lsp/debug-telemetry";
 import type { WorkspaceCodeIntelligenceSession } from "../session/session.ts";
+import type { CodeIntelResult, ToolOutputTruncationDetails } from "../types/index.ts";
 import { renderFindCall, renderFindResult } from "./find/tui.ts";
 import { renderGraphCall, renderGraphResult } from "./graph/tui.ts";
 import {
@@ -76,6 +80,72 @@ function getToolRenderer(name: string): ToolRenderer {
  */
 const registeredPis = new WeakSet<object>();
 
+type CodeOperationOutcome = "completed" | "failed" | "canceled";
+
+function createDebugOperationId(secret: Buffer, toolCallId: string): string {
+  const digest = createHmac("sha256", secret).update(toolCallId).digest().subarray(0, 16);
+  return `op-${digest.toString("base64url")}`;
+}
+
+function recordCodeOperationBoundary(
+  category: "code-operation.start" | "code-operation.finish",
+  operationId: string,
+  tool: string,
+  options: { cwd: string; outcome?: CodeOperationOutcome },
+): void {
+  recordDebugEvent({
+    operationId,
+    source: "code-intelligence",
+    level: "debug",
+    category,
+    message:
+      category === "code-operation.start" ? "Code operation started" : "Code operation finished",
+    cwd: truncateIdentity(options.cwd),
+    data: options.outcome ? { tool, outcome: options.outcome } : { tool },
+  });
+}
+
+function recordCodeWorkflowTiming(
+  timer: ReturnType<typeof startDebugTimer>,
+  operationId: string,
+  tool: string,
+  options: { cwd: string; outcome: CodeOperationOutcome },
+): void {
+  timer.finish(
+    {
+      operationId,
+      source: "code-intelligence",
+      level: "debug",
+      category: "workflow.timing",
+      message: "Code workflow finished",
+      cwd: truncateIdentity(options.cwd),
+      data: { tool, outcome: options.outcome },
+    },
+    "workflow",
+  );
+}
+
+function withTruncationDetails(
+  details: CodeIntelResult["details"],
+  truncation: ToolOutputTruncationDetails,
+): CodeIntelResult["details"] {
+  return details ? { ...details, truncation } : details;
+}
+
+function terminalCodeOperationOutcome(
+  error: unknown,
+  signal: AbortSignal | undefined,
+): CodeOperationOutcome {
+  if (signal?.aborted) return "canceled";
+  if (
+    error instanceof Error &&
+    (error.name === "AbortError" || error.name === "CodeRequestDeadlineError")
+  ) {
+    return "canceled";
+  }
+  return "failed";
+}
+
 export function registerCodeIntelligenceTools(
   pi: ExtensionAPI,
   getOrCreateSession: (cwd: string) => WorkspaceCodeIntelligenceSession,
@@ -89,6 +159,7 @@ export function registerCodeIntelligenceTools(
   // ponytail: WeakSet on pi identity; getAllTools() is not callable during load.
   if (registeredPis.has(pi)) return;
   registeredPis.add(pi);
+  const operationSecret = randomBytes(32);
 
   for (const spec of specs) {
     const surface = promptSurfaces[spec.name];
@@ -100,33 +171,67 @@ export function registerCodeIntelligenceTools(
       promptGuidelines: surface.promptGuidelines,
       parameters: spec.parameters,
       // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-      execute: async (_toolCallId, params, signal, onUpdate, ctx: ExtensionContext) => {
-        const session = getOrCreateSession(ctx.cwd);
-        session.setProjectTrusted(ctx.isProjectTrusted());
-        const { content, details } = await spec.run(params, {
+      execute: async (toolCallId, params, signal, onUpdate, ctx: ExtensionContext) => {
+        const operationId = createDebugOperationId(operationSecret, toolCallId);
+        const workflowTimer = startDebugTimer();
+        recordCodeOperationBoundary("code-operation.start", operationId, spec.name, {
           cwd: ctx.cwd,
-          signal,
-          onUpdate,
-          session,
-        });
-        const { text, truncated } = truncateToolContent(content, {
-          maxLines: spec.maxLines,
-          maxBytes: spec.maxBytes,
         });
-        if (truncated && content.length > 0) {
-          const dir = mkdtempSync(join(tmpdir(), "supi-ci-"));
-          const spillPath = join(dir, `${spec.name}-output.md`);
-          writeFileSync(spillPath, content, "utf-8");
-          const notice = `\n_Full output saved to: \`${spillPath}\`_`;
+        try {
+          const session = getOrCreateSession(ctx.cwd);
+          session.setProjectTrusted(ctx.isProjectTrusted());
+          const { content, details } = await spec.run(params, {
+            cwd: ctx.cwd,
+            operationId,
+            signal,
+            onUpdate,
+            session,
+          });
+          recordCodeWorkflowTiming(workflowTimer, operationId, spec.name, {
+            cwd: ctx.cwd,
+            outcome: "completed",
+          });
+          const { text, truncated } = truncateToolContent(content, {
+            maxLines: spec.maxLines,
+            maxBytes: spec.maxBytes,
+          });
+          if (truncated && content.length > 0) {
+            const dir = mkdtempSync(join(tmpdir(), "supi-ci-"));
+            const spillPath = join(dir, `${spec.name}-output.md`);
+            writeFileSync(spillPath, content, "utf-8");
+            const notice = `\n_Full output saved to: \`${spillPath}\`_`;
+            recordCodeOperationBoundary("code-operation.finish", operationId, spec.name, {
+              cwd: ctx.cwd,
+              outcome: "completed",
+            });
+            return {
+              content: [{ type: "text" as const, text: text + notice }],
+              details: withTruncationDetails(details, {
+                truncated: true,
+                fullOutputPath: spillPath,
+              }),
+            };
+          }
+          recordCodeOperationBoundary("code-operation.finish", operationId, spec.name, {
+            cwd: ctx.cwd,
+            outcome: "completed",
+          });
           return {
-            content: [{ type: "text" as const, text: text + notice }],
-            details,
+            content: [{ type: "text" as const, text }],
+            details: withTruncationDetails(details, { truncated: false }),
           };
+        } catch (error) {
+          const outcome = terminalCodeOperationOutcome(error, signal);
+          recordCodeWorkflowTiming(workflowTimer, operationId, spec.name, {
+            cwd: ctx.cwd,
+            outcome,
+          });
+          recordCodeOperationBoundary("code-operation.finish", operationId, spec.name, {
+            cwd: ctx.cwd,
+            outcome,
+          });
+          throw error;
         }
-        return {
-          content: [{ type: "text" as const, text }],
-          details,
-        };
       },
       ...getToolRenderer(spec.name),
     });

package/src/tool/resolve/execute.ts

@@ -31,6 +31,23 @@ export async function executeResolveTool(
 
   return {
     content,
-    details: { type: "resolve", data: assembly.details },
+    details: {
+      type: "resolve",
+      data: assembly.details,
+      status:
+        outcome.kind === "resolved" || outcome.kind === "target-group"
+          ? "completed"
+          : outcome.kind === "disambiguation" || outcome.kind === "kind-mismatch"
+            ? "disambiguation"
+            : "invalid-input",
+      ...(outcome.kind === "invalid-input"
+        ? { message: outcome.message }
+        : outcome.kind === "disambiguation"
+          ? { message: "Multiple target matches require one candidate." }
+          : outcome.kind === "kind-mismatch"
+            ? { message: `No target matched provider kind ${outcome.requestedKind}.` }
+            : {}),
+      displaySections: assembly.displaySections,
+    },
   };
 }

package/src/tool/resolve/tui.ts

@@ -1,42 +1,60 @@
-/**
- * TUI renderer for code_resolve — renderCall + renderResult.
- */
+/** TUI renderer for code_resolve. */
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import { type ResultOptios, renderSimpleResult, type ToolResult } from "../../ui/tui/common.ts";
+import {
+  formatCallPath,
+  formatCallValue,
+  type ResultOptios,
+  renderSimpleResult,
+  type ToolRendererContext,
+  type ToolResult,
+} from "../../ui/tui/common.ts";
 import type { CodeResolveToolParams } from "./execute.ts";
 
-/** ── renderCall ────────────────────────────────────────────────── */
-
-export function renderResolveCall(args: unknown, theme: Theme, _context: unknown): Text {
-  const params = (args ?? {}) as CodeResolveToolParams;
-
+/** Render the compact code_resolve call header. */
+export function renderResolveCall(
+  args: unknown,
+  theme: Theme,
+  _context: ToolRendererContext | undefined,
+): Text {
+  const params = (args ?? {}) as Partial<CodeResolveToolParams>;
   let content = theme.fg("toolTitle", "code_resolve");
+  const target = params.target;
+  if (!target || typeof target !== "object") return new Text(content, 0, 0);
 
-  if ("symbol" in params.target) {
-    content += ` ${theme.fg("accent", params.target.symbol.query)}`;
-    if (params.target.symbol.symbolKind) {
-      content += theme.fg("dim", ` [${params.target.symbol.symbolKind}]`);
-    }
-  } else if ("anchor" in params.target) {
-    const point = params.target.anchor;
-    const file = point.file.split("/").pop() ?? point.file;
-    content += ` ${theme.fg("accent", file)}${theme.fg("warning", `:${point.line}`)}`;
-  } else if ("file" in params.target) {
-    const file = params.target.file.split("/").pop() ?? params.target.file;
-    content += ` ${theme.fg("accent", file)}`;
+  const targetRecord = target as unknown as Record<string, unknown>;
+  if (targetRecord.symbol && typeof targetRecord.symbol === "object") {
+    content += renderResolveSymbol(targetRecord.symbol, theme);
+  } else if (targetRecord.anchor && typeof targetRecord.anchor === "object") {
+    content += renderResolveAnchor(targetRecord.anchor, theme);
+  } else {
+    const file = formatCallPath(targetRecord.file);
+    if (file) content += ` ${theme.fg("accent", file)}`;
   }
 
   return new Text(content, 0, 0);
 }
 
-/** ── renderResult ──────────────────────────────────────────────── */
+function renderResolveSymbol(value: object, theme: Theme): string {
+  const symbol = value as { query?: unknown; symbolKind?: unknown };
+  const query = formatCallValue(symbol.query);
+  const kind = formatCallValue(symbol.symbolKind, 30);
+  return `${query ? ` ${theme.fg("accent", query)}` : ""}${kind ? theme.fg("dim", ` [${kind}]`) : ""}`;
+}
+
+function renderResolveAnchor(value: object, theme: Theme): string {
+  const point = value as { file?: unknown; line?: unknown };
+  const file = formatCallPath(point.file);
+  const line = typeof point.line === "number" ? `:${point.line}` : "";
+  return file ? ` ${theme.fg("accent", file)}${theme.fg("warning", line)}` : "";
+}
 
+/** Render code_resolve progress, status, and structured result details. */
 export function renderResolveResult(
   result: ToolResult,
   options: ResultOptios,
   theme: Theme,
-  _context: unknown,
+  context: ToolRendererContext | undefined,
 ): ReturnType<typeof renderSimpleResult> {
-  return renderSimpleResult(result, options, theme, "Resolving…");
+  return renderSimpleResult(result, options, theme, "Resolving…", context);
 }

package/src/tool/result/display.ts

@@ -0,0 +1,107 @@
+import type { ToolDisplaySection } from "./types.ts";
+
+/** Maximum number of rows shown for one expanded TUI section. */
+export const MAX_TUI_DISPLAY_ITEMS = 20;
+
+/** Maximum visible characters kept in one structured TUI row. */
+export const MAX_TUI_DISPLAY_LINE_LENGTH = 240;
+
+/** Inputs for one bounded structured TUI section. */
+export interface ToolDisplaySectionInput<T> {
+  key: string;
+  title: string;
+  items: readonly T[];
+  format: (item: T) => string;
+  totalCount?: number | null;
+  omittedCount?: number | null;
+  partialReason?: string | null;
+  maxItems?: number;
+}
+
+/** Build a bounded, serializable TUI section from collected facts. */
+export function createToolDisplaySection<T>(input: ToolDisplaySectionInput<T>): ToolDisplaySection {
+  const maxItems = Math.max(0, input.maxItems ?? MAX_TUI_DISPLAY_ITEMS);
+  const items = input.items.slice(0, maxItems);
+  const lines = items.map((item) => truncateDisplayText(input.format(item)));
+  const displayOmittedCount = Math.max(0, input.items.length - items.length);
+  let totalCount: number | null;
+  if (input.totalCount === undefined) totalCount = input.items.length;
+  else totalCount = input.totalCount;
+  const omittedCount =
+    totalCount === null
+      ? input.omittedCount === null || input.omittedCount === undefined
+        ? displayOmittedCount || null
+        : input.omittedCount + displayOmittedCount
+      : Math.max(0, totalCount - lines.length);
+
+  return {
+    key: input.key,
+    title: input.title,
+    lines,
+    shownCount: lines.length,
+    totalCount,
+    omittedCount,
+    partialReason: input.partialReason ?? null,
+  };
+}
+
+/** Keep structured TUI rows readable without parsing or emitting Markdown. */
+export function truncateDisplayText(
+  value: string,
+  maxLength = MAX_TUI_DISPLAY_LINE_LENGTH,
+): string {
+  const limit = Math.max(1, maxLength);
+  return value
+    .split("\n")
+    .map((line) => {
+      if (line.length <= limit) return line;
+      return `${line.slice(0, Math.max(0, limit - 1))}…`;
+    })
+    .join("\n");
+}
+
+/** Read valid structured TUI sections from persisted tool details. */
+export function readToolDisplaySections(value: unknown): ToolDisplaySection[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return [];
+    const record = entry as Record<string, unknown>;
+    if (
+      typeof record.key !== "string" ||
+      typeof record.title !== "string" ||
+      !Array.isArray(record.lines) ||
+      !record.lines.every((line) => typeof line === "string") ||
+      !isCount(record.shownCount) ||
+      !isNullableCount(record.totalCount) ||
+      !isNullableCount(record.omittedCount) ||
+      !isNullableString(record.partialReason)
+    ) {
+      return [];
+    }
+    return [
+      {
+        key: record.key,
+        title: record.title,
+        lines: record.lines
+          .slice(0, MAX_TUI_DISPLAY_ITEMS)
+          .map((line) => truncateDisplayText(line)),
+        shownCount: record.shownCount,
+        totalCount: record.totalCount,
+        omittedCount: record.omittedCount,
+        partialReason: record.partialReason,
+      },
+    ];
+  });
+}
+
+function isCount(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+
+function isNullableCount(value: unknown): value is number | null {
+  return value === null || isCount(value);
+}
+
+function isNullableString(value: unknown): value is string | null {
+  return value === null || typeof value === "string";
+}