@hheei/pi-ext-ui 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hheei
+
+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.

package/README.md

@@ -1,3 +1,9 @@
-# Temporary Holding Version
+# @hheei/pi-ext-ui
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Pi UI primitives and a small set of specialized tool renderers.
+
+`pi-ext-ui` owns the visual result, not tool execution. Its default resolver only handles tools with an explicit specialized renderer (`edit`, `read`, `write`, `apply_patch`, `eval`, and `codemode`). Other tools remain on Pi's native renderer. Extensions can opt into the shared visual API with `createToolView`, `ToolView`, and `DiffView`, or explicitly add a tool through resolver options.
+
+The shared view API owns fold levels, compact sections, status glyphs, copy feedback, and width-safe rendering. It does not read files, execute tools, infer outcomes, or import a concrete extension.
+
+Background Bash and subagent tools own their display formats through ext-core `ToolPresentation` providers. This resolver consumes those providers automatically, including nested codemode calls, and adds shared folding and copy controls. Without `pi-ext-ui`, the same tools retain native Pi renderers. No direct dependency on `pi-ext-ui` is required by the tool extensions.

package/dist/apply-patch-glyph.d.ts

@@ -0,0 +1,10 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+/**
+ * Display contract mirror of pi-ext-tools' MUTATION_GLYPH/MUTATION_TONE: how one
+ * mutation outcome is drawn. The persisted `ApplyPatchToolDetails` carries the
+ * outcome facts; pi-ext-ui never imports pi-ext-tools, so the glyph vocabulary is
+ * restated here as part of the rendering contract it consumes.
+ */
+export declare const APPLY_PATCH_GLYPH: Record<string, string>;
+export declare const APPLY_PATCH_TONE: Record<string, "success" | "warning" | "dim" | "error">;
+export declare function applyPatchGlyph(status: string, theme: Theme): string;

package/dist/apply-patch-glyph.js

@@ -0,0 +1,29 @@
+/**
+ * Display contract mirror of pi-ext-tools' MUTATION_GLYPH/MUTATION_TONE: how one
+ * mutation outcome is drawn. The persisted `ApplyPatchToolDetails` carries the
+ * outcome facts; pi-ext-ui never imports pi-ext-tools, so the glyph vocabulary is
+ * restated here as part of the rendering contract it consumes.
+ */
+export const APPLY_PATCH_GLYPH = {
+    pending: "⋯",
+    applied: "✓",
+    partial: "▲",
+    fuzzy: "▲",
+    unconfirmed: "▲",
+    not_applied: "·",
+    rejected: "✗",
+};
+export const APPLY_PATCH_TONE = {
+    pending: "dim",
+    applied: "success",
+    partial: "warning",
+    fuzzy: "warning",
+    unconfirmed: "warning",
+    not_applied: "dim",
+    rejected: "error",
+};
+export function applyPatchGlyph(status, theme) {
+    const glyph = APPLY_PATCH_GLYPH[status] ?? "✗";
+    const tone = APPLY_PATCH_TONE[status] ?? "error";
+    return theme.fg(tone, glyph);
+}

package/dist/apply-patch-preview.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Display-only recognition of V4A operation headers in a patch that is still
+ * streaming. Mirrors the recognition rules pi-ext-tools' parser applies, but
+ * only as far as drawing `󰄰 create|modify|delete path +A -D` preview rows
+ * requires: a line is a candidate header, a payload line, or stops the preview.
+ */
+export interface V4aPreviewOperationView {
+    readonly kind: "add" | "delete" | "update";
+    readonly path: string;
+    readonly addedLines: number;
+    readonly removedLines: number;
+}
+/** Opaque cursor stored in the render state across streamed updates. */
+export interface V4aPreviewCursor {
+    consumed: string;
+    operations: MutablePreviewOperation[];
+    stopped: boolean;
+}
+type MutablePreviewOperation = {
+    kind: "add" | "delete" | "update";
+    path: string;
+    addedLines: number;
+    removedLines: number;
+};
+/**
+ * Incremental preview of the operation headers completed so far. The cursor
+ * lives in the render state so each streamed update only processes new lines.
+ */
+export declare function previewV4aOperations(input: string, argsComplete: boolean, cursor: V4aPreviewCursor | undefined): readonly V4aPreviewOperationView[];
+export {};

package/dist/apply-patch-preview.js

@@ -0,0 +1,89 @@
+const ADD = "*** Add File: ";
+const DELETE = "*** Delete File: ";
+const UPDATE = "*** Update File: ";
+const MOVE = "*** Move to: ";
+const BEGIN = "*** Begin Patch";
+const END = "*** End Patch";
+const MAX_PREVIEW_OPERATIONS = 128;
+function parseHeader(text) {
+    if (text.startsWith(ADD))
+        return { kind: "add", path: text.slice(ADD.length) };
+    if (text.startsWith(DELETE))
+        return { kind: "delete", path: text.slice(DELETE.length) };
+    if (text.startsWith(UPDATE))
+        return { kind: "update", path: text.slice(UPDATE.length) };
+    return undefined;
+}
+function previewablePath(path) {
+    return path !== "" && !path.includes("\0") && path !== BEGIN && path !== END;
+}
+function applyPreviewLine(state, text) {
+    if (text === BEGIN || text === END)
+        return true;
+    const header = parseHeader(text);
+    if (header !== undefined) {
+        if (!previewablePath(header.path) || state.operations.length >= MAX_PREVIEW_OPERATIONS)
+            return false;
+        state.operations.push({ kind: header.kind, path: header.path, addedLines: 0, removedLines: 0 });
+        return true;
+    }
+    const current = state.operations.at(-1);
+    if (current === undefined)
+        return true;
+    if (current.kind === "update" && text.startsWith(MOVE)) {
+        const moveTo = text.slice(MOVE.length);
+        if (!previewablePath(moveTo))
+            return false;
+        current.path = moveTo;
+        return true;
+    }
+    if (current.kind === "add") {
+        if (!text.startsWith("+"))
+            return false;
+        if (text.slice(1).length > 0)
+            current.addedLines += 1;
+        return true;
+    }
+    if (current.kind === "delete")
+        return false;
+    if (text.startsWith("@@") || text.startsWith(" "))
+        return true;
+    if (text.startsWith("+")) {
+        current.addedLines += 1;
+        return true;
+    }
+    if (text.startsWith("-")) {
+        current.removedLines += 1;
+        return true;
+    }
+    return false;
+}
+/**
+ * Incremental preview of the operation headers completed so far. The cursor
+ * lives in the render state so each streamed update only processes new lines.
+ */
+export function previewV4aOperations(input, argsComplete, cursor) {
+    const state = cursor ?? { consumed: "", operations: [], stopped: false };
+    if (!input.startsWith(state.consumed)) {
+        state.consumed = "";
+        state.operations = [];
+        state.stopped = false;
+    }
+    if (state.stopped)
+        return state.operations.map((operation) => ({ ...operation }));
+    const lines = (input.slice(state.consumed.length).match(/[^\n]*\n?/g) ?? []).filter((line) => line !== "");
+    for (const [index, raw] of lines.entries()) {
+        const newline = raw.endsWith("\n") ? "\n" : "";
+        const text = newline === "" ? raw : raw.slice(0, -1).replace(/\r$/, "");
+        const complete = newline !== "" || (argsComplete && index === lines.length - 1);
+        if (!complete)
+            break;
+        const applied = applyPreviewLine(state, text);
+        if (!applied) {
+            state.stopped = true;
+            break;
+        }
+        state.consumed += raw;
+    }
+    return state.operations.map((operation) => ({ ...operation }));
+}

package/dist/apply-patch-view.d.ts

@@ -0,0 +1,47 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+/**
+ * Display-side view of pi-ext-tools' persisted `ApplyPatchToolDetails`.
+ * The details are the contract; every field is read defensively at this
+ * untrusted boundary and dropped when it does not match the contract.
+ */
+export interface ApplyPatchOperationView {
+    readonly operationIndex: number;
+    readonly kind: "add" | "delete" | "update";
+    readonly path: string;
+    readonly addedLines: number;
+    readonly removedLines: number;
+    readonly status: string;
+    readonly appliedHunks: number | undefined;
+    readonly totalHunks: number | undefined;
+    readonly partialReason: string | undefined;
+}
+export interface ApplyPatchSnapshotView {
+    readonly path: string;
+    readonly startLine: number;
+    readonly before: readonly string[];
+    readonly after: readonly string[];
+}
+export interface ApplyPatchRejectionView {
+    readonly paths: readonly string[];
+    readonly error: string;
+    readonly diagnostics: readonly {
+        readonly text: string;
+    }[];
+}
+export interface ApplyPatchFacts {
+    readonly status: "success" | "partial" | "failed";
+    readonly operations: readonly ApplyPatchOperationView[];
+    readonly snapshots: readonly ApplyPatchSnapshotView[];
+    readonly rejected: readonly ApplyPatchRejectionView[];
+    readonly unconfirmed: readonly ApplyPatchRejectionView[];
+    readonly notApplied: readonly ApplyPatchRejectionView[];
+    readonly addedLines: number;
+    readonly removedLines: number;
+    readonly changedPaths: readonly string[];
+    readonly target: string | undefined;
+    readonly inProgress: boolean;
+}
+/** Reads only the persisted apply_patch details; other shapes return undefined. */
+export declare function applyPatchFacts(details: unknown): ApplyPatchFacts | undefined;
+/** One operation row: glyph, verb, path, delta, fuzzy marker, hunk summary. */
+export declare function formatApplyPatchOperationRow(operation: ApplyPatchOperationView, theme: Theme, host: string | undefined): string;

package/dist/apply-patch-view.js

@@ -0,0 +1,198 @@
+import { applyPatchGlyph } from "./apply-patch-glyph.js";
+const PATCH_STATUSES = ["success", "partial", "failed"];
+function isPatchStatus(value) {
+    return PATCH_STATUSES.includes(value);
+}
+const OPERATION_STATUSES = new Set([
+    "pending",
+    "applied",
+    "partial",
+    "fuzzy",
+    "unconfirmed",
+    "not_applied",
+    "rejected",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function operationView(value) {
+    const path = typeof value.path === "string" ? value.path : undefined;
+    if (path === undefined)
+        return undefined;
+    const kind = value.kind === "add" || value.kind === "delete" || value.kind === "update"
+        ? value.kind
+        : undefined;
+    if (kind === undefined)
+        return undefined;
+    const status = typeof value.status === "string" && OPERATION_STATUSES.has(value.status)
+        ? value.status
+        : undefined;
+    if (status === undefined)
+        return undefined;
+    return {
+        operationIndex: typeof value.operationIndex === "number" ? value.operationIndex : 0,
+        kind,
+        path,
+        addedLines: typeof value.addedLines === "number" ? value.addedLines : 0,
+        removedLines: typeof value.removedLines === "number" ? value.removedLines : 0,
+        status,
+        appliedHunks: typeof value.appliedHunks === "number" ? value.appliedHunks : undefined,
+        totalHunks: typeof value.totalHunks === "number" ? value.totalHunks : undefined,
+        partialReason: typeof value.partialReason === "string" ? value.partialReason : undefined,
+    };
+}
+function snapshotView(value) {
+    const path = typeof value.path === "string" ? value.path : undefined;
+    if (path === undefined)
+        return undefined;
+    const before = Array.isArray(value.before)
+        ? value.before.filter((line) => typeof line === "string")
+        : undefined;
+    const after = Array.isArray(value.after)
+        ? value.after.filter((line) => typeof line === "string")
+        : undefined;
+    if (before === undefined || after === undefined)
+        return undefined;
+    return {
+        path,
+        startLine: typeof value.startLine === "number" && value.startLine > 0 ? value.startLine : 1,
+        before,
+        after,
+    };
+}
+function rejectionView(value) {
+    const error = typeof value.error === "string" ? value.error : undefined;
+    if (error === undefined)
+        return undefined;
+    const paths = Array.isArray(value.paths)
+        ? value.paths.filter((path) => typeof path === "string")
+        : [];
+    const diagnostics = Array.isArray(value.diagnostics)
+        ? value.diagnostics
+            .filter(isRecord)
+            .map((diagnostic) => {
+            if (diagnostic.kind === "context_not_found") {
+                return typeof diagnostic.hint === "string"
+                    ? `context not found (${diagnostic.hint})`
+                    : "context not found";
+            }
+            if (diagnostic.kind === "ambiguous_exact") {
+                const candidates = Array.isArray(diagnostic.candidateStartLines)
+                    ? diagnostic.candidateStartLines.filter((line) => typeof line === "number")
+                    : [];
+                return `exact context is ambiguous at lines ${candidates.join(", ")}`;
+            }
+            return undefined;
+        })
+            .filter((text) => text !== undefined)
+            .map((text) => ({ text }))
+        : [];
+    return { paths, error, diagnostics };
+}
+function rejectionList(value) {
+    if (!Array.isArray(value))
+        return [];
+    const views = [];
+    for (const entry of value) {
+        if (!isRecord(entry))
+            continue;
+        const view = rejectionView(entry);
+        if (view !== undefined)
+            views.push(view);
+    }
+    return views;
+}
+/** Reads only the persisted apply_patch details; other shapes return undefined. */
+export function applyPatchFacts(details) {
+    if (!isRecord(details))
+        return undefined;
+    if (typeof details.status !== "string" || !isPatchStatus(details.status))
+        return undefined;
+    const status = details.status;
+    const operations = Array.isArray(details.operations)
+        ? details.operations
+            .filter(isRecord)
+            .map(operationView)
+            .filter((operation) => operation !== undefined)
+        : [];
+    // Older results carry applied/rejected lists instead of operations; the operation
+    // rows are rebuilt from them without hunk counts.
+    const applied = Array.isArray(details.applied) ? details.applied.filter(isRecord) : [];
+    const rejected = rejectionList(details.rejected);
+    if (operations.length === 0) {
+        for (const operation of applied) {
+            const path = typeof operation.paths === "object" &&
+                operation.paths !== null &&
+                Array.isArray(operation.paths) &&
+                typeof operation.paths[0] === "string"
+                ? operation.paths[0]
+                : undefined;
+            if (path === undefined)
+                continue;
+            const view = operationView({
+                operationIndex: operation.operationIndex,
+                kind: operation.kind,
+                path,
+                addedLines: 0,
+                removedLines: 0,
+                status: "applied",
+            });
+            if (view !== undefined)
+                operations.push(view);
+        }
+        for (const [index, rejection] of rejected.entries()) {
+            const view = operationView({
+                operationIndex: index,
+                kind: "update",
+                path: rejection.paths[0] ?? "<unknown>",
+                addedLines: 0,
+                removedLines: 0,
+                status: "rejected",
+            });
+            if (view !== undefined)
+                operations.push(view);
+        }
+    }
+    const snapshots = Array.isArray(details.applied)
+        ? details.applied.filter(isRecord).flatMap((operation) => Array.isArray(operation.snapshots)
+            ? operation.snapshots
+                .filter(isRecord)
+                .map(snapshotView)
+                .filter((snapshot) => snapshot !== undefined)
+            : [])
+        : [];
+    return {
+        status,
+        operations,
+        snapshots,
+        rejected,
+        unconfirmed: rejectionList(details.unconfirmed),
+        notApplied: rejectionList(details.notApplied),
+        addedLines: typeof details.addedLines === "number" ? details.addedLines : 0,
+        removedLines: typeof details.removedLines === "number" ? details.removedLines : 0,
+        changedPaths: Array.isArray(details.changedPaths)
+            ? details.changedPaths.filter((path) => typeof path === "string")
+            : [],
+        target: typeof details.target === "string" && details.target !== "local" ? details.target : undefined,
+        inProgress: isRecord(details.progress),
+    };
+}
+/** One operation row: glyph, verb, path, delta, fuzzy marker, hunk summary. */
+export function formatApplyPatchOperationRow(operation, theme, host) {
+    const glyph = applyPatchGlyph(operation.status, theme);
+    const kind = operation.kind === "add" ? "create" : operation.kind === "delete" ? "delete" : "modify";
+    const path = host === undefined ? operation.path : `${theme.fg("warning", `${host}:`)}${operation.path}`;
+    const deltaParts = [];
+    if (operation.addedLines > 0)
+        deltaParts.push(theme.fg("success", `+${String(operation.addedLines)}`));
+    if (operation.removedLines > 0)
+        deltaParts.push(theme.fg("error", `-${String(operation.removedLines)}`));
+    const delta = deltaParts.length > 0 ? ` (${deltaParts.join(" ")})` : "";
+    const score = operation.status === "fuzzy" ? ` ${theme.fg("dim", "fuzzy")}` : "";
+    const hunks = operation.status === "partial" &&
+        operation.appliedHunks !== undefined &&
+        operation.totalHunks !== undefined
+        ? ` ${theme.fg("dim", `(${String(operation.appliedHunks)}/${String(operation.totalHunks)} hunks applied${operation.partialReason === undefined ? "" : `; ${operation.partialReason}`})`)}`
+        : "";
+    return `${glyph} ${theme.fg("toolTitle", kind)} ${path}${delta}${score}${hunks}`.trimEnd();
+}

package/dist/diff-view.d.ts

@@ -0,0 +1,46 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component } from "@earendil-works/pi-tui";
+/** One displayed diff row. `line` is 1-based: old file for `del`, new file otherwise. */
+export interface DiffLine {
+    readonly kind: "add" | "del" | "ctx";
+    readonly line: number;
+    readonly text: string;
+}
+/** One contiguous change region, in display order. */
+export interface DiffHunk {
+    readonly lines: readonly DiffLine[];
+}
+/**
+ * Real diff sources, never a partially populated patch/before/after bag:
+ * a standard unified patch (what Pi native edit persists as `details.patch`) or
+ * hunks a caller already parsed.
+ */
+export type DiffSource = {
+    readonly kind: "unifiedPatch";
+    readonly text: string;
+} | {
+    readonly kind: "hunks";
+    readonly hunks: readonly DiffHunk[];
+};
+export interface DiffStats {
+    readonly added: number;
+    readonly removed: number;
+}
+export interface DiffViewOptions {
+    readonly theme: Theme;
+    readonly source: DiffSource;
+}
+/** Counts from the same interpretation the DiffView body renders. */
+export declare function diffStats(source: DiffSource): DiffStats | undefined;
+/**
+ * Unified single-column diff body for the ToolView rail. One space between the
+ * sign/line number and the source, right-aligned numbers, no right-side bar and
+ * no split columns. Wrapped continuation rows repeat neither sign nor number.
+ * A patch that cannot be parsed keeps its raw text behind a short diagnostic.
+ */
+export declare class DiffView implements Component {
+    #private;
+    constructor(options: DiffViewOptions);
+    render(width: number): string[];
+    invalidate(): void;
+}

package/dist/diff-view.js

@@ -0,0 +1,184 @@
+import { truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+const HUNK_HEADER = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+const PATCH_HEADER = /^(diff --git |diff -|index |--- |\+\+\+ |old mode |new mode |new file|deleted file|similarity index|rename |copy |Binary files )/;
+const MIN_NUMBER_WIDTH = 2;
+/** Tab width used for layout only; copy text keeps the original bytes. */
+const TAB_WIDTH = 2;
+function parseUnifiedPatch(text) {
+    if (text.trim() === "")
+        return { ok: false, diagnostic: "empty patch" };
+    const rawLines = text.split(/\r?\n/);
+    const hunks = [];
+    let added = 0;
+    let removed = 0;
+    let bodyLines = 0;
+    let current;
+    let oldNum = 0;
+    let newNum = 0;
+    for (let index = 0; index < rawLines.length; index += 1) {
+        const raw = rawLines[index] ?? "";
+        if (raw.startsWith("@@")) {
+            const header = HUNK_HEADER.exec(raw);
+            if (header === null)
+                return { ok: false, diagnostic: `invalid hunk header: ${raw}` };
+            if (current !== undefined)
+                hunks.push({ lines: current });
+            current = [];
+            oldNum = Number(header[1]);
+            newNum = Number(header[2]);
+            continue;
+        }
+        if (raw.startsWith("\\"))
+            continue;
+        if (current === undefined) {
+            if (raw === "" || PATCH_HEADER.test(raw))
+                continue;
+            return { ok: false, diagnostic: `unexpected line before the first hunk: ${raw}` };
+        }
+        if (raw === "") {
+            if (index === rawLines.length - 1)
+                break;
+            return { ok: false, diagnostic: "hunk line without a change sign" };
+        }
+        const sign = raw.charAt(0);
+        const body = raw.slice(1);
+        if (sign === "+") {
+            current.push({ kind: "add", line: newNum, text: body });
+            newNum += 1;
+            added += 1;
+        }
+        else if (sign === "-") {
+            current.push({ kind: "del", line: oldNum, text: body });
+            oldNum += 1;
+            removed += 1;
+        }
+        else if (sign === " ") {
+            current.push({ kind: "ctx", line: newNum, text: body });
+            oldNum += 1;
+            newNum += 1;
+        }
+        else {
+            return { ok: false, diagnostic: `unsupported hunk line: ${raw}` };
+        }
+        bodyLines += 1;
+    }
+    if (current !== undefined)
+        hunks.push({ lines: current });
+    if (bodyLines === 0)
+        return { ok: false, diagnostic: "no hunks found" };
+    return { ok: true, hunks, stats: { added, removed } };
+}
+function summarizeHunks(hunks) {
+    let added = 0;
+    let removed = 0;
+    let bodyLines = 0;
+    for (const hunk of hunks) {
+        for (const line of hunk.lines) {
+            bodyLines += 1;
+            if (line.kind === "add")
+                added += 1;
+            else if (line.kind === "del")
+                removed += 1;
+        }
+    }
+    if (bodyLines === 0)
+        return { ok: false, diagnostic: "no hunks found" };
+    return { ok: true, hunks, stats: { added, removed } };
+}
+function parseSource(source) {
+    return source.kind === "unifiedPatch"
+        ? parseUnifiedPatch(source.text)
+        : summarizeHunks(source.hunks);
+}
+/** Counts from the same interpretation the DiffView body renders. */
+export function diffStats(source) {
+    const parsed = parseSource(source);
+    return parsed.ok ? parsed.stats : undefined;
+}
+function numberWidth(hunks) {
+    let max = 0;
+    for (const hunk of hunks) {
+        for (const line of hunk.lines) {
+            if (line.line > max)
+                max = line.line;
+        }
+    }
+    return Math.max(MIN_NUMBER_WIDTH, String(max).length);
+}
+function lineToken(kind) {
+    if (kind === "add")
+        return "success";
+    if (kind === "del")
+        return "error";
+    return "dim";
+}
+function lineSign(kind) {
+    if (kind === "add")
+        return "+";
+    if (kind === "del")
+        return "-";
+    return " ";
+}
+/**
+ * Unified single-column diff body for the ToolView rail. One space between the
+ * sign/line number and the source, right-aligned numbers, no right-side bar and
+ * no split columns. Wrapped continuation rows repeat neither sign nor number.
+ * A patch that cannot be parsed keeps its raw text behind a short diagnostic.
+ */
+export class DiffView {
+    #theme;
+    #parsed;
+    #rawText;
+    #cache;
+    constructor(options) {
+        this.#theme = options.theme;
+        this.#rawText = options.source.kind === "unifiedPatch" ? options.source.text : undefined;
+        this.#parsed = parseSource(options.source);
+    }
+    render(width) {
+        const safeWidth = Math.max(1, width);
+        if (this.#cache?.width === safeWidth)
+            return this.#cache.rows;
+        const rows = this.#parsed.ok
+            ? this.#renderDiff(safeWidth, this.#parsed.hunks)
+            : this.#renderRaw(safeWidth);
+        this.#cache = { width: safeWidth, rows };
+        return rows;
+    }
+    invalidate() {
+        this.#cache = undefined;
+    }
+    #renderRaw(width) {
+        const rows = [];
+        if (!this.#parsed.ok)
+            rows.push(this.#theme.fg("warning", `! ${this.#parsed.diagnostic}`));
+        for (const raw of (this.#rawText ?? "").split(/\r?\n/)) {
+            rows.push(this.#theme.fg("dim", raw));
+        }
+        return rows.map((row) => truncateToWidth(row, width, "…"));
+    }
+    #renderDiff(width, hunks) {
+        const numberCol = numberWidth(hunks);
+        const gutterWidth = numberCol + 2;
+        const contentWidth = Math.max(1, width - gutterWidth);
+        const continuation = " ".repeat(gutterWidth);
+        const rows = [];
+        let isFirstHunk = true;
+        for (const hunk of hunks) {
+            if (!isFirstHunk) {
+                rows.push(this.#theme.fg("dim", ` ${"…".padStart(numberCol)}`));
+            }
+            isFirstHunk = false;
+            for (const line of hunk.lines) {
+                const token = lineToken(line.kind);
+                const prefix = `${lineSign(line.kind)}${String(line.line).padStart(numberCol)} `;
+                const wrapped = wrapTextWithAnsi(line.text.replace(/\t/g, " ".repeat(TAB_WIDTH)), contentWidth);
+                for (let row = 0; row < wrapped.length; row += 1) {
+                    const head = row === 0 ? prefix : continuation;
+                    rows.push(this.#theme.fg(token, `${head}${wrapped[row] ?? ""}`));
+                }
+            }
+        }
+        return rows.map((row) => truncateToWidth(row, width, "…"));
+    }
+}

package/dist/extension.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function (pi: ExtensionAPI): void;