@esso0428/pi-subagents 0.15.6 → 0.15.7

package/src/ui/ccstyle/diff/line-width-safety.ts

@@ -0,0 +1,92 @@
+import { normalizeDiffRenderWidth } from "./diff-presentation.js";
+import { pluralize } from "./render-utils.js";
+import { showMoreHintText } from "./render-utils.js";
+
+export interface WidthMeasurementOps {
+	measure(text: string): number;
+	truncate(text: string, maxWidth: number): string;
+}
+
+export interface CollapsedDiffHintOptions {
+	remainingLines: number;
+	hiddenHunks: number;
+}
+
+function guardSafeWidth(width: number): number | undefined {
+	const safe = normalizeDiffRenderWidth(width);
+	return safe === 0 ? undefined : safe;
+}
+
+function renderWithSafeWidth<T>(width: number, fallback: T, render: (safeWidth: number) => T): T {
+	const safeWidth = guardSafeWidth(width);
+	if (safeWidth === undefined) {
+		return fallback;
+	}
+	return render(safeWidth);
+}
+
+export function clampRenderedLineToWidth(
+	text: string,
+	width: number,
+	ops: WidthMeasurementOps,
+): string {
+	return renderWithSafeWidth(width, "", (safeWidth) => {
+		if (ops.measure(text) <= safeWidth) {
+			return text;
+		}
+
+		for (let targetWidth = safeWidth; targetWidth >= 0; targetWidth--) {
+			const candidate = ops.truncate(text, targetWidth);
+			if (ops.measure(candidate) <= safeWidth) {
+				return candidate;
+			}
+		}
+
+		return "";
+	});
+}
+
+export function clampRenderedLinesToWidth(
+	lines: string[],
+	width: number,
+	ops: WidthMeasurementOps,
+): string[] {
+	return lines.map((line) => clampRenderedLineToWidth(line, width, ops));
+}
+
+export function buildCollapsedDiffHintText(
+	options: CollapsedDiffHintOptions,
+	width: number,
+	ops: WidthMeasurementOps,
+): string {
+	return renderWithSafeWidth(width, "", (safeWidth) => {
+		const remainingText = `${options.remainingLines} more ${pluralize(options.remainingLines, "diff line")}`;
+		const hiddenHunksText =
+			options.hiddenHunks > 0
+				? `${options.hiddenHunks} more ${pluralize(options.hiddenHunks, "hunk")}`
+				: undefined;
+		const shortRemainingText = `${options.remainingLines} more ${pluralize(options.remainingLines, "line")}`;
+		const shortHiddenHunksText =
+			options.hiddenHunks > 0
+				? `${options.hiddenHunks} ${pluralize(options.hiddenHunks, "hunk")}`
+				: undefined;
+
+		const candidates = [
+			`… (${[remainingText, hiddenHunksText, showMoreHintText()].filter(Boolean).join(" • ")})`,
+			`… (${[remainingText, hiddenHunksText].filter(Boolean).join(" • ")})`,
+			`… (${[shortRemainingText, shortHiddenHunksText].filter(Boolean).join(" • ")})`,
+			options.hiddenHunks > 0
+				? `… (+${options.remainingLines} • +${options.hiddenHunks}h)`
+				: `… (+${options.remainingLines})`,
+			"…",
+		];
+
+		for (const candidate of candidates) {
+			if (ops.measure(candidate) <= safeWidth) {
+				return candidate;
+			}
+		}
+
+		return clampRenderedLineToWidth(candidates[candidates.length - 1] ?? "", safeWidth, ops);
+	});
+}

package/src/ui/ccstyle/diff/render-utils.ts

@@ -0,0 +1,32 @@
+export { sanitizeAnsiForThemedOutput } from "./ansi-utils.js";
+
+export function pluralize(count: number, singular: string, plural = `${singular}s`): string {
+  return count === 1 ? singular : plural;
+}
+
+/** Strip terminal control sequences before captured tool text is rendered again. */
+const UNSAFE_TERMINAL_ESCAPE = new RegExp(
+  "(?:\\u001B\\]|\\u009D)[\\s\\S]*?(?:\\u0007|\\u001B\\x5C|\\u009C)" +
+    "|(?:\\u001B[PX^_]|\\u0090)[\\s\\S]*?(?:\\u001B\\x5C|\\u009C)" +
+    "|(?:\\u001B\\[|\\u009B)[0-?]*[ -/]*[@-~]" +
+    "|\\u001B[@-_]",
+  "g",
+);
+
+export function sanitizeToolResultText(value: string, maxChars?: number): string {
+  const source =
+    typeof maxChars === "number" && maxChars >= 0 && value.length > maxChars
+      ? value.slice(0, maxChars)
+      : value;
+  return source
+    .replace(UNSAFE_TERMINAL_ESCAPE, "")
+    .replace(/\x1B/g, "")
+    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, "")
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n");
+}
+
+/** Kept local so renderer modules do not depend on a package-global hint setting. */
+export function showMoreHintText(): string {
+  return "click to show more";
+}

package/src/ui/ccstyle/diff/types.ts

@@ -0,0 +1,33 @@
+export type DiffViewMode = "auto" | "split" | "unified";
+export type DiffIndicatorMode = "bars" | "classic" | "none";
+
+/** Immutable viewer-local configuration; no global ccstyle config is consulted. */
+export interface ViewerDiffConfig {
+  diffWordWrap: boolean;
+  diffViewMode: DiffViewMode;
+  diffIndicatorMode: DiffIndicatorMode;
+  editDiffCollapsedLines: number;
+  expandedPreviewMaxLines: number;
+  /** Optional compatibility knobs for callers that want split/write tuning. */
+  diffSplitMinWidth?: number;
+  writeDiffCollapsedLines?: number;
+}
+
+/** @deprecated Use ViewerDiffConfig. Kept as a local alias for renderer callers. */
+export type ToolDisplayConfig = ViewerDiffConfig;
+
+export const DEFAULT_TOOL_DISPLAY_CONFIG: ViewerDiffConfig = Object.freeze({
+  diffWordWrap: true,
+  diffViewMode: "auto",
+  diffIndicatorMode: "bars",
+  editDiffCollapsedLines: 24,
+  expandedPreviewMaxLines: 40,
+  diffSplitMinWidth: 120,
+  writeDiffCollapsedLines: 0,
+});
+
+export interface PersistedDiff {
+  diff?: string;
+  patch?: string;
+  diffUnavailableReason?: string;
+}

package/src/ui/ccstyle/diff/write-display-utils.ts

@@ -0,0 +1,12 @@
+export function splitWriteContentLines(content: string): string[] {
+	if (!content) {
+		return [];
+	}
+
+	const normalized = content.replace(/\r\n?/g, "\n");
+	const lines = normalized.split("\n");
+	if (lines.length > 0 && lines[lines.length - 1] === "") {
+		lines.pop();
+	}
+	return lines;
+}

package/src/ui/ccstyle/tool-renderer.ts

@@ -0,0 +1,71 @@
+import { truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import { createViewerCcstyleResult, oneLine } from "./tool-result.js";
+
+export interface ViewerToolRenderers {
+  name: string;
+  label: string;
+  renderShell: "self";
+  renderCall?: (args: unknown, theme: any, context: any) => Component;
+  renderResult?: (result: any, options: any, theme: any, context: any) => Component;
+}
+
+function titleForTool(toolName: string): string {
+  return toolName
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_-]+/g, " ")
+    .replace(/\b\w/g, (character) => character.toUpperCase());
+}
+
+function summaryForCall(toolName: string, args: any): string {
+  if (!args || typeof args !== "object") return titleForTool(toolName);
+  const value =
+    args.path ?? args.file_path ?? args.command ?? args.query ?? args.pattern ?? args.url ?? args.name;
+  return value === undefined
+    ? titleForTool(toolName)
+    : `${titleForTool(toolName)} ${oneLine(value)}`;
+}
+
+function renderCallComponent(toolName: string, args: any, theme: any, context: any): Component {
+  const pending = context?.isPartial || context?.executionStarted;
+  const icon = pending ? "●" : context?.isError ? "✗" : "✓";
+  const color = pending ? "accent" : context?.isError ? "error" : "success";
+  return {
+    render(width: number): string[] {
+      const safeWidth = Math.max(1, Math.floor(Number.isFinite(width) ? width : 1));
+      const prefix = ` ${theme.fg(color, icon)} `;
+      return [truncateToWidth(prefix + theme.fg("toolTitle", summaryForCall(toolName, args)), safeWidth, "")];
+    },
+    invalidate() {},
+  };
+}
+
+/**
+ * Create a renderer definition consumed by the public ToolExecutionComponent
+ * renderer hooks. It is viewer-local: no Pi prototype or terminal listener is
+ * installed, and no global ccstyle configuration is read.
+ */
+export function createViewerCcstyleTool(toolName: string): ViewerToolRenderers {
+  const name = String(toolName || "tool");
+  // ToolExecutionComponent does not expose its result to renderCall. Keep a
+  // renderer-local settled bit so a rebuilt history card can show ✓/✗ rather
+  // than treating every reconstructed call as still running.
+  let settled = false;
+  return {
+    name,
+    label: name,
+    renderShell: "self",
+    renderCall(args, theme, context) {
+      return renderCallComponent(name, args, theme, {
+        ...context,
+        executionStarted: settled ? false : context?.executionStarted,
+      });
+    },
+    renderResult(result, options, theme, context) {
+      settled = true;
+      return createViewerCcstyleResult(name, result, options, theme, context);
+    },
+  };
+}
+
+export { renderRichToolResult } from "./tool-result.js";
+export type { PersistedDiff, ViewerDiffConfig } from "./diff/types.js";

package/src/ui/ccstyle/tool-result.ts

@@ -0,0 +1,238 @@
+import { Text, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component } from "@earendil-works/pi-tui";
+import {
+  renderEditDiffResult,
+  renderWriteDiffResult,
+  type DisplayConfigInput,
+} from "./diff/diff-renderer.js";
+import { DEFAULT_TOOL_DISPLAY_CONFIG, type PersistedDiff, type ViewerDiffConfig } from "./diff/types.js";
+import { sanitizeToolResultText, showMoreHintText } from "./diff/render-utils.js";
+
+export function toolViewportWidth(width: number): number {
+  return Math.max(1, Math.floor(Number.isFinite(width) ? width : 1));
+}
+
+export function oneLine(value: unknown, max = 4096): string {
+  const text = sanitizeToolResultText(String(value ?? "")).replace(/\s+/g, " ").trim();
+  return text.length > max ? `${text.slice(0, Math.max(0, max - 1))}…` : text;
+}
+
+function rawTextFromResult(result: any): string {
+  return Array.isArray(result?.content)
+    ? result.content
+        .filter((item: any) => item?.type === "text")
+        .map((item: any) => String(item.text ?? ""))
+        .join("\n")
+    : "";
+}
+
+export function textFromResult(result: any, expanded = false): string {
+  const content = sanitizeToolResultText(rawTextFromResult(result), 16_384);
+  const detail = result?.details;
+  if (!expanded || detail === undefined) return content;
+  const details = sanitizeToolResultText(
+    typeof detail === "string" ? detail : safeJson(detail),
+    16_384,
+  );
+  if (!details || details === content) return content;
+  return content ? `${content}\nDetails:\n${details}` : details;
+}
+
+function safeJson(value: unknown): string {
+  try {
+    return JSON.stringify(value, null, 2) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+
+export function outputLineCount(result: any): number {
+  const text = rawTextFromResult(result).replace(/\r\n?/g, "\n").replace(/\n+$/, "");
+  return text ? text.split("\n").length : 0;
+}
+
+export function countLines(text: string): number {
+  return text.trim() ? text.trim().split("\n").length : 0;
+}
+
+export function formatToolInputArgs(args: unknown, maxChars = 8_000): string {
+  if (args === undefined || args === null) return "";
+  const rendered =
+    typeof args === "object" ? safeJson(args) : sanitizeToolResultText(String(args));
+  const bounded = sanitizeToolResultText(rendered, maxChars);
+  return rendered.length > maxChars ? `${bounded}…` : bounded;
+}
+
+function hasExpandableDetail(text: string, args: unknown): boolean {
+  return countLines(text) > 1 || formatToolInputArgs(args).trim().length > 0;
+}
+
+/** Small Component used for the viewer-local Input/Output card. */
+class ExpandedToolIoView implements Component {
+  private readonly input: string;
+  private readonly output: string;
+  private readonly isError: boolean;
+
+  constructor(input: string, output: string, isError: boolean) {
+    this.input = input;
+    this.output = output || "Done";
+    this.isError = isError;
+  }
+
+  render(width: number): string[] {
+    const safeWidth = toolViewportWidth(width);
+    const rows: string[] = [];
+    const addSection = (title: string, body: string, last: boolean) => {
+      rows.push(truncateToWidth(`${last ? "└" : "├"} ${title}`, safeWidth, ""));
+      const source = body.replace(/\t/g, "   ").replace(/\n+$/, "") || "(empty)";
+      for (const line of source.split("\n")) {
+        for (const wrapped of wrapTextWithAnsi(line, Math.max(1, safeWidth - 3))) {
+          const prefix = last ? "  " : "│ ";
+          rows.push(truncateToWidth(`${prefix}${wrapped}`, safeWidth, ""));
+        }
+      }
+    };
+    if (this.input.trim()) {
+      addSection("Input", this.input, false);
+      addSection("Output", this.output, true);
+    } else {
+      addSection("Output", this.output, true);
+    }
+    return rows.map((row) => (this.isError ? row : row));
+  }
+
+  invalidate(): void {}
+}
+
+function unavailableComponent(reason: string, theme: any): Component {
+  return {
+    render(width: number): string[] {
+      return [truncateToWidth(theme.fg("warning", `↳ diff unavailable: ${oneLine(reason, 512)}`), toolViewportWidth(width), "")];
+    },
+    invalidate() {},
+  };
+}
+
+function resultText(result: any): string {
+  return rawTextFromResult(result);
+}
+
+function persistedFromDetails(details: any): PersistedDiff | undefined {
+  if (!details || typeof details !== "object") return undefined;
+  const persisted: PersistedDiff = {};
+  if (typeof details.diff === "string") persisted.diff = details.diff;
+  if (typeof details.patch === "string") persisted.patch = details.patch;
+  if (typeof details.diffUnavailableReason === "string") {
+    persisted.diffUnavailableReason = details.diffUnavailableReason;
+  }
+  return Object.keys(persisted).length ? persisted : undefined;
+}
+
+function viewerConfig(context: any): ViewerDiffConfig {
+  const candidate = context?.diffConfig;
+  if (!candidate || typeof candidate !== "object") return DEFAULT_TOOL_DISPLAY_CONFIG;
+  return {
+    ...DEFAULT_TOOL_DISPLAY_CONFIG,
+    ...candidate,
+  };
+}
+
+/**
+ * Rich edit/write rendering for the conversation viewer. Durable details are
+ * passed through before any live/ephemeral context so history is deterministic.
+ */
+export function renderRichToolResult(
+  toolName: string,
+  result: any,
+  options: any,
+  theme: any,
+  context: any,
+): Component | undefined {
+  if (options?.isPartial || options?.isError || context?.isError) return undefined;
+  const expanded = options?.expanded === true || context?.expanded === true;
+  const args = context?.args ?? options?.args;
+  const filePath = args?.file_path ?? args?.path;
+  const details = result?.details;
+  const persistedDiff = context?.persistedDiff ?? persistedFromDetails(details);
+
+  if (toolName === "edit") {
+    return renderEditDiffResult(
+      details,
+      { expanded, filePath, persistedDiff, isHovered: options?.isHovered, invalidate: context?.invalidate },
+      viewerConfig(context),
+      theme,
+      resultText(result),
+    );
+  }
+  if (toolName !== "write") return undefined;
+  if (persistedDiff?.diffUnavailableReason && !persistedDiff.diff && !persistedDiff.patch) {
+    return unavailableComponent(persistedDiff.diffUnavailableReason, theme);
+  }
+
+  const content = typeof args?.content === "string" ? args.content : undefined;
+  if (!content && !persistedDiff?.diff && !persistedDiff?.patch) {
+    return unavailableComponent("execution metadata is unavailable", theme);
+  }
+  return renderWriteDiffResult(
+    content,
+    {
+      expanded,
+      filePath,
+      persistedDiff,
+      previousContent: context?.previousContent,
+      fileExistedBeforeWrite: context?.fileExistedBeforeWrite,
+      isHovered: options?.isHovered,
+      invalidate: context?.invalidate,
+    },
+    viewerConfig(context),
+    theme,
+    resultText(result),
+  );
+}
+
+function renderCallSummary(toolName: string, args: any, theme: any): string {
+  const title = toolName.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ");
+  const value = args?.path ?? args?.file_path ?? args?.command ?? args?.query ?? args?.name;
+  const summary = value === undefined ? title : `${title} ${oneLine(value)}`;
+  return theme.fg("toolTitle", summary);
+}
+
+function settledIcon(context: any): string {
+  if (context?.isError) return "✗";
+  if (context?.isPartial || context?.executionStarted) return "●";
+  return "✓";
+}
+
+function renderFallbackResult(result: any, options: any, theme: any, context: any): Component {
+  const error = options?.isError || context?.isError;
+  const expanded = options?.expanded === true || context?.expanded === true;
+  const text = textFromResult(result, expanded);
+  if (expanded && (text.trim() || formatToolInputArgs(context?.args).trim())) {
+    return new ExpandedToolIoView(formatToolInputArgs(context?.args), text, Boolean(error));
+  }
+  const lines = text ? text.split("\n") : [];
+  const count = lines.length;
+  const summary = error ? oneLine(text) || "Failed" : count ? `${count} ${count === 1 ? "line" : "lines"} returned` : "Done";
+  const expandable = !expanded && hasExpandableDetail(text, context?.args);
+  return {
+    render(width: number): string[] {
+      const hint = expandable ? ` • ${showMoreHintText()}` : "";
+      return [truncateToWidth(theme.fg(error ? "error" : "muted", `   ↳ ${summary}${hint}`), toolViewportWidth(width), "")];
+    },
+    invalidate() {},
+  };
+}
+
+export function createViewerCcstyleResult(
+  toolName: string,
+  result: any,
+  options: any,
+  theme: any,
+  context: any,
+): Component {
+  return (
+    renderRichToolResult(toolName, result, options, theme, context) ??
+    renderFallbackResult(result, options, theme, context)
+  );
+}
+
+export { ExpandedToolIoView };