pi-one-ui 0.1.1

package/extensions/shell/user-message.ts

@@ -0,0 +1,226 @@
+import {
+  type Theme,
+  UserMessageComponent,
+} from "@earendil-works/pi-coding-agent";
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import type { ZentuiConfig } from "../app/config/shell.ts";
+import {
+  installPrototypePatch,
+  removePrototypePatch,
+} from "./prototype-patch-registry.ts";
+import {
+  sanitizeRenderedUserMessageLines,
+  sanitizeRenderedUserMessageText,
+  sanitizeUserMessageSourceText,
+} from "./user-message-osc.ts";
+import {
+  renderUserMessageStyle,
+  userMessageStyleCacheKey,
+} from "./user-message-styles.ts";
+
+const OSC133_ZONE_START = "\x1b]133;A\x07";
+const OSC133_ZONE_END = "\x1b]133;B\x07";
+const OSC133_ZONE_FINAL = "\x1b]133;C\x07";
+
+type PatchableUserMessagePrototype = {
+  children?: unknown[];
+};
+
+type Cleanup = () => void;
+
+type UserMessageRenderCache = {
+  hasMarkdownText: boolean;
+  text?: string;
+  width?: number;
+  theme?: Theme;
+  configKey?: string;
+  renderedLines?: string[];
+};
+
+const userMessageRenderCache = new WeakMap<object, UserMessageRenderCache>();
+
+function isObject(value: unknown): value is object {
+  return (
+    (typeof value === "object" && value !== null) || typeof value === "function"
+  );
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function findMarkdownText(value: unknown): string | undefined {
+  if (!isRecord(value)) return undefined;
+  if (typeof value.text === "string") return value.text;
+
+  const children = value.children;
+  if (!Array.isArray(children)) return undefined;
+
+  for (const child of children) {
+    const text = findMarkdownText(child);
+    if (text !== undefined) return text;
+  }
+
+  return undefined;
+}
+
+function getCachedMarkdownText(instance: object): string | undefined {
+  const cached = userMessageRenderCache.get(instance);
+  if (cached?.hasMarkdownText) return cached.text;
+
+  const text = findMarkdownText(instance);
+  if (text !== undefined) {
+    userMessageRenderCache.set(instance, {
+      ...cached,
+      hasMarkdownText: true,
+      text,
+    });
+  }
+  return text;
+}
+
+function renderZentuiUserMessage(
+  instance: PatchableUserMessagePrototype,
+  width: number,
+  theme: Theme | undefined,
+  config: ZentuiConfig,
+): string[] | undefined {
+  if (!isRecord(instance)) return undefined;
+
+  const text = getCachedMarkdownText(instance);
+  if (text === undefined) return undefined;
+  const configKey = userMessageStyleCacheKey(config);
+  const cached = userMessageRenderCache.get(instance);
+  if (
+    cached?.hasMarkdownText &&
+    cached.width === width &&
+    cached.theme === theme &&
+    cached.configKey === configKey &&
+    cached.renderedLines
+  ) {
+    return cached.renderedLines;
+  }
+
+  const lines = renderUserMessageStyle({
+    text,
+    width,
+    theme,
+    config,
+  });
+  userMessageRenderCache.set(instance, {
+    hasMarkdownText: true,
+    text,
+    width,
+    theme,
+    configKey,
+    renderedLines: lines,
+  });
+  return lines;
+}
+
+function withPromptZoneMarkers(lines: string[]): string[] {
+  if (lines.length === 1) {
+    return [
+      `${OSC133_ZONE_START}${lines[0]}${OSC133_ZONE_END}${OSC133_ZONE_FINAL}`,
+    ];
+  }
+  const markedLines = [...lines];
+  markedLines[0] = OSC133_ZONE_START + markedLines[0];
+  markedLines[markedLines.length - 1] =
+    OSC133_ZONE_END + OSC133_ZONE_FINAL + markedLines[markedLines.length - 1];
+  return markedLines;
+}
+
+function sanitizePredecessorRender(result: unknown): unknown {
+  if (typeof result === "string")
+    return sanitizeRenderedUserMessageText(result);
+  if (!Array.isArray(result)) return result;
+  const stringRows = result.every(
+    (line): line is string => typeof line === "string",
+  );
+  if (stringRows) return sanitizeRenderedUserMessageLines(result);
+  return result.map((line) =>
+    typeof line === "string" ? sanitizeRenderedUserMessageText(line) : line,
+  );
+}
+
+function renderSafeSourceFallback(
+  instance: PatchableUserMessagePrototype,
+  width: number,
+): string[] | undefined {
+  let text: string | undefined;
+  try {
+    text = isRecord(instance) ? getCachedMarkdownText(instance) : undefined;
+  } catch {
+    return undefined;
+  }
+  if (text === undefined) return undefined;
+  const stripped = sanitizeUserMessageSourceText(text);
+  if (stripped === text) return undefined;
+  const lines = (width > 0 ? wrapTextWithAnsi(stripped, width) : [""]).map(
+    sanitizeRenderedUserMessageText,
+  );
+  return withPromptZoneMarkers(lines.length > 0 ? lines : [""]);
+}
+
+export function removeUserMessageStyle(): void {
+  const prototype = UserMessageComponent.prototype;
+  removePrototypePatch(prototype, "render", "user-message-render");
+  removePrototypePatch(prototype, "invalidate", "user-message-invalidate");
+}
+
+export function installUserMessageStyle(
+  getTheme: () => Theme | undefined,
+  getConfig: () => ZentuiConfig,
+): Cleanup {
+  const prototype = UserMessageComponent.prototype;
+  const cleanupInvalidate = installPrototypePatch(
+    prototype,
+    "invalidate",
+    "user-message-invalidate",
+    ({ predecessor, receiver, args }) => {
+      if (isObject(receiver)) userMessageRenderCache.delete(receiver);
+      return Reflect.apply(predecessor, receiver, args);
+    },
+  );
+  let cleanupRender: Cleanup;
+  try {
+    cleanupRender = installPrototypePatch(
+      prototype,
+      "render",
+      "user-message-render",
+      ({ predecessor, receiver, args }) => {
+        const renderPredecessor = () =>
+          sanitizePredecessorRender(Reflect.apply(predecessor, receiver, args));
+        const width = args[0];
+        if (typeof width !== "number") return renderPredecessor();
+        try {
+          const lines = renderZentuiUserMessage(
+            receiver as PatchableUserMessagePrototype,
+            width,
+            getTheme(),
+            getConfig(),
+          );
+          if (!lines) return renderPredecessor();
+          return lines.length ? withPromptZoneMarkers(lines) : lines;
+        } catch {
+          const safeFallback = renderSafeSourceFallback(
+            receiver as PatchableUserMessagePrototype,
+            width,
+          );
+          return safeFallback ?? renderPredecessor();
+        }
+      },
+    );
+  } catch (error) {
+    cleanupInvalidate();
+    throw error;
+  }
+  let cleaned = false;
+  return () => {
+    if (cleaned) return;
+    cleaned = true;
+    cleanupRender();
+    cleanupInvalidate();
+  };
+}

package/extensions/shell/working-line-messages.ts

@@ -0,0 +1,24 @@
+/** The built-in Working-line verb catalog, in display order. */
+export const PI_WORKING_LINE_DEFAULT_PHRASES = [
+  "Sautéing",
+  "Cooking",
+  "Ionizing",
+  "Zigzagging",
+  "Razzle-dazzling",
+  "Photosynthesizing",
+  "Nucleating",
+  "Brewing",
+  "Combobulating",
+  "Boogieing",
+  "Befuddling",
+  "Alchemizing",
+  "Conjuring",
+  "Baking",
+  "Simmering",
+  "Blanching",
+] as const;
+
+/** Complete visible messages derived consistently from the built-in verb catalog. */
+export const PI_WORKING_LINE_MESSAGES = PI_WORKING_LINE_DEFAULT_PHRASES.map(
+  (phrase) => `${phrase}…`,
+);

package/extensions/shell/working-line-spinners.ts

@@ -0,0 +1,54 @@
+import type { WorkingLineSpinner } from "../app/config/shell.ts";
+
+/*
+ * Pulse frames adapted from Funky UI's animations.ts:
+ * https://github.com/pi-zza/funky-ui/blob/e9aed319a4de61c2b2a5e99009821efa7b67b178/packages/funky-ui/extensions/funky-ui/animations.ts
+ * Frozen imported source revision:
+ * https://github.com/lmilojevicc/pi-zza/blob/37d82d565c1f5a9aa9b31d4b1711fa5604eb04a1/packages/funky-ui/extensions/funky-ui/animations.ts
+ *
+ * Funky UI's NOTICE states that the package combines Marko Nakic's Funky UI
+ * source with code derived from FammasMaz/pi-cc-tools, published as
+ * pi-claude-style-tools.
+ *
+ * MIT License
+ *
+ * Copyright (c) FammasMaz/pi-cc-tools contributors
+ * Copyright (c) 2026 Marko Nakic
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/** Spinner definitions contain frames only; spinnerIntervalMs remains user-controlled. */
+export const WORKING_LINE_SPINNERS = {
+  braille: {
+    frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  },
+  "star-bloom": {
+    frames: ["·", "✦", "✧", "✶", "✧", "✦"],
+  },
+  pinwheel: {
+    frames: ["-", "\\", "|", "/"],
+  },
+  "claude-inspired": {
+    frames: ["·", "✢", "✳", "✶", "✻", "✽"],
+  },
+  pulse: {
+    frames: ["⠀⠶⠀", "⠰⣿⠆", "⢾⣉⡷", "⣏⠀⣹", "⡁⠀⢈"],
+  },
+} as const satisfies Record<WorkingLineSpinner, { frames: readonly string[] }>;