pi-one-ui 0.1.1

package/extensions/transcript/renderer/tool/diff/index.ts

@@ -0,0 +1,147 @@
+import {
+  createWriteToolDefinition,
+  type ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import {
+  renderEditDiffResult,
+  renderWriteDiffResult,
+  type DisplayConfigInput,
+} from "./diff-renderer.ts";
+import { DEFAULT_TOOL_DISPLAY_CONFIG } from "../../../../app/config/renderer.ts";
+import {
+  executeWriteWithMetadata,
+  WriteExecutionMetadataStore,
+} from "./write-execution.ts";
+
+function resultText(result: any): string {
+  const blocks = Array.isArray(result?.content) ? result.content : [];
+  return blocks
+    .filter(
+      (block: any) => block?.type === "text" && typeof block.text === "string",
+    )
+    .map((block: any) => block.text)
+    .join("\n");
+}
+
+function unavailableComponent(reason: string, theme: any) {
+  return {
+    render(width: number): string[] {
+      return [
+        truncateToWidth(
+          theme.fg("warning", `↳ diff unavailable: ${reason}`),
+          Math.max(0, width),
+          "",
+        ),
+      ];
+    },
+    invalidate() {},
+  };
+}
+
+export function renderRichToolResult(
+  toolName: string,
+  result: any,
+  options: any,
+  theme: any,
+  context: any,
+  writeMetadata: WriteExecutionMetadataStore,
+  /** Plain snapshot or live getter — getter lets /ccstyle panel changes repaint existing diffs. */
+  displayConfig: DisplayConfigInput = DEFAULT_TOOL_DISPLAY_CONFIG,
+): any | undefined {
+  if (options?.isPartial || options?.isError || context?.isError)
+    return undefined;
+  const expanded = options?.expanded === true || context?.expanded === true;
+  const filePath = context?.args?.file_path ?? context?.args?.path;
+  if (toolName === "edit") {
+    return renderEditDiffResult(
+      result?.details,
+      {
+        expanded,
+        filePath,
+        isHovered: options?.isHovered,
+        invalidate: () => context?.invalidate?.(),
+      },
+      displayConfig,
+      theme,
+      resultText(result),
+    );
+  }
+  if (toolName !== "write") return undefined;
+
+  const metadata = writeMetadata.get(context?.toolCallId);
+  if (!metadata) {
+    return unavailableComponent("execution metadata is unavailable", theme);
+  }
+  if (metadata.diffUnavailableReason) {
+    return unavailableComponent(metadata.diffUnavailableReason, theme);
+  }
+  return renderWriteDiffResult(
+    typeof context?.args?.content === "string"
+      ? context.args.content
+      : undefined,
+    {
+      expanded,
+      filePath,
+      previousContent: metadata.previousContent,
+      fileExistedBeforeWrite: metadata.fileExistedBeforeWrite,
+      isHovered: options?.isHovered,
+      invalidate: () => context?.invalidate?.(),
+    },
+    displayConfig,
+    theme,
+    resultText(result),
+  );
+}
+
+function hasExternalWriteOwner(pi: ExtensionAPI): boolean {
+  try {
+    const tools = pi.getAllTools();
+    const write = tools.find((tool: any) => tool?.name === "write") as any;
+    const source = write?.sourceInfo?.source;
+    return Boolean(write && typeof source === "string" && source !== "builtin");
+  } catch {
+    // getAllTools is unavailable before the extension runtime is bound.
+    return false;
+  }
+}
+
+export function installWriteOverride(
+  pi: ExtensionAPI,
+  store = new WriteExecutionMetadataStore(),
+): WriteExecutionMetadataStore {
+  if (
+    typeof (pi as any).registerTool !== "function" ||
+    hasExternalWriteOwner(pi)
+  )
+    return store;
+  const nativeWrite = createWriteToolDefinition(process.cwd()) as any;
+  pi.registerTool({
+    ...nativeWrite,
+    async execute(
+      toolCallId: string,
+      params: { path: string; content: string },
+      signal: AbortSignal | undefined,
+      _onUpdate: unknown,
+      ctx: { cwd: string },
+    ) {
+      return executeWriteWithMetadata(
+        store,
+        toolCallId,
+        params,
+        signal,
+        ctx.cwd,
+      );
+    },
+  });
+  return store;
+}
+
+export {
+  DEFAULT_TOOL_DISPLAY_CONFIG,
+  type ToolDisplayConfig,
+  type DiffViewMode,
+  type DiffIndicatorMode,
+} from "../../../../app/config/renderer.ts";
+export type { DisplayConfigInput } from "./diff-renderer.ts";
+export { WriteExecutionMetadataStore } from "./write-execution.ts";

package/extensions/transcript/renderer/tool/diff/line-width-safety.ts

@@ -0,0 +1,100 @@
+import { normalizeDiffRenderWidth } from "./diff-presentation.ts";
+import { pluralize } from "./diff-text.ts";
+import { showMoreHintText } from "../show-more-hint.ts";
+
+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/extensions/transcript/renderer/tool/diff/shiki-highlight.ts

@@ -0,0 +1,104 @@
+export const MAX_HL_CHARS = 32_000;
+const MAX_CACHE_ENTRIES = 48;
+
+type CodeToAnsi = (code: string, lang: any, theme: any) => Promise<string>;
+type Loader = () => Promise<CodeToAnsi>;
+type Subscriber = { fallback: readonly string[]; invalidate: () => void };
+type Pending = { work: Promise<void>; subscribers: Set<Subscriber> };
+
+let defaultLoad: Promise<CodeToAnsi> | undefined;
+const loadDefault: Loader = () => {
+  if (!defaultLoad) {
+    defaultLoad = import("@shikijs/cli")
+      .then((module) => module.codeToANSI as CodeToAnsi)
+      .catch((error) => {
+        defaultLoad = undefined;
+        throw error;
+      });
+  }
+  return defaultLoad;
+};
+
+function differs(
+  lines: readonly string[],
+  fallback: readonly string[],
+): boolean {
+  return (
+    lines.length !== fallback.length ||
+    lines.some((line, index) => line !== fallback[index])
+  );
+}
+
+export class ShikiHighlightCache {
+  private readonly cache = new Map<string, string[]>();
+  private readonly pending = new Map<string, Pending>();
+  private readonly loader: Loader;
+
+  constructor(loader: Loader = loadDefault) {
+    this.loader = loader;
+  }
+
+  get(
+    code: string,
+    lang: string | undefined,
+    theme: string,
+    fallback: readonly string[],
+    invalidate?: () => void,
+  ): string[] | undefined {
+    if (!lang || code.length > MAX_HL_CHARS) return undefined;
+    const key = `${theme}\0${lang}\0${code}`;
+    const cached = this.cache.get(key);
+    if (cached) {
+      this.cache.delete(key);
+      this.cache.set(key, cached);
+      return cached;
+    }
+
+    const existing = this.pending.get(key);
+    if (existing) {
+      if (
+        invalidate &&
+        ![...existing.subscribers].some(
+          (item) => item.invalidate === invalidate,
+        )
+      ) {
+        existing.subscribers.add({ fallback, invalidate });
+      }
+      return undefined;
+    }
+
+    const pending: Pending = {
+      work: undefined as never,
+      subscribers: new Set(),
+    };
+    if (invalidate) pending.subscribers.add({ fallback, invalidate });
+    pending.work = this.loader()
+      .then((highlight) => highlight(code, lang, theme))
+      .then((ansi) => {
+        const lines = ansi.replace(/\r/g, "").replace(/\n$/, "").split("\n");
+        this.cache.set(key, lines);
+        while (this.cache.size > MAX_CACHE_ENTRIES) {
+          const oldest = this.cache.keys().next().value;
+          if (oldest !== undefined) this.cache.delete(oldest);
+        }
+        for (const subscriber of pending.subscribers) {
+          if (!differs(lines, subscriber.fallback)) continue;
+          try {
+            subscriber.invalidate();
+          } catch {
+            // One component must not prevent the other subscribers from repainting.
+          }
+        }
+      })
+      .catch(() => {})
+      .finally(() => this.pending.delete(key));
+    this.pending.set(key, pending);
+    return undefined;
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+}
+
+export const shikiHighlightCache = new ShikiHighlightCache();

package/extensions/transcript/renderer/tool/diff/write-execution.ts

@@ -0,0 +1,124 @@
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { lstat, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+
+export const MAX_COMPARABLE_WRITE_BYTES = 512_000;
+export const MAX_WRITE_METADATA_ENTRIES = 100;
+
+export type WriteExecutionMeta = {
+  fileExistedBeforeWrite: boolean;
+  previousContent?: string;
+  diffUnavailableReason?: string;
+};
+
+export class WriteExecutionMetadataStore {
+  readonly entries = new Map<string, WriteExecutionMeta>();
+
+  set(toolCallId: string, metadata: WriteExecutionMeta): void {
+    this.entries.delete(toolCallId);
+    this.entries.set(toolCallId, metadata);
+    while (this.entries.size > MAX_WRITE_METADATA_ENTRIES) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest === undefined) break;
+      this.entries.delete(oldest);
+    }
+  }
+
+  get(toolCallId: unknown): WriteExecutionMeta | undefined {
+    return typeof toolCallId === "string"
+      ? this.entries.get(toolCallId)
+      : undefined;
+  }
+
+  delete(toolCallId: string): void {
+    this.entries.delete(toolCallId);
+  }
+
+  clear(): void {
+    this.entries.clear();
+  }
+}
+
+async function capturePreviousContent(
+  absolutePath: string,
+): Promise<WriteExecutionMeta> {
+  let info;
+  try {
+    info = await lstat(absolutePath);
+  } catch (error: any) {
+    if (error?.code === "ENOENT") return { fileExistedBeforeWrite: false };
+    return {
+      fileExistedBeforeWrite: true,
+      diffUnavailableReason: "unable to inspect the previous file",
+    };
+  }
+
+  if (!info.isFile()) {
+    return {
+      fileExistedBeforeWrite: true,
+      diffUnavailableReason: "previous path is not a regular file",
+    };
+  }
+  if (info.size > MAX_COMPARABLE_WRITE_BYTES) {
+    return {
+      fileExistedBeforeWrite: true,
+      diffUnavailableReason: `previous file exceeds ${MAX_COMPARABLE_WRITE_BYTES} bytes`,
+    };
+  }
+
+  try {
+    const bytes = await readFile(absolutePath);
+    const previousContent = new TextDecoder("utf-8", { fatal: true }).decode(
+      bytes,
+    );
+    return { fileExistedBeforeWrite: true, previousContent };
+  } catch {
+    return {
+      fileExistedBeforeWrite: true,
+      diffUnavailableReason: "previous file is not comparable UTF-8 text",
+    };
+  }
+}
+
+export async function executeWriteWithMetadata(
+  store: WriteExecutionMetadataStore,
+  toolCallId: string,
+  params: { path: string; content: string },
+  signal: AbortSignal | undefined,
+  cwd: string,
+): Promise<{
+  content: Array<{ type: "text"; text: string }>;
+  details: undefined;
+}> {
+  const absolutePath = isAbsolute(params.path)
+    ? params.path
+    : resolve(cwd, params.path);
+  store.delete(toolCallId);
+  try {
+    return await withFileMutationQueue(absolutePath, async () => {
+      const throwIfAborted = () => {
+        if (signal?.aborted) throw new Error("Operation aborted");
+      };
+      throwIfAborted();
+      const metadata = await capturePreviousContent(absolutePath);
+      throwIfAborted();
+      await mkdir(dirname(absolutePath), { recursive: true });
+      throwIfAborted();
+      await writeFile(absolutePath, params.content, "utf8");
+      throwIfAborted();
+      store.set(toolCallId, metadata);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Successfully wrote ${params.content.length} bytes to ${params.path}`,
+          },
+        ],
+        details: undefined,
+      };
+    });
+  } catch (error) {
+    store.delete(toolCallId);
+    throw error;
+  }
+}