pi-one-ui 0.1.1

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

@@ -0,0 +1,629 @@
+import {
+  Text,
+  truncateToWidth,
+  visibleWidth,
+  type Component,
+} from "@earendil-works/pi-tui";
+import { sanitizeToolResultText } from "../../../../tools/tool-result-sanitize.ts";
+import { showMoreHintText } from "../show-more-hint.ts";
+import { splitWriteContentLines } from "./diff-text.ts";
+import {
+  collectDiffStats,
+  getLineNumberWidth,
+  type DiffLineEntry,
+  type DiffStats,
+  type ParsedDiffEntry,
+} from "./diff-parse.ts";
+import {
+  buildInlineHighlightMap,
+  buildSplitRows,
+  type DiffSpan,
+  type SplitDiffRow,
+} from "./diff-inline.ts";
+import { resolveDiffPalette, type DiffTheme } from "./diff-palette.ts";
+import {
+  createCodeLineHighlighter,
+  resolveLanguageFromPath,
+  type CodeLineHighlighter,
+} from "./diff-highlight.ts";
+import {
+  canRenderSplitLayout,
+  renderCompact,
+  renderSplit,
+  renderUnified,
+  type DiffRenderContext,
+  type RenderedRow,
+} from "./diff-layout.ts";
+import {
+  renderDiffFrameLine,
+  renderSingleDiffRow,
+  renderWriteHeader,
+} from "./diff-header.ts";
+import {
+  applyLineLimit,
+  clampDiffLineToWidth,
+  clampDiffLinesToWidth,
+  resolveDiffDisplayLimit,
+  resolveDiffProcessBudget,
+  resolveWriteCollapsedLimit,
+  takeEntriesForLineBudget,
+  takeSplitRowsForBudget,
+} from "./diff-limits.ts";
+import {
+  RICH_DIFF_COMPONENT,
+  createDiffRenderCache,
+  displayConfigCacheKey,
+  resolveDiffIndicatorMode,
+  resolveLiveDisplayConfig,
+  type DiffRenderOptions,
+  type DisplayConfigInput,
+} from "./diff-component.ts";
+import {
+  buildDiffSummaryText,
+  normalizeDiffRenderWidth,
+  resolveDiffPresentationMode,
+  type DiffPresentationMode,
+} from "./diff-presentation.ts";
+
+type WriteDiffOperationKind = "context" | "remove" | "add";
+
+interface WriteDiffOperation {
+  kind: WriteDiffOperationKind;
+  content: string;
+}
+
+function buildWriteDiffOperations(
+  oldLines: string[],
+  newLines: string[],
+): WriteDiffOperation[] {
+  const oldLength = oldLines.length;
+  const newLength = newLines.length;
+  const table: number[][] = Array.from({ length: oldLength + 1 }, () =>
+    Array<number>(newLength + 1).fill(0),
+  );
+
+  for (let oldIndex = 1; oldIndex <= oldLength; oldIndex++) {
+    for (let newIndex = 1; newIndex <= newLength; newIndex++) {
+      if ((oldLines[oldIndex - 1] ?? "") === (newLines[newIndex - 1] ?? "")) {
+        table[oldIndex]![newIndex] =
+          (table[oldIndex - 1]?.[newIndex - 1] ?? 0) + 1;
+        continue;
+      }
+      const top = table[oldIndex - 1]?.[newIndex] ?? 0;
+      const left = table[oldIndex]?.[newIndex - 1] ?? 0;
+      table[oldIndex]![newIndex] = Math.max(top, left);
+    }
+  }
+
+  const operations: WriteDiffOperation[] = [];
+  let oldCursor = oldLength;
+  let newCursor = newLength;
+
+  while (oldCursor > 0 || newCursor > 0) {
+    const oldLine = oldCursor > 0 ? (oldLines[oldCursor - 1] ?? "") : undefined;
+    const newLine = newCursor > 0 ? (newLines[newCursor - 1] ?? "") : undefined;
+
+    if (oldCursor > 0 && newCursor > 0 && oldLine === newLine) {
+      operations.push({ kind: "context", content: oldLine ?? "" });
+      oldCursor--;
+      newCursor--;
+      continue;
+    }
+
+    const top = oldCursor > 0 ? (table[oldCursor - 1]?.[newCursor] ?? 0) : -1;
+    const left = newCursor > 0 ? (table[oldCursor]?.[newCursor - 1] ?? 0) : -1;
+
+    if (newCursor > 0 && left >= top) {
+      operations.push({ kind: "add", content: newLine ?? "" });
+      newCursor--;
+      continue;
+    }
+
+    if (oldCursor > 0) {
+      operations.push({ kind: "remove", content: oldLine ?? "" });
+      oldCursor--;
+    }
+  }
+
+  operations.reverse();
+  return operations;
+}
+
+function buildWriteEntries(lines: string[]): ParsedDiffEntry[] {
+  return lines.map((line, index) => ({
+    kind: "line",
+    lineKind: "add",
+    oldLineNumber: null,
+    newLineNumber: index + 1,
+    fallbackLineNumber: `${index + 1}`,
+    content: line,
+    raw: `+${line}`,
+    hunkIndex: 1,
+  }));
+}
+
+function buildWriteOverwriteEntries(
+  oldLines: string[],
+  newLines: string[],
+): ParsedDiffEntry[] {
+  const operations = buildWriteDiffOperations(oldLines, newLines);
+  const entries: ParsedDiffEntry[] = [];
+  let oldLineNumber = 1;
+  let newLineNumber = 1;
+
+  for (const operation of operations) {
+    if (operation.kind === "context") {
+      entries.push({
+        kind: "line",
+        lineKind: "context",
+        oldLineNumber,
+        newLineNumber,
+        fallbackLineNumber: `${newLineNumber}`,
+        content: operation.content,
+        raw: ` ${operation.content}`,
+        hunkIndex: 1,
+      });
+      oldLineNumber++;
+      newLineNumber++;
+      continue;
+    }
+
+    if (operation.kind === "remove") {
+      entries.push({
+        kind: "line",
+        lineKind: "remove",
+        oldLineNumber,
+        newLineNumber: null,
+        fallbackLineNumber: `${oldLineNumber}`,
+        content: operation.content,
+        raw: `-${operation.content}`,
+        hunkIndex: 1,
+      });
+      oldLineNumber++;
+      continue;
+    }
+
+    entries.push({
+      kind: "line",
+      lineKind: "add",
+      oldLineNumber: null,
+      newLineNumber,
+      fallbackLineNumber: `${newLineNumber}`,
+      content: operation.content,
+      raw: `+${operation.content}`,
+      hunkIndex: 1,
+    });
+    newLineNumber++;
+  }
+
+  return entries;
+}
+
+interface WriteDiffData {
+  entries: ParsedDiffEntry[];
+  splitRows: SplitDiffRow[];
+  inlineHighlights: WeakMap<DiffLineEntry, DiffSpan[]>;
+  lineNumberWidth: number;
+  stats: DiffStats;
+  hunkCount: number;
+}
+
+interface WriteOverwriteGuard {
+  previousLineCount: number;
+  nextLineCount: number;
+}
+
+const MAX_WRITE_OVERWRITE_DIFF_LINES = 4000;
+const MAX_WRITE_OVERWRITE_DIFF_MATRIX_CELLS = 1_000_000;
+/** Collapsed overwrite previews refuse larger LCS matrices to avoid TUI freezes. */
+const MAX_COLLAPSED_WRITE_OVERWRITE_DIFF_MATRIX_CELLS = 200_000;
+
+function buildApproximateWriteStats(
+  lineCount: number,
+  previousLineCount: number,
+  hasComparablePrevious: boolean,
+): DiffStats {
+  const removed = hasComparablePrevious ? previousLineCount : 0;
+  const added = lineCount;
+  const hasContent = lineCount > 0 || removed > 0;
+  return {
+    added,
+    removed,
+    context: 0,
+    hunks: hasContent ? 1 : 0,
+    files: 1,
+    lines: added + removed,
+  };
+}
+
+function buildWriteDiffData(entries: ParsedDiffEntry[]): WriteDiffData {
+  const splitRows = buildSplitRows(entries);
+  const inlineHighlights = buildInlineHighlightMap(splitRows);
+  const lineNumberWidth = getLineNumberWidth(entries);
+  const hunkCount = entries.length > 0 ? 1 : 0;
+  const stats = collectDiffStats(entries, hunkCount, 1);
+  return {
+    entries,
+    splitRows,
+    inlineHighlights,
+    lineNumberWidth,
+    stats,
+    hunkCount,
+  };
+}
+
+function resolveWriteOverwriteGuard(
+  previousLines: string[],
+  nextLines: string[],
+  expanded = true,
+): WriteOverwriteGuard | undefined {
+  const previousLineCount = previousLines.length;
+  const nextLineCount = nextLines.length;
+  if (
+    previousLineCount > MAX_WRITE_OVERWRITE_DIFF_LINES ||
+    nextLineCount > MAX_WRITE_OVERWRITE_DIFF_LINES
+  ) {
+    return { previousLineCount, nextLineCount };
+  }
+  if (previousLineCount === 0 || nextLineCount === 0) {
+    return undefined;
+  }
+  const cellLimit = expanded
+    ? MAX_WRITE_OVERWRITE_DIFF_MATRIX_CELLS
+    : MAX_COLLAPSED_WRITE_OVERWRITE_DIFF_MATRIX_CELLS;
+  return previousLineCount * nextLineCount > cellLimit
+    ? { previousLineCount, nextLineCount }
+    : undefined;
+}
+
+function buildWriteOverwriteGuardText(
+  guard: WriteOverwriteGuard,
+  width: number,
+): string {
+  const safeWidth = normalizeDiffRenderWidth(width);
+  if (safeWidth === 0) {
+    return "";
+  }
+
+  const candidates = [
+    `↳ overwrite diff omitted (${guard.previousLineCount} → ${guard.nextLineCount} lines)`,
+    `↳ overwrite diff omitted (${guard.previousLineCount}→${guard.nextLineCount})`,
+    "↳ overwrite diff omitted",
+    "diff omitted",
+    "…",
+  ];
+  for (const candidate of candidates) {
+    if (visibleWidth(candidate) <= safeWidth) {
+      return candidate;
+    }
+  }
+  return truncateToWidth(
+    candidates[candidates.length - 1] ?? "",
+    safeWidth,
+    "",
+  );
+}
+
+function renderWriteOverwriteGuardRows(
+  guard: WriteOverwriteGuard,
+  width: number,
+  theme: DiffTheme,
+): string[] {
+  return renderSingleDiffRow(
+    buildWriteOverwriteGuardText(guard, width),
+    "warning",
+    width,
+    theme,
+  );
+}
+
+/** Folded write with `writeDiffCollapsedLines: 0`: `↳ created • click to show more`. */
+function renderWriteCollapsedHintLine(
+  wasOverwrite: boolean,
+  width: number,
+  theme: DiffTheme,
+  hovered: boolean,
+  headerLabel?: string,
+): string[] {
+  const safeWidth = normalizeDiffRenderWidth(width);
+  if (safeWidth === 0) {
+    return [""];
+  }
+  const actionLabel =
+    headerLabel?.trim() || (wasOverwrite ? "overwritten" : "created");
+  const clickLabel = showMoreHintText();
+  const candidates = [
+    `↳ ${actionLabel} • ${clickLabel}`,
+    `↳ ${actionLabel}`,
+    actionLabel,
+    "…",
+  ];
+  let text = candidates[candidates.length - 1] ?? "…";
+  for (const candidate of candidates) {
+    if (visibleWidth(candidate) <= safeWidth) {
+      text = candidate;
+      break;
+    }
+  }
+  if (visibleWidth(text) > safeWidth) {
+    text = truncateToWidth(text, safeWidth, "");
+  }
+  const clickIndex = text.lastIndexOf(clickLabel);
+  const styled =
+    hovered && clickIndex >= 0
+      ? theme.fg("muted", text.slice(0, clickIndex)) +
+        theme.fg("text", clickLabel) +
+        theme.fg("muted", text.slice(clickIndex + clickLabel.length))
+      : theme.fg("muted", text);
+  return [clampDiffLineToWidth(styled, safeWidth)];
+}
+
+/**
+ * write 变更行统计（compact 单行用）：复用当前 write diff 算法。
+ * 新文件 = 全部新内容为 added；覆盖已有文件用 LCS 精确统计。
+ * content 非字符串、元数据缺失或超过矩阵预算时返回 undefined（不显示计数）。
+ */
+export function countWriteDiffStats(
+  content: string | undefined,
+  previousContent: string | undefined,
+  fileExistedBeforeWrite: boolean | undefined,
+): { added: number; removed: number } | undefined {
+  if (typeof content !== "string" || fileExistedBeforeWrite === undefined)
+    return undefined;
+  const lines = splitWriteContentLines(sanitizeToolResultText(content));
+  if (fileExistedBeforeWrite === false)
+    return { added: lines.length, removed: 0 };
+  if (typeof previousContent !== "string") return undefined;
+  const previousLines = splitWriteContentLines(
+    sanitizeToolResultText(previousContent),
+  );
+  if (previousLines.length === 0 || lines.length === 0) {
+    return { added: lines.length, removed: previousLines.length };
+  }
+  if (
+    previousLines.length * lines.length >
+    MAX_COLLAPSED_WRITE_OVERWRITE_DIFF_MATRIX_CELLS
+  ) {
+    return undefined;
+  }
+  let added = 0;
+  let removed = 0;
+  for (const operation of buildWriteDiffOperations(previousLines, lines)) {
+    if (operation.kind === "add") added++;
+    else if (operation.kind === "remove") removed++;
+  }
+  return { added, removed };
+}
+
+export function renderWriteDiffResult(
+  content: string | undefined,
+  options: DiffRenderOptions,
+  config: DisplayConfigInput,
+  theme: DiffTheme,
+  fallbackText: string,
+): Component {
+  const safeFallbackText = sanitizeToolResultText(fallbackText);
+  if (typeof content !== "string") {
+    if (!safeFallbackText.trim()) {
+      return new Text(theme.fg("muted", "↳ write completed"), 0, 0);
+    }
+    return new Text(theme.fg("toolOutput", safeFallbackText), 0, 0);
+  }
+
+  const filePath = options.filePath?.trim() || "(unknown path)";
+  const lines = splitWriteContentLines(sanitizeToolResultText(content));
+  const previousLines =
+    typeof options.previousContent === "string"
+      ? splitWriteContentLines(sanitizeToolResultText(options.previousContent))
+      : [];
+  const hasComparablePrevious =
+    options.fileExistedBeforeWrite === true &&
+    typeof options.previousContent === "string";
+  const approximateStats = buildApproximateWriteStats(
+    lines.length,
+    previousLines.length,
+    hasComparablePrevious,
+  );
+  const palette = resolveDiffPalette(theme);
+  // Keep the panel transparent; changed rows and inline spans retain their own highlights.
+  const containerBgAnsi = undefined;
+  const language = resolveLanguageFromPath(filePath);
+  const cache = createDiffRenderCache();
+  let highlightLine: CodeLineHighlighter | undefined;
+  let detailedData: WriteDiffData | undefined;
+
+  function getDetailedData(): WriteDiffData {
+    if (detailedData) {
+      return detailedData;
+    }
+    const entries = hasComparablePrevious
+      ? buildWriteOverwriteEntries(previousLines, lines)
+      : buildWriteEntries(lines);
+    detailedData = buildWriteDiffData(entries);
+    highlightLine = createCodeLineHighlighter(language, theme, entries, () => {
+      cache.invalidate();
+      options.invalidate?.();
+    });
+    return detailedData;
+  }
+
+  return {
+    [RICH_DIFF_COMPONENT]: true,
+    render(width: number): string[] {
+      // Live config: panel can change indicator/wrap/limits after this component is created.
+      const live = resolveLiveDisplayConfig(config);
+      const wordWrap = live.diffWordWrap;
+      const indicatorMode = resolveDiffIndicatorMode(live);
+      const configKey = displayConfigCacheKey(live);
+      const safeWidth = normalizeDiffRenderWidth(width);
+      const resolvedMode = resolveDiffPresentationMode(
+        live,
+        safeWidth,
+        canRenderSplitLayout(safeWidth),
+      );
+      const mode: DiffPresentationMode = hasComparablePrevious
+        ? resolvedMode
+        : resolvedMode === "split"
+          ? "unified"
+          : resolvedMode;
+      const hovered = options.isHovered?.() ?? false;
+      const cached = cache.get(
+        safeWidth,
+        options.expanded,
+        mode,
+        configKey,
+        hovered,
+      );
+      if (cached) {
+        return cached;
+      }
+
+      const writeCollapsedLimit = resolveWriteCollapsedLimit(live);
+      const statsOnlyCollapsed = !options.expanded && writeCollapsedLimit === 0;
+      if (statsOnlyCollapsed) {
+        return cache.set(
+          safeWidth,
+          options.expanded,
+          mode,
+          configKey,
+          hovered,
+          clampDiffLinesToWidth(
+            renderWriteCollapsedHintLine(
+              options.fileExistedBeforeWrite === true,
+              safeWidth,
+              theme,
+              hovered,
+              options.headerLabel,
+            ),
+            safeWidth,
+          ),
+        );
+      }
+
+      const header = renderWriteHeader(
+        options.fileExistedBeforeWrite === true,
+        safeWidth,
+        theme,
+        options.headerLabel,
+      );
+      // Guard depends on expanded: collapsed previews use a stricter LCS cell budget.
+      const overwriteGuard = hasComparablePrevious
+        ? resolveWriteOverwriteGuard(previousLines, lines, options.expanded)
+        : undefined;
+      if (overwriteGuard) {
+        return cache.set(
+          safeWidth,
+          options.expanded,
+          mode,
+          configKey,
+          hovered,
+          clampDiffLinesToWidth(
+            [
+              header,
+              ...renderWriteOverwriteGuardRows(
+                overwriteGuard,
+                safeWidth,
+                theme,
+              ),
+            ],
+            safeWidth,
+          ),
+        );
+      }
+
+      if (mode === "summary") {
+        const summaryRows =
+          approximateStats.lines === 0
+            ? [header]
+            : [
+                header,
+                ...renderSingleDiffRow(
+                  buildDiffSummaryText(approximateStats, safeWidth),
+                  "toolOutput",
+                  safeWidth,
+                  theme,
+                ),
+              ];
+        return cache.set(
+          safeWidth,
+          options.expanded,
+          mode,
+          configKey,
+          hovered,
+          clampDiffLinesToWidth(summaryRows, safeWidth),
+        );
+      }
+
+      const data = getDetailedData();
+      const displayLimit = resolveDiffDisplayLimit(
+        options.expanded,
+        writeCollapsedLimit,
+        live.expandedPreviewMaxLines,
+      );
+      const processBudget = resolveDiffProcessBudget(displayLimit, wordWrap);
+      const entryBudget = takeEntriesForLineBudget(data.entries, processBudget);
+      const splitBudget = takeSplitRowsForBudget(data.splitRows, processBudget);
+      const inlineHighlights =
+        splitBudget.processedRows < splitBudget.totalRows
+          ? buildInlineHighlightMap(splitBudget.rows)
+          : data.inlineHighlights;
+      const renderCtx: DiffRenderContext = {
+        width: safeWidth,
+        theme,
+        inlineHighlights,
+        palette,
+        highlightLine: highlightLine!,
+        containerBgAnsi,
+        wordWrap,
+        indicatorMode,
+        showHashlineAnchors: false,
+      };
+      const bodyRows: RenderedRow[] =
+        entryBudget.entries.length === 0
+          ? [{ text: theme.fg("muted", "(empty file)"), hunkIndex: null }]
+          : mode === "split"
+            ? renderSplit(splitBudget.rows, renderCtx, data.lineNumberWidth)
+            : mode === "compact"
+              ? renderCompact(entryBudget.entries, renderCtx)
+              : renderUnified(
+                  entryBudget.entries,
+                  renderCtx,
+                  data.lineNumberWidth,
+                );
+      const unprocessedLogicalRows =
+        mode === "split"
+          ? Math.max(0, splitBudget.totalRows - splitBudget.processedRows)
+          : Math.max(
+              0,
+              entryBudget.totalLineEntries - entryBudget.processedLineEntries,
+            );
+
+      const bodyWithLimit = applyLineLimit(
+        bodyRows,
+        safeWidth,
+        options.expanded,
+        writeCollapsedLimit,
+        live.expandedPreviewMaxLines,
+        data.hunkCount,
+        theme,
+        unprocessedLogicalRows,
+        hovered,
+      );
+      const frame = renderDiffFrameLine(safeWidth, theme);
+      const renderedLines =
+        mode === "unified"
+          ? [header, frame, ...bodyWithLimit, frame]
+          : [header, ...bodyWithLimit];
+      const finalLines = clampDiffLinesToWidth(renderedLines, safeWidth);
+      return cache.set(
+        safeWidth,
+        options.expanded,
+        mode,
+        configKey,
+        hovered,
+        finalLines,
+      );
+    },
+    invalidate: cache.invalidate,
+  } as Component;
+}