pi-extensions-tool-display 0.1.1 → 0.2.1

package/src/disposable.ts

@@ -0,0 +1,34 @@
+// Track cleanup callbacks for reload safety
+let cleanupCallbacks: Array<() => void> = [];
+let isDisposed = false;
+
+export function registerCleanup(callback: () => void): void {
+  if (isDisposed) {
+    callback();
+    return;
+  }
+  cleanupCallbacks.push(callback);
+}
+
+export function registerTimer(timer: ReturnType<typeof setInterval> | ReturnType<typeof setTimeout>): void {
+  registerCleanup(() => clearInterval(timer as ReturnType<typeof setInterval>));
+}
+
+export function disposeAll(): void {
+  if (isDisposed) return;
+  isDisposed = true;
+  // Run in reverse order (LIFO)
+  for (let i = cleanupCallbacks.length - 1; i >= 0; i--) {
+    try { cleanupCallbacks[i](); } catch (cleanupError) { void cleanupError; }
+  }
+  cleanupCallbacks = [];
+}
+
+export function resetDisposed(): void {
+  isDisposed = false;
+  cleanupCallbacks = [];
+}
+
+export function getCleanupCount(): number {
+  return cleanupCallbacks.length;
+}

package/src/extension-lifecycle.ts

@@ -0,0 +1,14 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Register a session_shutdown handler that runs cleanup only when the
+ * session is shutting down for a reload. Centralizes the reload-detection
+ * check shared by extension registration modules.
+ */
+export function onReloadShutdown(pi: ExtensionAPI, cleanup: () => void): void {
+  pi.on("session_shutdown", async (event: { reason?: string }) => {
+    if (event?.reason === "reload") {
+      cleanup();
+    }
+  });
+}

package/src/index.ts

@@ -1,98 +1,151 @@
-import { Container, type Component } from "@earendil-works/pi-tui";
-
-export const TOOL_DISPLAY_API_KEY = Symbol.for("pi-tool-display.api.v1");
-export const PENDING_MIDDLEWARES_KEY = Symbol.for("pi-tool-display.pendingResultRenderMiddlewares.v1");
-
-export type RenderTheme = {
-  fg(color: string, text: string): string;
-  bold(text: string): string;
-};
-
-export type ResultMiddlewareContext = {
-  toolName: string;
-  result: unknown;
-  options: { expanded?: boolean };
-  theme: RenderTheme;
-};
-
-export type ResultMiddleware = (
-  context: ResultMiddlewareContext,
-  next: () => unknown,
-) => unknown;
-
-export type MiddlewareRegistration = {
-  id: string;
-  toolName: string;
-  middleware: ResultMiddleware;
-};
-
-export type ToolDisplayApi = {
-  registerResultRenderMiddleware?(registration: MiddlewareRegistration): string;
-  unregisterResultRenderMiddleware?(id: string): boolean;
-  hasResultRenderMiddleware?(id: string): boolean;
-  isResultRenderPipelineActive?(toolName: string): boolean;
-};
-
-type GlobalProtocol = typeof globalThis & {
-  [TOOL_DISPLAY_API_KEY]?: ToolDisplayApi;
-  [PENDING_MIDDLEWARES_KEY]?: MiddlewareRegistration[];
-};
-
-function getApi(): ToolDisplayApi | undefined {
-  return (globalThis as GlobalProtocol)[TOOL_DISPLAY_API_KEY];
-}
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  loadToolDisplayConfig,
+  normalizeToolDisplayConfig,
+  saveToolDisplayConfig,
+} from "./config-store.js";
+import {
+  applyCapabilityConfigGuards,
+  detectToolDisplayCapabilities,
+  type ToolDisplayCapabilities,
+} from "./capabilities.js";
+import { registerToolDisplayOverrides } from "./tool-overrides.js";
+import { disposeAll, resetDisposed } from "./disposable.js";
+import { registerThinkingLabeling } from "./thinking-label.js";
+import registerNativeUserMessageBox from "./user-message-box-native.js";
+import {
+  BUILT_IN_TOOL_OVERRIDE_NAMES,
+  type ConfigLoadResult,
+  type ToolDisplayConfig,
+} from "./types.js";
+
+export * from "./result-render-middleware.js";
 
-function queueRegistration(registration: MiddlewareRegistration): void {
-  const globalProtocol = globalThis as GlobalProtocol;
-  const queue = Array.isArray(globalProtocol[PENDING_MIDDLEWARES_KEY])
-    ? globalProtocol[PENDING_MIDDLEWARES_KEY]!
-    : [];
-  const index = queue.findIndex((entry) => entry?.id === registration.id);
-  if (index >= 0) queue[index] = registration;
-  else queue.push(registration);
-  globalProtocol[PENDING_MIDDLEWARES_KEY] = queue;
+function ownershipChanged(
+  previous: ToolDisplayConfig,
+  next: ToolDisplayConfig,
+): boolean {
+  return BUILT_IN_TOOL_OVERRIDE_NAMES.some(
+    (toolName) =>
+      previous.registerToolOverrides[toolName] !==
+      next.registerToolOverrides[toolName],
+  );
 }
 
-function removeQueuedRegistration(id: string): void {
-  const queue = (globalThis as GlobalProtocol)[PENDING_MIDDLEWARES_KEY];
-  if (!Array.isArray(queue)) return;
-  const index = queue.findIndex((entry) => entry?.id === id);
-  if (index >= 0) queue.splice(index, 1);
+export function toolDisplayReloadRequired(
+  previous: ToolDisplayConfig,
+  next: ToolDisplayConfig,
+): boolean {
+  return previous.enabled !== next.enabled || ownershipChanged(previous, next);
 }
 
-export function registerResultRenderMiddleware(
-  registration: MiddlewareRegistration,
-): () => void {
-  const api = getApi();
-  if (typeof api?.registerResultRenderMiddleware === "function") {
-    api.registerResultRenderMiddleware(registration);
-  } else {
-    queueRegistration(registration);
+const initializedHosts = new WeakSet<ExtensionAPI>();
+
+function hasRegisteredToolDisplayCommand(pi: ExtensionAPI): boolean {
+  try {
+    return pi.getCommands().some((command) => command.name === "tool-display");
+  } catch {
+    return false;
   }
+}
+
+/**
+ * Load the display host when a feature extension uses this package as a
+ * dependency. Pi only auto-loads top-level packages, so relying on the
+ * dependency's `pi.extensions` metadata alone would leave the middleware
+ * queue undrained for users who install `pi-distill` or `pi-tool-supervisor`.
+ */
+export function ensureToolDisplayHost(
+  pi: ExtensionAPI,
+  initial: ConfigLoadResult = loadToolDisplayConfig(),
+): void {
+  if (initializedHosts.has(pi)) return;
+  initializedHosts.add(pi);
 
-  return () => {
-    getApi()?.unregisterResultRenderMiddleware?.(registration.id);
-    removeQueuedRegistration(registration.id);
+  resetDisposed();
+
+  pi.on("session_shutdown", (event: { reason: string }) => {
+    if (event.reason === "reload") {
+      disposeAll();
+      initializedHosts.delete(pi);
+    }
+  });
+
+  let config: ToolDisplayConfig = initial.config;
+  let pendingLoadError = initial.error;
+  let capabilities: ToolDisplayCapabilities = {
+    hasMcpTooling: false,
+    hasRtkOptimizer: false,
   };
-}
 
-export function isResultRenderMiddlewareActive(id: string, toolName: string): boolean {
-  const api = getApi();
-  return api?.hasResultRenderMiddleware?.(id) === true
-    && api.isResultRenderPipelineActive?.(toolName) === true;
-}
+  const refreshCapabilities = (): void => {
+    capabilities = detectToolDisplayCapabilities(pi, process.cwd());
+  };
+
+  const getConfig = (): ToolDisplayConfig => config;
+  const getCapabilities = (): ToolDisplayCapabilities => capabilities;
+  const getEffectiveConfig = (): ToolDisplayConfig =>
+    applyCapabilityConfigGuards(config, capabilities);
+
+  const setConfig = (
+    next: ToolDisplayConfig,
+    ctx: ExtensionCommandContext,
+  ): void => {
+    const normalized = normalizeToolDisplayConfig(next);
+    const requiresReload = toolDisplayReloadRequired(config, normalized);
+    config = normalized;
+
+    const saved = saveToolDisplayConfig(normalized);
+    if (!saved.success && saved.error) {
+      ctx.ui.notify(saved.error, "error");
+    }
+
+    if (requiresReload) {
+      ctx.ui.notify(
+        "Global switch or tool ownership updates apply after /reload.",
+        "warning",
+      );
+    }
+  };
+
+  if (initial.config.enabled) {
+    registerToolDisplayOverrides(pi, getEffectiveConfig);
+    registerNativeUserMessageBox(pi, getConfig);
+    registerThinkingLabeling(pi);
+  }
+
+  // Each Pi extension has its own registration map, while getCommands() sees
+  // the shared runtime. Check the latter so feature extensions do not expose
+  // duplicate /tool-display entries when they initialize this host separately.
+  if (!hasRegisteredToolDisplayCommand(pi)) {
+    pi.registerCommand("tool-display", {
+      description: "Configure tool output rendering (OpenCode-style)",
+      handler: async (args, ctx) => {
+        const { runToolDisplayCommandHandler } = await import("./config-modal.js");
+        await runToolDisplayCommandHandler(args, ctx, { getConfig, setConfig, getCapabilities });
+      },
+    });
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    refreshCapabilities();
+    if (pendingLoadError) {
+      ctx.ui.notify(pendingLoadError, "warning");
+      pendingLoadError = undefined;
+    }
+  });
 
-export function asComponent(value: unknown): Component | undefined {
-  return value && typeof value === "object" && typeof (value as Component).render === "function"
-    ? value as Component
-    : undefined;
+  pi.on("before_agent_start", async () => {
+    refreshCapabilities();
+  });
 }
 
-export function appendResultRenderPanel(baseValue: unknown, panel: Component): Component {
-  const base = asComponent(baseValue);
-  if (!base) return panel;
-  const container = new Container();
-  container.addChild(base);
-  container.addChild(panel);
-  return container;
+export default function toolDisplayExtension(
+  pi: ExtensionAPI,
+  initial: ConfigLoadResult = loadToolDisplayConfig(),
+): void {
+  ensureToolDisplayHost(pi, initial);
 }

package/src/line-width-safety.ts

@@ -0,0 +1,93 @@
+import { normalizeDiffRenderWidth } from "./diff-presentation.js";
+import { pluralize } 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, "Ctrl+O to expand"].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/modal-icons.ts

@@ -0,0 +1,57 @@
+export interface ModalIconSet {
+	search: string;
+}
+
+const NERD_MODAL_ICONS: ModalIconSet = {
+	search: "\uF002",
+};
+
+const EMOJI_MODAL_ICONS: ModalIconSet = {
+	search: "🔍",
+};
+
+const NERD_FONT_TERMINAL_HINTS = [
+	"iterm",
+	"wezterm",
+	"kitty",
+	"ghostty",
+	"alacritty",
+	"xfce4-terminal",
+	"gnome-terminal",
+	"tilix",
+	"terminator",
+	"konsole",
+] as const;
+
+function parseBooleanEnv(value: string | undefined): boolean | undefined {
+	if (value === "1" || value?.toLowerCase() === "true") {
+		return true;
+	}
+
+	if (value === "0" || value?.toLowerCase() === "false") {
+		return false;
+	}
+
+	return undefined;
+}
+
+function detectNerdFonts(): boolean {
+	const explicitPreference =
+		parseBooleanEnv(process.env.PI_NERD_FONTS) ?? parseBooleanEnv(process.env.POWERLINE_NERD_FONTS);
+	if (explicitPreference !== undefined) {
+		return explicitPreference;
+	}
+
+	if (process.env.GHOSTTY_RESOURCES_DIR) {
+		return true;
+	}
+
+	const termProgram = (process.env.TERM_PROGRAM || "").toLowerCase();
+	const term = (process.env.TERM || "").toLowerCase();
+	const fingerprint = `${termProgram} ${term}`;
+	return NERD_FONT_TERMINAL_HINTS.some((terminal) => fingerprint.includes(terminal));
+}
+
+export function getModalIcons(): ModalIconSet {
+	return detectNerdFonts() ? NERD_MODAL_ICONS : EMOJI_MODAL_ICONS;
+}