pi-extensions-tool-display 0.1.1 → 0.2.0

package/src/types.ts

@@ -0,0 +1,105 @@
+export const READ_OUTPUT_MODES = ["hidden", "summary", "preview"] as const;
+export const SEARCH_OUTPUT_MODES = ["hidden", "count", "preview"] as const;
+export const MCP_OUTPUT_MODES = ["hidden", "summary", "preview"] as const;
+export const CUSTOM_TOOL_OVERRIDE_KINDS = ["generic", "mcp"] as const;
+export const CUSTOM_TOOL_OUTPUT_MODES = ["hidden", "summary", "preview"] as const;
+export const BASH_OUTPUT_MODES = ["opencode", "summary", "preview"] as const;
+export const DIFF_VIEW_MODES = ["auto", "split", "unified"] as const;
+export const DIFF_INDICATOR_MODES = ["bars", "classic", "none"] as const;
+
+export type ReadOutputMode = (typeof READ_OUTPUT_MODES)[number];
+export type SearchOutputMode = (typeof SEARCH_OUTPUT_MODES)[number];
+export type McpOutputMode = (typeof MCP_OUTPUT_MODES)[number];
+export type CustomToolOverrideKind = (typeof CUSTOM_TOOL_OVERRIDE_KINDS)[number];
+export type CustomToolOutputMode = (typeof CUSTOM_TOOL_OUTPUT_MODES)[number];
+export type BashOutputMode = (typeof BASH_OUTPUT_MODES)[number];
+export type DiffViewMode = (typeof DIFF_VIEW_MODES)[number];
+export type DiffIndicatorMode = (typeof DIFF_INDICATOR_MODES)[number];
+
+export const BUILT_IN_TOOL_OVERRIDE_NAMES = [
+	"read",
+	"grep",
+	"find",
+	"ls",
+	"bash",
+	"edit",
+	"write",
+] as const;
+
+export type BuiltInToolOverrideName = (typeof BUILT_IN_TOOL_OVERRIDE_NAMES)[number];
+
+export interface ToolOverrideOwnership {
+	read: boolean;
+	grep: boolean;
+	find: boolean;
+	ls: boolean;
+	bash: boolean;
+	edit: boolean;
+	write: boolean;
+}
+
+export interface CustomToolOverrideConfig {
+	enabled: boolean;
+	kind: CustomToolOverrideKind;
+	outputMode: CustomToolOutputMode;
+}
+
+export interface ToolDisplayConfig {
+	enabled: boolean;
+	registerToolOverrides: ToolOverrideOwnership;
+	customToolOverrides: Record<string, CustomToolOverrideConfig>;
+	enableNativeUserMessageBox: boolean;
+	readOutputMode: ReadOutputMode;
+	searchOutputMode: SearchOutputMode;
+	mcpOutputMode: McpOutputMode;
+	previewLines: number;
+	expandedPreviewMaxLines: number;
+	bashOutputMode: BashOutputMode;
+	bashCollapsedLines: number;
+	diffViewMode: DiffViewMode;
+	diffIndicatorMode: DiffIndicatorMode;
+	diffSplitMinWidth: number;
+	diffCollapsedLines: number;
+	diffWordWrap: boolean;
+	showTruncationHints: boolean;
+	showRtkCompactionHints: boolean;
+}
+
+export const DEFAULT_TOOL_DISPLAY_CONFIG: ToolDisplayConfig = {
+	enabled: true,
+	registerToolOverrides: {
+		read: true,
+		grep: true,
+		find: true,
+		ls: true,
+		bash: true,
+		edit: true,
+		write: true,
+	},
+	customToolOverrides: {},
+	enableNativeUserMessageBox: true,
+	readOutputMode: "hidden",
+	searchOutputMode: "hidden",
+	mcpOutputMode: "hidden",
+	previewLines: 8,
+	expandedPreviewMaxLines: 4000,
+	bashOutputMode: "opencode",
+	bashCollapsedLines: 10,
+	diffViewMode: "auto",
+	diffIndicatorMode: "bars",
+	diffSplitMinWidth: 120,
+	diffCollapsedLines: 24,
+	diffWordWrap: true,
+	showTruncationHints: false,
+	showRtkCompactionHints: false,
+};
+
+export interface ConfigLoadResult {
+	config: ToolDisplayConfig;
+	error?: string;
+}
+
+export interface ConfigSaveResult {
+	success: boolean;
+	error?: string;
+}

package/src/user-message-box-markdown.ts

@@ -0,0 +1,64 @@
+import { isRecord } from "./tool-metadata.js";
+
+interface MarkdownLike {
+  text?: unknown;
+  theme?: unknown;
+  defaultTextStyle?: unknown;
+}
+
+interface UserMessageLike {
+  children?: unknown;
+}
+
+export interface UserMessageMarkdownState {
+  text: string;
+  theme: unknown;
+  defaultTextStyle?: Record<string, unknown>;
+}
+
+function sanitizeDefaultTextStyle(value: unknown): Record<string, unknown> | undefined {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const { bgColor: _bgColor, ...rest } = value;
+  return Object.keys(rest).length > 0 ? rest : undefined;
+}
+
+function isMarkdownLike(value: unknown): value is MarkdownLike {
+  return isRecord(value) && typeof value.text === "string" && value.theme !== undefined;
+}
+
+function findMarkdownChild(value: unknown): MarkdownLike | undefined {
+  if (isMarkdownLike(value)) {
+    return value;
+  }
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const children = Array.isArray(value.children) ? value.children : [];
+  for (const child of children) {
+    const markdownChild = findMarkdownChild(child);
+    if (markdownChild) {
+      return markdownChild;
+    }
+  }
+
+  return undefined;
+}
+
+export function extractUserMessageMarkdownState(
+  userMessage: UserMessageLike,
+): UserMessageMarkdownState | undefined {
+  const markdownChild = findMarkdownChild(userMessage);
+  if (!markdownChild || typeof markdownChild.text !== "string") {
+    return undefined;
+  }
+
+  return {
+    text: markdownChild.text,
+    theme: markdownChild.theme,
+    defaultTextStyle: sanitizeDefaultTextStyle(markdownChild.defaultTextStyle),
+  };
+}

package/src/user-message-box-native.ts

@@ -0,0 +1,66 @@
+import {
+  type ExtensionAPI,
+  UserMessageComponent,
+} from "@earendil-works/pi-coding-agent";
+import {
+  patchNativeUserMessagePrototype,
+  type PatchableUserMessagePrototype,
+  type UserMessageTheme,
+} from "./user-message-box-renderer.js";
+import { unregisterUserMessageRenderPrototypePatch } from "./user-message-box-patch.js";
+import type { ToolDisplayConfig } from "./types.js";
+import { onReloadShutdown } from "./extension-lifecycle.js";
+
+const registeredNativeUserMessageApis = new WeakSet<ExtensionAPI>();
+
+function getUserMessagePrototype(): PatchableUserMessagePrototype {
+  return UserMessageComponent.prototype as unknown as PatchableUserMessagePrototype;
+}
+
+function patchUserMessageRender(
+  getTheme: () => UserMessageTheme | undefined,
+  isEnabled: () => boolean,
+): void {
+  patchNativeUserMessagePrototype(
+    getUserMessagePrototype(),
+    getTheme,
+    isEnabled,
+  );
+}
+
+function restoreUserMessageRender(): void {
+  unregisterUserMessageRenderPrototypePatch(getUserMessagePrototype());
+}
+
+export default function registerNativeUserMessageBox(
+  pi: ExtensionAPI,
+  getConfig: () => ToolDisplayConfig,
+): void {
+  if (registeredNativeUserMessageApis.has(pi)) {
+    return;
+  }
+  registeredNativeUserMessageApis.add(pi);
+
+  let activeTheme: UserMessageTheme | undefined;
+
+  const getTheme = (): UserMessageTheme | undefined => activeTheme;
+  const isEnabled = (): boolean => getConfig().enableNativeUserMessageBox;
+
+  patchUserMessageRender(getTheme, isEnabled);
+
+  onReloadShutdown(pi, () => {
+    restoreUserMessageRender();
+    activeTheme = undefined;
+    registeredNativeUserMessageApis.delete(pi);
+  });
+
+  pi.on("before_agent_start", async () => {
+    patchUserMessageRender(getTheme, isEnabled);
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    activeTheme = ctx?.ui?.theme as unknown as UserMessageTheme;
+    patchUserMessageRender(getTheme, isEnabled);
+  });
+
+}

package/src/user-message-box-patch.ts

@@ -0,0 +1,72 @@
+export type UserMessageRenderFn = (width: number) => string[];
+
+const USER_MESSAGE_PATCH_OWNER = {};
+
+export interface PatchableUserMessagePrototype {
+  render: UserMessageRenderFn;
+  __piUserMessageOriginalRender?: UserMessageRenderFn;
+  __piUserMessageNativePatched?: boolean;
+  __piUserMessagePatchVersion?: number;
+  __piUserMessagePatchOwner?: object;
+}
+
+export function unregisterUserMessageRenderPrototypePatch(
+  prototype: PatchableUserMessagePrototype,
+): void {
+  const originalRender = prototype.__piUserMessageOriginalRender;
+  if (typeof originalRender === "function") {
+    prototype.render = originalRender;
+  }
+
+  delete prototype.__piUserMessageOriginalRender;
+  delete prototype.__piUserMessageNativePatched;
+  delete prototype.__piUserMessagePatchVersion;
+  delete prototype.__piUserMessagePatchOwner;
+}
+
+export function patchUserMessageRenderPrototype(
+  prototype: PatchableUserMessagePrototype,
+  patchVersion: number,
+  buildRender: (originalRender: UserMessageRenderFn) => UserMessageRenderFn,
+): void {
+  if (typeof prototype.render !== "function") {
+    return;
+  }
+
+  const previousOriginalRender = prototype.__piUserMessageOriginalRender;
+  const hasPreviousPatch = typeof previousOriginalRender === "function"
+    && previousOriginalRender !== prototype.render;
+  const isCurrentPatch = prototype.__piUserMessagePatchOwner === USER_MESSAGE_PATCH_OWNER;
+  let restoredStalePatch = false;
+
+  if (hasPreviousPatch && !isCurrentPatch) {
+    prototype.render = previousOriginalRender;
+    delete prototype.__piUserMessageNativePatched;
+    delete prototype.__piUserMessagePatchVersion;
+    delete prototype.__piUserMessagePatchOwner;
+    restoredStalePatch = true;
+  }
+
+  if (
+    !restoredStalePatch
+    && prototype.__piUserMessageNativePatched
+    && prototype.__piUserMessagePatchVersion === patchVersion
+    && typeof prototype.__piUserMessageOriginalRender === "function"
+  ) {
+    return;
+  }
+
+  if (!prototype.__piUserMessageOriginalRender) {
+    prototype.__piUserMessageOriginalRender = prototype.render;
+  }
+
+  const originalRender = prototype.__piUserMessageOriginalRender;
+  if (!originalRender) {
+    return;
+  }
+
+  prototype.render = buildRender(originalRender);
+  prototype.__piUserMessageNativePatched = true;
+  prototype.__piUserMessagePatchVersion = patchVersion;
+  prototype.__piUserMessagePatchOwner = USER_MESSAGE_PATCH_OWNER;
+}