@mrclrchtr/supi-code-intelligence 4.10.0 → 6.0.0

package/src/ui/tui/common.ts

@@ -6,19 +6,47 @@
  * partial/error guards, and the shared simple-result pattern.
  */
 
-import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import {
+  getMarkdownTheme,
+  type Theme,
+  type ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import { formatEvidenceBadge } from "@mrclrchtr/supi-core/evidence-badge";
+import { truncateDisplayText } from "../../tool/result/display.ts";
+import { renderToolDisplaySections } from "./display.ts";
+
+export { formatCallPath, formatCallValue, renderToolDisplaySections } from "./display.ts";
+
+import type {
+  ToolDisplaySection,
+  ToolOutputTruncationDetails,
+  ToolResultStatus,
+} from "../../tool/result/types.ts";
 
 // ── Result type ──────────────────────────────────────────────────
 
 /** Shape of a pi tool result consumed by renderResult functions. */
 export interface ToolResult {
   content: Array<{ type: string; text?: string }>;
-  details?: { type: string; data: Record<string, unknown> };
-  isError?: boolean;
+  details?: {
+    type: string;
+    data: Record<string, unknown>;
+    status?: ToolResultStatus;
+    message?: string;
+    displaySections?: readonly ToolDisplaySection[];
+    truncation?: ToolOutputTruncationDetails;
+  };
+}
+
+/** PI render context used by Code Intelligence result renderers. */
+export interface ToolRendererContext {
+  isError: boolean;
 }
 
+/** PI render options used by Code Intelligence result renderers. */
+export type ResultOptios = ToolRenderResultOptions;
+
 // ── Evidence key labels ──────────────────────────────────────────
 
 export const EVIDENCE_KEY_LABELS: Record<string, string> = {
@@ -142,7 +170,7 @@ export function renderMarkdownDetail(
   const markdownText = source.content?.find((c) => c.type === "text")?.text ?? "";
   if (!markdownText) return;
   container.addChild(new Spacer(1));
-  const divider = `${theme.fg("border", "────")} ${theme.fg("dim", "raw markdown")} ${theme.fg("border", "─".repeat(100))}`;
+  const divider = `${theme.fg("border", "────")} ${theme.fg("dim", "raw markdown")} ${theme.fg("border", "────")}`;
   container.addChild(new Text(divider, 0, 0));
   container.addChild(new Markdown(markdownText, 0, 0, getMarkdownTheme()));
 }
@@ -157,13 +185,62 @@ export function renderError(label: string, theme: Theme): Text {
   return new Text(theme.fg("error", label), 0, 0);
 }
 
-// ── Result options ───────────────────────────────────────────────
+/** Render an execution failure from PI's renderer context. */
+export function renderExecutionError(
+  context: ToolRendererContext | undefined,
+  label: string,
+  theme: Theme,
+): Text | null {
+  return context?.isError ? renderError(label, theme) : null;
+}
+
+/** Render a domain error encoded in structured result details. */
+export function renderDomainError(result: ToolResult, theme: Theme): Text | null {
+  const status = result.details?.status;
+  if (status !== "invalid-input" && status !== "disambiguation" && status !== "unavailable") {
+    return null;
+  }
+
+  const label =
+    status === "invalid-input"
+      ? "Invalid input"
+      : status === "disambiguation"
+        ? "Choose a target"
+        : "Unavailable";
+  const message = result.details?.message
+    ? `: ${truncateDisplayText(result.details.message, 160)}`
+    : "";
+  return renderError(`${label}${message}`, theme);
+}
+
+/** Render an invalid-input or unavailable result with its structured body. */
+export function renderDomainResult(
+  result: ToolResult,
+  options: ResultOptios,
+  theme: Theme,
+  error: Text,
+): Container | Text {
+  if (!options.expanded) return error;
+  const container = new Container();
+  container.addChild(error);
+  renderToolDisplaySections(container, result.details?.displaySections, theme);
+  renderMarkdownDetail(container, result, theme);
+  return container;
+}
 
-export interface ResultOptios {
-  expanded: boolean;
-  isPartial: boolean;
+/** Render the structured output-truncation disclosure. */
+export function renderTruncationDisclosure(result: ToolResult, theme: Theme): Text | null {
+  const truncation = result.details?.truncation;
+  if (!truncation?.truncated) return null;
+
+  const path = truncation.fullOutputPath
+    ? `; full output: ${truncateDisplayText(truncation.fullOutputPath, 160)}`
+    : "";
+  return new Text(theme.fg("warning", `Output truncated${path}`), 0, 0);
 }
 
+// ── Result options ───────────────────────────────────────────────
+
 // ── Shared simple-result renderer ─────────────────────────────────
 
 /**
@@ -172,19 +249,34 @@ export interface ResultOptios {
  *
  * Handles partial, error, compact, and expanded states uniformly.
  */
+// biome-ignore lint/complexity/useMaxParams: renderer signature keeps the shared helper convenient for each tool
 export function renderSimpleResult(
   result: ToolResult,
   options: ResultOptios,
   theme: Theme,
   partialLabel: string,
+  context?: ToolRendererContext,
 ): Container | Text {
   if (options.isPartial) return renderPartial(partialLabel, theme);
-  if (result.isError) return renderError("Tool failed", theme);
+
+  const executionError = renderExecutionError(context, "Tool failed", theme);
+  if (executionError) return executionError;
+
+  const domainError = renderDomainError(result, theme);
+  if (domainError) return renderDomainResult(result, options, theme, domainError);
 
   const data = result.details?.data as Record<string, unknown> | undefined;
   if (options.expanded) return buildExpandedView(result, data, theme);
 
-  return buildSimpleCompact(data, theme);
+  const compact = buildSimpleCompact(data, theme);
+  const truncation = renderTruncationDisclosure(result, theme);
+  if (!truncation) return compact;
+
+  const container = new Container();
+  container.addChild(compact);
+  container.addChild(new Spacer(1));
+  container.addChild(truncation);
+  return container;
 }
 
 function buildExpandedView(
@@ -197,7 +289,13 @@ function buildExpandedView(
   const header = buildSimpleHeader(data, theme);
   if (header) container.addChild(header);
 
+  renderToolDisplaySections(container, result.details?.displaySections, theme);
   renderStructuredDetailBody(container, data, theme);
+  const truncation = renderTruncationDisclosure(result, theme);
+  if (truncation) {
+    container.addChild(new Spacer(1));
+    container.addChild(truncation);
+  }
   renderMarkdownDetail(container, result, theme);
 
   return container;

package/src/ui/tui/display.ts

@@ -0,0 +1,48 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Container, Text } from "@earendil-works/pi-tui";
+import { readToolDisplaySections, truncateDisplayText } from "../../tool/result/display.ts";
+import type { ToolDisplaySection } from "../../tool/result/types.ts";
+
+/** Render bounded structured rows for an expanded TUI body. */
+export function renderToolDisplaySections(
+  container: Container,
+  value: unknown,
+  theme: Theme,
+): void {
+  for (const section of readToolDisplaySections(value)) {
+    container.addChild(
+      new Text(theme.fg("dim", `${section.title}${formatDisplayBounds(section)}`), 0, 0),
+    );
+    for (const line of section.lines) {
+      container.addChild(new Text(theme.fg("muted", line), 0, 0));
+    }
+  }
+}
+
+function formatDisplayBounds(section: ToolDisplaySection): string {
+  if (section.totalCount === null) {
+    const omitted = section.omittedCount ? `; ${section.omittedCount} collected omitted` : "";
+    const reason = section.partialReason
+      ? `; more may exist — ${section.partialReason}`
+      : "; partial";
+    return ` (${section.shownCount}${omitted}${reason})`;
+  }
+  if (section.omittedCount && section.omittedCount > 0) {
+    return ` (${section.shownCount} of ${section.totalCount}; ${section.omittedCount} omitted)`;
+  }
+  return ` (${section.totalCount})`;
+}
+
+/** Format one call argument for a compact human transcript row. */
+export function formatCallValue(value: unknown, maxLength = 60): string | null {
+  if (typeof value !== "string" || value.length === 0) return null;
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return truncateDisplayText(normalized, maxLength);
+}
+
+/** Show the final path segment while accepting both POSIX and Windows paths. */
+export function formatCallPath(value: unknown, maxLength = 60): string | null {
+  const formatted = formatCallValue(value, Number.MAX_SAFE_INTEGER);
+  if (!formatted) return null;
+  return formatCallValue(formatted.split(/[\\/]/).pop() ?? formatted, maxLength);
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/session/runtime.ts

@@ -1,351 +0,0 @@
-// Tree-sitter runtime — parser management, parse, and query services.
-
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { startDebugTimer } from "@mrclrchtr/supi-core/debug";
-import { resolveToolPath } from "@mrclrchtr/supi-core/path";
-import type { Language, Parser, Tree } from "web-tree-sitter";
-import { nodeToRange } from "../coordinates.ts";
-import { detectGrammar, resolveGrammarWasmPath } from "../language.ts";
-import type { GrammarId, QueryCapture, TreeSitterResult } from "../types.ts";
-
-interface ParserEntry {
-  parser: Parser;
-  language: Language;
-}
-
-/**
- * Session-scoped Tree-sitter runtime.
- *
- * A runtime owns the expensive `web-tree-sitter` initialization and parser
- * instances for one pi working directory. Call `dispose()` when the session is
- * torn down so WASM parser resources are released.
- */
-export class TreeSitterRuntime {
-  private parserModule: typeof import("web-tree-sitter") | undefined;
-  private parsers = new Map<GrammarId, ParserEntry>();
-  private parserPromises = new Map<GrammarId, Promise<ParserEntry>>();
-  private initPromise: Promise<typeof import("web-tree-sitter")> | undefined;
-  private initializing = false;
-  private disposed = false;
-
-  /** Create a runtime that resolves relative file paths from `cwd`. */
-  constructor(private cwd: string) {}
-
-  /** Ensure web-tree-sitter Parser is initialized. */
-  private async ensureParserInit(): Promise<typeof import("web-tree-sitter")> {
-    this.assertActive();
-    if (this.parserModule) return this.parserModule;
-    if (this.initializing && this.initPromise) return this.initPromise;
-
-    this.initializing = true;
-    this.initPromise = (async () => {
-      const mod = await import("web-tree-sitter");
-      await mod.Parser.init();
-      this.assertActive();
-      this.parserModule = mod;
-      return mod;
-    })();
-
-    try {
-      return await this.initPromise;
-    } catch (err: unknown) {
-      // Allow retry on next call
-      this.initPromise = undefined;
-      this.initializing = false;
-      throw new Error("Failed to initialize web-tree-sitter", { cause: err });
-    }
-  }
-
-  /**
-   * Get or create a parser entry for a grammar.
-   *
-   * Concurrent first-use calls for the same grammar share one initialization
-   * promise. Failed initialization is not cached, so a later request can retry.
-   */
-  async ensureGrammarParser(grammarId: GrammarId): Promise<ParserEntry> {
-    this.assertActive();
-    const existing = this.parsers.get(grammarId);
-    if (existing) return existing;
-
-    const pending = this.parserPromises.get(grammarId);
-    if (pending) return pending;
-
-    const promise = this.createGrammarParser(grammarId);
-    this.parserPromises.set(grammarId, promise);
-
-    try {
-      return await promise;
-    } finally {
-      if (this.parserPromises.get(grammarId) === promise) {
-        this.parserPromises.delete(grammarId);
-      }
-    }
-  }
-
-  private async createGrammarParser(grammarId: GrammarId): Promise<ParserEntry> {
-    const mod = await this.ensureParserInit();
-    const wasmPath = resolveGrammarWasmPath(grammarId);
-
-    const language = await mod.Language.load(wasmPath);
-    const parser = new mod.Parser();
-    try {
-      parser.setLanguage(language);
-    } catch (err) {
-      parser.delete();
-      throw err;
-    }
-
-    if (this.disposed) {
-      parser.delete();
-      throw new Error("Tree-sitter runtime has been disposed");
-    }
-
-    const entry = { parser, language };
-    this.parsers.set(grammarId, entry);
-    return entry;
-  }
-
-  /** Read and parse a file. Returns structured result. */
-  async parseFile(filePath: string): Promise<
-    TreeSitterResult<{
-      tree: Tree;
-      source: string;
-      resolvedPath: string;
-      grammarId: GrammarId;
-    }>
-  > {
-    const resolvedPath = resolveToolPath(this.cwd, filePath);
-
-    // Check language support first
-    const grammarId = detectGrammar(filePath);
-    if (!grammarId) {
-      return {
-        kind: "unsupported-language",
-        file: filePath,
-        message: `No Tree-sitter grammar configured for ${path.extname(filePath) || "this file type"}`,
-      };
-    }
-
-    const timer = startDebugTimer();
-    const parserState = this.parsers.has(grammarId)
-      ? "reused"
-      : this.parserPromises.has(grammarId)
-        ? "initializing"
-        : "cold";
-
-    // Read the file
-    let source: string;
-    try {
-      source = fs.readFileSync(resolvedPath, "utf-8");
-    } catch (err: unknown) {
-      finishStructuralTiming(timer, {
-        operation: "parse",
-        grammar: grammarId,
-        parserState,
-        outcome: "file-access-error",
-        finalPhase: "file-read",
-      });
-      const message = err instanceof Error ? err.message : "File could not be read";
-      return {
-        kind: "file-access-error",
-        file: filePath,
-        message,
-      };
-    }
-    timer.mark("file-read");
-
-    if (timer.enabled) {
-      try {
-        createHash("sha256").update(source).digest();
-      } catch {
-        // Timing-only hashing must not change structural behavior.
-      }
-    }
-    timer.mark("content-hash");
-
-    let parserReady = false;
-    try {
-      const entry = await this.ensureGrammarParser(grammarId);
-      timer.mark("parser-setup");
-      parserReady = true;
-      const tree = entry.parser.parse(source);
-      finishStructuralTiming(timer, {
-        operation: "parse",
-        grammar: grammarId,
-        parserState,
-        outcome: "completed",
-        finalPhase: "parse",
-      });
-      return {
-        kind: "success",
-        data: { tree: tree as Tree, source, resolvedPath, grammarId },
-      };
-    } catch (err: unknown) {
-      finishStructuralTiming(timer, {
-        operation: "parse",
-        grammar: grammarId,
-        parserState,
-        outcome: "runtime-error",
-        finalPhase: parserReady ? "parse" : "parser-setup",
-      });
-      return { kind: "runtime-error", message: formatError(err, "Parser initialization failed") };
-    }
-  }
-
-  /** Execute a Tree-sitter query against a file. */
-  async queryFile(
-    filePath: string,
-    queryString: string,
-  ): Promise<TreeSitterResult<QueryCapture[]>> {
-    if (!queryString || queryString.trim().length === 0) {
-      return { kind: "validation-error", message: "query is required and must be non-empty" };
-    }
-    if (queryString.length > MAX_QUERY_LENGTH) {
-      return {
-        kind: "validation-error",
-        message: `query exceeds maximum length of ${MAX_QUERY_LENGTH} characters`,
-      };
-    }
-
-    const parseResult = await this.parseFile(filePath);
-    if (parseResult.kind !== "success") return parseResult;
-
-    const { grammarId, tree, source } = parseResult.data;
-    const timer = startDebugTimer();
-    let compiled = false;
-
-    try {
-      const entry = await this.ensureGrammarParser(grammarId);
-      const mod = await this.ensureParserInit();
-      let query: InstanceType<typeof mod.Query>;
-
-      try {
-        query = new mod.Query(entry.language, queryString);
-        compiled = true;
-        timer.mark("query-compilation");
-      } catch (err: unknown) {
-        finishStructuralTiming(timer, {
-          operation: "query",
-          grammar: grammarId,
-          outcome: "validation-error",
-          captureCount: 0,
-          finalPhase: "query-compilation",
-        });
-        return { kind: "validation-error", message: `Invalid query: ${formatError(err)}` };
-      }
-
-      try {
-        const matches = query.matches(tree.rootNode);
-        const captures: QueryCapture[] = [];
-        for (const match of matches) {
-          for (const { name, node } of match.captures) {
-            captures.push({
-              name,
-              nodeType: node.type,
-              range: nodeToRange(node, source),
-              text: node.text,
-            });
-          }
-        }
-        finishStructuralTiming(timer, {
-          operation: "query",
-          grammar: grammarId,
-          outcome: "completed",
-          captureCount: captures.length,
-          finalPhase: "query-execution",
-        });
-        return { kind: "success", data: captures };
-      } finally {
-        query.delete();
-      }
-    } catch (err: unknown) {
-      finishStructuralTiming(timer, {
-        operation: "query",
-        grammar: grammarId,
-        outcome: "runtime-error",
-        captureCount: 0,
-        finalPhase: compiled ? "query-execution" : "query-compilation",
-      });
-      return { kind: "runtime-error", message: formatError(err, "Query execution failed") };
-    } finally {
-      tree.delete();
-    }
-  }
-
-  /** Get the grammar ID for a file, or undefined if unsupported. */
-  getGrammarId(filePath: string): GrammarId | undefined {
-    return detectGrammar(filePath);
-  }
-
-  /** Resolve a file path from cwd. */
-  resolvePath(filePath: string): string {
-    return resolveToolPath(this.cwd, filePath);
-  }
-
-  /** Dispose all held parser resources. */
-  dispose(): void {
-    this.disposed = true;
-    for (const [, entry] of this.parsers) {
-      entry.parser.delete();
-    }
-    this.parsers.clear();
-    this.parserPromises.clear();
-    this.parserModule = undefined;
-    this.initPromise = undefined;
-    this.initializing = false;
-  }
-
-  private assertActive(): void {
-    if (this.disposed) {
-      throw new Error("Tree-sitter runtime has been disposed");
-    }
-  }
-}
-
-/** Max query string length to prevent ReDoS via overly complex Tree-sitter patterns. */
-const MAX_QUERY_LENGTH = 10_000;
-
-type StructuralTimer = ReturnType<typeof startDebugTimer>;
-type ParserState = "cold" | "initializing" | "reused";
-
-type StructuralTimingObservation =
-  | {
-      readonly operation: "parse";
-      readonly grammar: GrammarId;
-      readonly parserState: ParserState;
-      readonly outcome: "completed" | "file-access-error" | "runtime-error";
-      readonly finalPhase: "file-read" | "parse" | "parser-setup";
-    }
-  | {
-      readonly operation: "query";
-      readonly grammar: GrammarId;
-      readonly outcome: "completed" | "runtime-error" | "validation-error";
-      readonly captureCount: number;
-      readonly finalPhase: "query-compilation" | "query-execution";
-    };
-
-function finishStructuralTiming(
-  timer: StructuralTimer,
-  observation: StructuralTimingObservation,
-): void {
-  const { finalPhase, ...data } = observation;
-  timer.finish(
-    () => ({
-      source: "tree-sitter",
-      level: "debug",
-      category: `structural.${data.operation}.timing`,
-      message: `Tree-sitter ${data.operation} ${data.outcome}`,
-      data: { ...data },
-    }),
-    finalPhase,
-  );
-}
-
-/** Format errors with their cause chain's first message for user-facing tool output. */
-function formatError(err: unknown, fallback = "Operation failed"): string {
-  if (!(err instanceof Error)) return String(err || fallback);
-  if (err.cause instanceof Error) return `${err.message}: ${err.cause.message}`;
-  return err.message || fallback;
-}

package/src/tool/find/tui.ts

@@ -1,39 +0,0 @@
-/**
- * TUI renderer for code_find — renderCall + renderResult.
- */
-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 type { CodeFindToolParams } from "./execute.ts";
-
-/** ── renderCall ────────────────────────────────────────────────── */
-
-export function renderFindCall(args: unknown, theme: Theme, _context: unknown): Text {
-  const params = (args ?? {}) as CodeFindToolParams;
-  const mode = params.mode ?? "mode?";
-
-  let content = theme.fg("toolTitle", "code_find");
-
-  if (params.query) {
-    content += ` ${theme.fg("accent", JSON.stringify(params.query))}`;
-  }
-
-  content += ` ${theme.fg("muted", mode)}`;
-
-  if (params.kind) {
-    content += theme.fg("dim", ` [${params.kind}]`);
-  }
-
-  return new Text(content, 0, 0);
-}
-
-/** ── renderResult ──────────────────────────────────────────────── */
-
-export function renderFindResult(
-  result: ToolResult,
-  options: ResultOptios,
-  theme: Theme,
-  _context: unknown,
-): ReturnType<typeof renderSimpleResult> {
-  return renderSimpleResult(result, options, theme, "Searching…");
-}

package/src/tool/graph/execute.ts

@@ -1,62 +0,0 @@
-/** Thin Pi adapter for the session-owned code_graph workflow. */
-
-import type { GraphWorkflowInput, RequestedGraphRelation } from "../../session/graph-types.ts";
-import type { GraphTargetInput } from "../../session/target-input.ts";
-import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
-import { toWorkflowControl } from "../infra/workflow-control.ts";
-import { searchErrorResult } from "../result/errors.ts";
-import { assembleGraphResult } from "../result/graph.ts";
-import { renderGraphResult } from "./markdown.ts";
-
-export type GraphRelation = RequestedGraphRelation;
-
-export interface CodeGraphToolParams {
-  target: GraphTargetInput;
-  relations?: GraphRelation[];
-  calleeDepth?: "direct" | "deep";
-  maxResults?: number;
-}
-
-export async function executeGraphTool(
-  params: CodeGraphToolParams,
-  ctx: CodeIntelToolExecCtx,
-): Promise<CodeIntelResult> {
-  const outcome = await ctx.session.graph(params as GraphWorkflowInput, toWorkflowControl(ctx));
-
-  if (outcome.kind === "unavailable") throw new Error(outcome.reason);
-  if (outcome.kind === "invalid-input") {
-    return searchErrorResult(`**Error:** ${outcome.message}`);
-  }
-  if (outcome.kind === "disambiguation" || outcome.kind === "kind-mismatch") {
-    const lines = [
-      outcome.kind === "kind-mismatch"
-        ? `**No target matched provider kind \`${outcome.requestedKind}\`. Near matches:**`
-        : "**Target is ambiguous. Choose one candidate handle:**",
-      "",
-    ];
-    for (const candidate of outcome.candidates) {
-      lines.push(
-        `- \`${candidate.targetId}\` — ${candidate.name} (\`${candidate.kind ?? "unknown"}\`) at ${candidate.file}:${candidate.line}:${candidate.character}`,
-      );
-    }
-    if (outcome.kind === "kind-mismatch") {
-      lines.push(
-        "",
-        "Retry without `symbolKind`, use an observed provider kind, or choose a handle.",
-      );
-    }
-    return searchErrorResult(lines.join("\n"));
-  }
-
-  const assembly = assembleGraphResult({
-    displayName: outcome.displayName,
-    sections: outcome.sections,
-    resolvedDisplayFile: outcome.resolvedDisplayFile,
-    maxResults: outcome.maxResults,
-    cwd: ctx.cwd,
-  });
-  return {
-    content: renderGraphResult(assembly),
-    details: { type: "search", data: assembly.details },
-  };
-}