pi-diff-widget 0.0.0-stage → 0.1.1

package/src/index.ts

@@ -0,0 +1,80 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { collectUncommitted, type DiffFile } from './git.ts';
+import type { ExecFn } from './exec.ts';
+import { createBaselineTracker } from './baseline.ts';
+import { collectTurns, createWriteDiffTracker } from './turns.ts';
+import { DiffViewer } from './ui.ts';
+import { toTurnViews, toUncommittedSections, type ViewMode } from './view.ts';
+import { registerDiffWidget } from './widget.ts';
+
+export default function (pi: ExtensionAPI) {
+    const lookupWrite = createWriteDiffTracker(pi);
+    const baselines = createBaselineTracker(pi);
+    const exec: ExecFn = (command, args, options) =>
+        pi.exec(command, args, options);
+
+    registerDiffWidget(pi, baselines, exec);
+
+    pi.registerCommand('diff', {
+        description:
+            'Show uncommitted changes and per-turn edits in a scrollable viewer',
+        handler: async (_args, ctx) => {
+            if (ctx.mode !== 'tui') {
+                ctx.ui.notify('/diff needs the interactive TUI', 'warning');
+                return;
+            }
+
+            await ctx.waitForIdle();
+
+            let files: DiffFile[] = [];
+            let gitError: string | undefined;
+            try {
+                files = await collectUncommitted(exec, ctx.cwd);
+            } catch (error) {
+                gitError =
+                    error instanceof Error ? error.message : String(error);
+            }
+
+            const turns = toTurnViews(
+                collectTurns(ctx.sessionManager, lookupWrite),
+            );
+
+            const uncommitted = toUncommittedSections(files);
+
+            if (uncommitted.length === 0 && turns.length === 0) {
+                if (gitError) ctx.ui.notify(`/diff: ${gitError}`, 'error');
+                else
+                    ctx.ui.notify(
+                        'No uncommitted changes and no edits this session',
+                        'info',
+                    );
+                return;
+            }
+
+            const initialMode: ViewMode =
+                uncommitted.length === 0 ? 'turns' : 'uncommitted';
+
+            await ctx.ui.custom<void>(
+                (tui, theme, _keybindings, done) =>
+                    new DiffViewer({
+                        title: 'pi diff',
+                        uncommitted,
+                        turns,
+                        initialMode,
+                        tui,
+                        theme,
+                        onClose: () => done(undefined),
+                    }),
+                {
+                    overlay: true,
+                    overlayOptions: {
+                        width: '100%',
+                        maxHeight: '100%',
+                        margin: 0,
+                        anchor: 'center',
+                    },
+                },
+            );
+        },
+    });
+}

package/src/summary.ts

@@ -0,0 +1,117 @@
+import { mkdir, unlink, writeFile } from 'node:fs/promises';
+import { dirname, relative } from 'node:path';
+import { generateDiffString } from '@earendil-works/pi-coding-agent';
+import { readFileCapped, locationGone, type BaselineTracker } from './baseline.ts';
+import { listDirtyPaths } from './git.ts';
+import type { ExecFn } from './exec.ts';
+import { summarizeDiffs, type EditSummary } from './view.ts';
+
+/**
+ * Current content for a tracked path, or undefined when it cannot be accounted
+ * for: too large, unreadable, or its whole location is gone.
+ */
+async function readCurrent(absolute: string): Promise<string | undefined> {
+    if (await locationGone(absolute)) return undefined;
+    return readFileCapped(absolute);
+}
+
+/**
+ * Net agent changes: for each file the agent touched, diff its current content
+ * against the baseline captured before the first touch. Reverted files vanish.
+ */
+export async function computeNetSummary(
+    baselines: BaselineTracker,
+    cwd: string,
+): Promise<EditSummary> {
+    const diffs: Array<{ path: string; diff: string }> = [];
+
+    for (const absolute of baselines.paths()) {
+        const current = await readCurrent(absolute);
+        if (current === undefined) continue;
+        const baseline = baselines.get(absolute) ?? '';
+        const { diff } = generateDiffString(baseline, current);
+        if (!diff) continue;
+
+        const rel = relative(cwd, absolute);
+        diffs.push({ path: rel.startsWith('..') ? absolute : rel, diff });
+    }
+
+    return summarizeDiffs(diffs);
+}
+
+export interface RevertTarget {
+    absolutePath: string;
+    relativePath: string;
+    baseline: string;
+    missing: boolean;
+}
+
+/** Files whose current content differs from their baseline. */
+export async function collectRevertTargets(
+    baselines: BaselineTracker,
+    cwd: string,
+): Promise<RevertTarget[]> {
+    const targets: RevertTarget[] = [];
+    for (const absolute of baselines.paths()) {
+        const current = await readCurrent(absolute);
+        if (current === undefined) continue;
+        const baseline = baselines.get(absolute) ?? '';
+        const { diff } = generateDiffString(baseline, current);
+        if (!diff) continue;
+        const rel = relative(cwd, absolute);
+        targets.push({
+            absolutePath: absolute,
+            relativePath: rel.startsWith('..') ? absolute : rel,
+            baseline,
+            missing: baselines.wasMissing(absolute),
+        });
+    }
+    return targets;
+}
+
+/**
+ * Restore files to their baselines: write the original content back, or delete
+ * files the agent created. The caller confirms first, since this is destructive.
+ */
+export async function revertTargets(targets: RevertTarget[]): Promise<void> {
+    for (const target of targets) {
+        if (target.missing) {
+            await unlink(target.absolutePath).catch(() => undefined);
+            continue;
+        }
+        await mkdir(dirname(target.absolutePath), { recursive: true });
+        await writeFile(target.absolutePath, target.baseline, 'utf8');
+    }
+}
+
+/**
+ * Drop files that no longer have uncommitted changes, so committing clears the
+ * panel. Files outside the repository, or sessions outside git, are kept.
+ */
+export async function pruneCleanBaselines(
+    baselines: BaselineTracker,
+    exec: ExecFn,
+    cwd: string,
+): Promise<void> {
+    // A baseline whose location is gone can never be shown or reverted again,
+    // and keeping it would let reject rebuild a directory that was moved away.
+    const live = new Set<string>();
+    for (const absolute of baselines.paths()) {
+        if (!(await locationGone(absolute))) live.add(absolute);
+    }
+    baselines.retain((absolute) => live.has(absolute));
+
+    let dirty: Set<string> | undefined;
+    try {
+        dirty = await listDirtyPaths(exec, cwd);
+    } catch {
+        return;
+    }
+    if (!dirty) return;
+
+    baselines.retain((absolute) => {
+        const rel = relative(cwd, absolute);
+        if (rel.startsWith('..')) return true; // outside the repo, cannot judge
+        return dirty.has(rel);
+    });
+}

package/src/turns.ts

@@ -0,0 +1,221 @@
+import { readFile, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import {
+    generateDiffString,
+    isToolCallEventType,
+    isWriteToolResult,
+} from '@earendil-works/pi-coding-agent';
+import type {
+    ExtensionAPI,
+    ExtensionContext,
+    SessionEntry,
+} from '@earendil-works/pi-coding-agent';
+
+export interface TurnEdit {
+    path: string;
+    /** Raw display diff in pi's line-numbered format (`+123 text`). Render with `renderDiff`. */
+    diff: string;
+}
+
+export interface Turn {
+    prompt: string;
+    edits: TurnEdit[];
+}
+
+export interface WriteDiff {
+    path: string;
+    diff: string;
+}
+
+/** Session entry type used to persist write diffs across reloads. */
+export const WRITE_DIFF_ENTRY = 'pi-diff:writes';
+
+export interface WriteDiffRecord extends WriteDiff {
+    toolCallId: string;
+}
+
+/** Maps a `write` tool call id to the diff its execution produced. */
+export type WriteDiffLookup = (toolCallId: string) => WriteDiff | undefined;
+
+/** The subset of the session manager `collectTurns` reads. */
+export type SessionBranchSource = Pick<
+    ExtensionContext['sessionManager'],
+    'getBranch'
+>;
+
+const MAX_TRACKED_WRITES = 2000;
+const MAX_TURNS = 100;
+const MAX_SNAPSHOT_BYTES = 1024 * 1024;
+
+type SnapshotRead =
+    | { kind: 'text'; text: string }
+    | { kind: 'missing' }
+    | { kind: 'too-large' };
+
+async function readSnapshot(path: string): Promise<SnapshotRead> {
+    const info = await stat(path).catch(() => undefined);
+    if (!info || !info.isFile()) return { kind: 'missing' };
+    if (info.size > MAX_SNAPSHOT_BYTES) return { kind: 'too-large' };
+    const text = await readFile(path, 'utf8').catch(() => undefined);
+    return text === undefined ? { kind: 'missing' } : { kind: 'text', text };
+}
+
+function extractText(content: unknown): string {
+    if (typeof content === 'string') return content;
+    if (!Array.isArray(content)) return '';
+    return content
+        .filter(
+            (block): block is { type: 'text'; text: string } =>
+                typeof block === 'object' &&
+                block !== null &&
+                (block as { type?: unknown }).type === 'text',
+        )
+        .map((block) => block.text)
+        .join(' ')
+        .trim();
+}
+
+/**
+ * `write` results carry no diff, so snapshot the old content and synthesize one
+ * after the write, keyed by tool call id. Diffs are persisted per turn.
+ */
+export function createWriteDiffTracker(pi: ExtensionAPI): WriteDiffLookup {
+    const pending = new Map<string, { path: string; before?: string }>();
+    const diffs = new Map<string, WriteDiff>();
+    let unflushed: string[] = [];
+
+    const flush = () => {
+        if (unflushed.length === 0) return;
+        const records: WriteDiffRecord[] = [];
+        for (const toolCallId of unflushed) {
+            const diff = diffs.get(toolCallId);
+            if (diff) records.push({ toolCallId, ...diff });
+        }
+        unflushed = [];
+        if (records.length > 0) {
+            pi.appendEntry(WRITE_DIFF_ENTRY, { diffs: records });
+        }
+    };
+
+    // Persist at turn boundaries so write diffs survive a session reload. At
+    // turn_end no tool result is in flight, so it is safe to append an entry.
+    pi.on('turn_end', flush);
+    pi.on('agent_settled', () => {
+        // A write without a matching result (aborted run) would otherwise linger.
+        pending.clear();
+        flush();
+    });
+
+    pi.on('tool_call', async (event, ctx) => {
+        if (!isToolCallEventType('write', event)) return;
+        const read = await readSnapshot(resolve(ctx.cwd, event.input.path));
+        if (read.kind === 'too-large') return; // don't read or diff oversized files
+        pending.set(event.toolCallId, {
+            path: event.input.path,
+            before: read.kind === 'text' ? read.text : undefined,
+        });
+    });
+
+    pi.on('tool_result', async (event, ctx) => {
+        if (!isWriteToolResult(event)) return;
+        const snapshot = pending.get(event.toolCallId);
+        if (!snapshot) return;
+        pending.delete(event.toolCallId);
+
+        const read = await readSnapshot(resolve(ctx.cwd, snapshot.path));
+        const after = read.kind === 'text' ? read.text : '';
+        const { diff } = generateDiffString(snapshot.before ?? '', after);
+        if (!diff) return;
+
+        diffs.set(event.toolCallId, { path: snapshot.path, diff });
+        unflushed.push(event.toolCallId);
+        while (diffs.size > MAX_TRACKED_WRITES) {
+            const oldest = diffs.keys().next().value;
+            if (oldest === undefined) break;
+            diffs.delete(oldest);
+        }
+    });
+
+    return (toolCallId) => diffs.get(toolCallId);
+}
+
+/** Collect write diffs persisted by past turns. */
+function readPersistedWrites(branch: SessionEntry[]): Map<string, WriteDiff> {
+    const writes = new Map<string, WriteDiff>();
+    for (const entry of branch) {
+        if (entry.type !== 'custom' || entry.customType !== WRITE_DIFF_ENTRY) {
+            continue;
+        }
+        const records = (entry.data as { diffs?: WriteDiffRecord[] } | undefined)
+            ?.diffs;
+        if (!Array.isArray(records)) continue;
+        for (const record of records) {
+            writes.set(record.toolCallId, {
+                path: record.path,
+                diff: record.diff,
+            });
+        }
+    }
+    return writes;
+}
+
+/**
+ * Group edits by user message from persisted session data. No git, no filesystem.
+ * `edit` results already carry `details.diff`; `write` results use `lookupWrite`.
+ */
+export function collectTurns(
+    session: SessionBranchSource,
+    lookupWrite: WriteDiffLookup,
+): Turn[] {
+    const branch = session.getBranch();
+    const persistedWrites = readPersistedWrites(branch);
+
+    const callArguments = new Map<string, Record<string, unknown>>();
+    for (const entry of branch) {
+        if (entry.type !== 'message' || entry.message.role !== 'assistant')
+            continue;
+        for (const block of entry.message.content) {
+            if (block.type === 'toolCall')
+                callArguments.set(block.id, block.arguments ?? {});
+        }
+    }
+
+    const turns: Turn[] = [];
+    let current: Turn | undefined;
+
+    for (const entry of branch) {
+        if (entry.type !== 'message') continue;
+        const message = entry.message;
+
+        if (message.role === 'user') {
+            current = {
+                prompt: extractText(message.content),
+                edits: [],
+            };
+            turns.push(current);
+            continue;
+        }
+
+        if (message.role !== 'toolResult') continue;
+
+        const args = callArguments.get(message.toolCallId);
+        const path = typeof args?.path === 'string' ? args.path : '(unknown)';
+
+        if (message.toolName === 'edit') {
+            const diff = (message.details as { diff?: string } | undefined)
+                ?.diff;
+            if (diff) current?.edits.push({ path, diff });
+            continue;
+        }
+
+        if (message.toolName === 'write') {
+            const tracked =
+                lookupWrite(message.toolCallId) ??
+                persistedWrites.get(message.toolCallId);
+            if (tracked)
+                current?.edits.push({ path: tracked.path, diff: tracked.diff });
+        }
+    }
+
+    return turns.length > MAX_TURNS ? turns.slice(-MAX_TURNS) : turns;
+}

package/src/ui.ts

@@ -0,0 +1,234 @@
+import { Key, matchesKey, truncateToWidth } from '@earendil-works/pi-tui';
+import type { Component, TUI } from '@earendil-works/pi-tui';
+import { renderDiff } from '@earendil-works/pi-coding-agent';
+import type { DiffSection, TurnView, ViewMode } from './view.ts';
+import {
+    buildDocument,
+    type DiffTextRenderer,
+    type DocumentTheme,
+} from './document.ts';
+
+export interface DiffViewerOptions {
+    title: string;
+    uncommitted: DiffSection[];
+    turns: TurnView[];
+    initialMode: ViewMode;
+    tui: TUI;
+    theme: DocumentTheme;
+    onClose: () => void;
+    /** Defaults to pi's `renderDiff`, which uses pi's active theme. */
+    renderDiffText?: DiffTextRenderer;
+}
+
+/**
+ * Full-screen scrollable diff view. Renders one source at a time: uncommitted
+ * changes or the edits of a single turn. `Tab` switches source, `[` and `]`
+ * walk turns. Used as an overlay, so it reads its own height from the terminal.
+ */
+export class DiffViewer implements Component {
+    private readonly title: string;
+    private readonly uncommitted: DiffSection[];
+    private readonly turns: TurnView[];
+    private readonly tui: TUI;
+    private readonly theme: DocumentTheme;
+    private readonly renderDiffText: DiffTextRenderer;
+    private readonly onClose: () => void;
+
+    private mode: ViewMode;
+    private turnIndex: number;
+    private lines: string[] = [];
+    private sectionStarts: number[] = [];
+    private offset = 0;
+    private viewportHeight = 1;
+
+    constructor(options: DiffViewerOptions) {
+        this.title = options.title;
+        this.uncommitted = options.uncommitted;
+        this.turns = options.turns;
+        this.tui = options.tui;
+        this.theme = options.theme;
+        this.renderDiffText = options.renderDiffText ?? renderDiff;
+        this.onClose = options.onClose;
+        this.mode = options.initialMode;
+        this.turnIndex = Math.max(0, options.turns.length - 1);
+        this.rebuild();
+    }
+
+    private currentSections(): DiffSection[] {
+        if (this.mode === 'turns')
+            return this.turns[this.turnIndex]?.sections ?? [];
+        return this.uncommitted;
+    }
+
+    private rebuild(): void {
+        const document = buildDocument(
+            this.currentSections(),
+            this.theme,
+            this.renderDiffText,
+        );
+        this.lines = document.lines;
+        this.sectionStarts = document.sectionStarts;
+    }
+
+    private headerText(): string {
+        if (this.mode === 'turns') {
+            const counter = `[${this.turnIndex + 1}/${this.turns.length}]`;
+            const label = this.turns[this.turnIndex]?.label ?? '';
+            return `${this.title} · turns  ${this.theme.fg('dim', `${counter} ${label}`)}`;
+        }
+        return `${this.title} · uncommitted  ${this.theme.fg('dim', `[${this.uncommitted.length} files]`)}`;
+    }
+
+    private footerHint(): string {
+        const parts: string[] = [];
+        if (this.mode === 'turns') {
+            parts.push('[ / ] turn');
+            if (this.uncommitted.length > 0) parts.push('Tab uncommitted');
+        } else if (this.turns.length > 0) {
+            parts.push('Tab turns');
+        }
+        parts.push('up/down scroll', 'n/p section', 'g/G ends', 'q close');
+        return parts.join('   ');
+    }
+
+    private clamp(): void {
+        const max = Math.max(0, this.lines.length - this.viewportHeight);
+        this.offset = Math.max(0, Math.min(this.offset, max));
+    }
+
+    private currentSectionIndex(): number {
+        let index = 0;
+        for (let i = 0; i < this.sectionStarts.length; i++) {
+            if ((this.sectionStarts[i] ?? 0) <= this.offset) index = i;
+        }
+        return index;
+    }
+
+    private scroll(delta: number): void {
+        this.offset += delta;
+        this.clamp();
+        this.tui.requestRender();
+    }
+
+    private goTo(line: number): void {
+        this.offset = line;
+        this.clamp();
+        this.tui.requestRender();
+    }
+
+    private goToSection(direction: number): void {
+        const next = this.currentSectionIndex() + direction;
+        if (next < 0 || next >= this.sectionStarts.length) return;
+        this.goTo(this.sectionStarts[next] ?? 0);
+    }
+
+    private switchMode(): void {
+        if (this.mode === 'turns') {
+            this.mode = 'uncommitted';
+        } else {
+            if (this.turns.length === 0) return;
+            this.mode = 'turns';
+            this.turnIndex = this.turns.length - 1;
+        }
+        this.offset = 0;
+        this.rebuild();
+        this.tui.requestRender();
+    }
+
+    private stepTurn(direction: number): void {
+        const next = this.turnIndex + direction;
+        if (next < 0 || next >= this.turns.length) return;
+        this.turnIndex = next;
+        this.offset = 0;
+        this.rebuild();
+        this.tui.requestRender();
+    }
+
+    render(width: number): string[] {
+        const height = Math.max(6, this.tui.terminal.rows - 1);
+        this.viewportHeight = Math.max(1, height - 2);
+        this.clamp();
+
+        const out: string[] = [truncateToWidth(this.headerText(), width)];
+
+        for (let i = 0; i < this.viewportHeight; i++) {
+            const line = this.lines[this.offset + i];
+            out.push(line === undefined ? '' : truncateToWidth(line, width));
+        }
+
+        const last = Math.min(
+            this.offset + this.viewportHeight,
+            this.lines.length,
+        );
+        const range =
+            this.lines.length === 0
+                ? '0/0'
+                : `${this.offset + 1}-${last}/${this.lines.length}`;
+        out.push(
+            truncateToWidth(
+                this.theme.fg('dim', `${this.footerHint()}   ${range}`),
+                width,
+            ),
+        );
+
+        return out;
+    }
+
+    handleInput(data: string): void {
+        if (
+            matchesKey(data, Key.escape) ||
+            matchesKey(data, Key.ctrl('c')) ||
+            data === 'q'
+        ) {
+            this.onClose();
+            return;
+        }
+        if (matchesKey(data, Key.tab)) {
+            this.switchMode();
+            return;
+        }
+        if (matchesKey(data, Key.up)) {
+            this.scroll(-1);
+            return;
+        }
+        if (matchesKey(data, Key.down)) {
+            this.scroll(1);
+            return;
+        }
+        if (matchesKey(data, Key.pageUp)) {
+            this.scroll(-this.viewportHeight);
+            return;
+        }
+        if (matchesKey(data, Key.pageDown)) {
+            this.scroll(this.viewportHeight);
+            return;
+        }
+        if (this.mode === 'turns' && data === '[') {
+            this.stepTurn(-1);
+            return;
+        }
+        if (this.mode === 'turns' && data === ']') {
+            this.stepTurn(1);
+            return;
+        }
+        if (data === 'n') {
+            this.goToSection(1);
+            return;
+        }
+        if (data === 'p') {
+            this.goToSection(-1);
+            return;
+        }
+        if (data === 'g') {
+            this.goTo(0);
+            return;
+        }
+        if (data === 'G') {
+            this.goTo(this.lines.length);
+        }
+    }
+
+    invalidate(): void {
+        this.rebuild();
+    }
+}