@agnishc/edb-diff-files 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## [Unreleased]
+
+### Added
+- Initial release: session-scoped file change tracker via write/edit tool events and bash diff snapshots
+- Live widget with flash notification on new files per turn
+- Footer status bar with created/edited/deleted counts
+- `/diff-files` command with full-screen list + inline diff viewer
+- Filter by change type, open in editor support
+- Configurable via env vars and `~/.pi/settings.json`

package/LICENSE

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

@@ -0,0 +1,46 @@
+# @agnishc/edb-diff-files
+
+A Pi CLI extension that tracks every file the agent touches during a session and shows them in a live widget above the editor. Opens a full-screen diff viewer on demand.
+
+## Features
+
+- **Live widget** — updates above the editor after every turn showing `+ created`, `~ edited`, `- deleted` files
+- **Flash notification** — briefly highlights newly added files at the end of each turn
+- **Footer status** — compact `D(+N ~N -N)` indicator always visible
+- **Inline diff viewer** — press Enter on any file to see a syntax-coloured unified diff
+- **Filter by type** — cycle through all / created / edited / deleted with `f`
+- **Open in editor** — press `o` to open the file in your configured GUI editor
+
+## Install
+
+```bash
+pi install npm:@agnishc/edb-diff-files
+```
+
+## Usage
+
+```
+/diff-files
+```
+
+| Key | Action |
+|-----|--------|
+| `j`/`k` or `↑`/`↓` | Navigate file list |
+| `Enter` | Open inline diff for selected file |
+| `o` | Open file in GUI editor |
+| `f` | Cycle filter: all → created → edited → deleted |
+| `Esc` | Close / back to list |
+
+## Configuration
+
+Set via environment variables or `~/.pi/settings.json`:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `FILES_WIDGET_MAX_LINES` | `8` | Max files shown in widget |
+| `FILES_WIDGET_SHOW_HEADER` | `true` | Show "N files changed" header |
+| `FILES_WIDGET_INCLUDE_DELETED` | `false` | Include deleted files in widget |
+
+## License
+
+[MIT](LICENSE) © Agnish Chakraborty

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@agnishc/edb-diff-files",
+	"version": "0.1.0",
+	"description": "Pi extension: live widget tracking files changed this session with an inline diff viewer",
+	"keywords": ["pi-package", "pi-extension", "edb", "git"],
+	"type": "module",
+	"license": "MIT",
+	"author": "Agnish Chakraborty",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/agnishcc/pi-extention-monorepo.git",
+		"directory": "packages/edb-diff-files"
+	},
+	"homepage": "https://github.com/agnishcc/pi-extention-monorepo/tree/main/packages/edb-diff-files#readme",
+	"bugs": { "url": "https://github.com/agnishcc/pi-extention-monorepo/issues" },
+	"publishConfig": { "access": "public" },
+	"scripts": { "test": "vitest run" },
+	"files": ["src", "README.md", "LICENSE", "CHANGELOG.md"],
+	"pi": {
+		"extensions": ["./src/index.ts"]
+	},
+	"peerDependencies": {
+		"@mariozechner/pi-coding-agent": "*",
+		"@mariozechner/pi-tui": "*"
+	}
+}

package/src/config.ts

@@ -0,0 +1,82 @@
+import { existsSync, readFileSync } from "node:fs";
+import type { Colors, WidgetConfig } from "./types";
+
+// ---------------------------------------------------------------------------
+// Widget config — env → settings.json → defaults
+// ---------------------------------------------------------------------------
+
+const DEFAULTS: WidgetConfig = {
+	maxLines: 8,
+	showHeader: true,
+	includeDeleted: false,
+	cwd: process.cwd(),
+};
+
+function envInt(name: string, fallback: number): number {
+	const v = Number.parseInt(process.env[name] ?? "", 10);
+	return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+
+function envBool(name: string, fallback: boolean): boolean {
+	const v = process.env[name]?.toLowerCase();
+	if (v === "true" || v === "1") return true;
+	if (v === "false" || v === "0") return false;
+	return fallback;
+}
+
+export function loadConfig(): WidgetConfig {
+	let maxLines = envInt("FILES_WIDGET_MAX_LINES", DEFAULTS.maxLines);
+	let showHeader = envBool("FILES_WIDGET_SHOW_HEADER", DEFAULTS.showHeader);
+	let includeDeleted = envBool("FILES_WIDGET_INCLUDE_DELETED", DEFAULTS.includeDeleted);
+
+	const paths = [`${process.cwd()}/.pi/settings.json`, `${process.env.HOME ?? ""}/.pi/settings.json`];
+	for (const p of paths) {
+		try {
+			if (existsSync(p)) {
+				const raw = JSON.parse(readFileSync(p, "utf-8"));
+				if (raw.filesWidgetMaxLines != null) maxLines = raw.filesWidgetMaxLines;
+				if (raw.filesWidgetShowHeader != null) showHeader = raw.filesWidgetShowHeader;
+				if (raw.filesWidgetIncludeDeleted != null) includeDeleted = raw.filesWidgetIncludeDeleted;
+			}
+		} catch {
+			/* skip invalid */
+		}
+	}
+
+	return { maxLines, showHeader, includeDeleted, cwd: process.cwd() };
+}
+
+// ---------------------------------------------------------------------------
+// Colors — theme → fallbacks
+// ---------------------------------------------------------------------------
+
+const FG_GREEN = "\x1b[38;2;100;180;120m";
+const FG_YELLOW = "\x1b[38;2;200;180;80m";
+const FG_RED = "\x1b[38;2;200;100;100m";
+const FG_MUTED = "\x1b[38;2;139;148;158m";
+const FG_DIM = "\x1b[38;2;80;80;80m";
+const RST = "\x1b[0m";
+
+export function resolveColors(theme?: any): Colors {
+	let fgCreated = FG_GREEN;
+	let fgEdited = FG_YELLOW;
+	let fgDeleted = FG_RED;
+	let fgHeader = FG_MUTED;
+	let fgMuted = FG_MUTED;
+	let fgDim = FG_DIM;
+
+	if (theme?.getFgAnsi) {
+		try {
+			fgCreated = theme.getFgAnsi("toolDiffAdded") || FG_GREEN;
+			fgEdited = theme.getFgAnsi("warning") || theme.getFgAnsi("accent") || FG_YELLOW;
+			fgDeleted = theme.getFgAnsi("toolDiffRemoved") || FG_RED;
+			fgHeader = theme.getFgAnsi("muted") || FG_MUTED;
+			fgMuted = theme.getFgAnsi("muted") || FG_MUTED;
+			fgDim = theme.getFgAnsi("dim") || FG_DIM;
+		} catch {
+			/* use fallbacks */
+		}
+	}
+
+	return { fgCreated, fgEdited, fgDeleted, fgHeader, fgMuted, fgDim, rst: RST };
+}

package/src/git.ts

@@ -0,0 +1,120 @@
+import { execSync, spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { ChangeType, type FileEntry, type GitDiffSnapshot } from "./types";
+
+/**
+ * Check if cwd is inside a git repository.
+ */
+export function isGitRepo(cwd: string): boolean {
+	try {
+		execSync("git rev-parse --is-inside-work-tree", {
+			cwd,
+			stdio: "pipe",
+			timeout: 5000,
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Parse `git diff --name-status HEAD` output into a map.
+ *
+ * Status codes:
+ *   A = Added (Created)
+ *   M = Modified (Edited)
+ *   D = Deleted
+ *   R = Renamed (treated as Added for the destination)
+ *   C = Copied (treated as Added for the destination)
+ *   T = Type change (treated as Edited)
+ */
+export function getGitDiff(cwd: string): GitDiffSnapshot {
+	const snapshot: GitDiffSnapshot = new Map();
+
+	try {
+		const output = execSync("git diff --name-status HEAD", {
+			cwd,
+			stdio: "pipe",
+			timeout: 10000,
+			encoding: "utf-8",
+		});
+
+		for (const line of output.trim().split("\n")) {
+			if (!line.trim()) continue;
+
+			// Format: "STATUS\tpath" or "R100\told\tnew"
+			const parts = line.split("\t");
+			const status = parts[0]?.trim();
+			const path = parts.length >= 3 ? parts[2] : parts[1]; // rename: R100\told\tnew
+
+			if (!status || !path) continue;
+
+			// Resolve absolute path
+			const absPath = resolve(cwd, path);
+
+			let changeType: ChangeType;
+			switch (status[0]) {
+				case "A":
+				case "R": // rename destination = new file
+				case "C": // copy destination = new file
+					changeType = ChangeType.Created;
+					break;
+				case "D":
+					changeType = ChangeType.Deleted;
+					break;
+				default:
+					changeType = ChangeType.Edited;
+					break;
+			}
+
+			snapshot.set(absPath, changeType);
+		}
+	} catch {
+		// git diff failed (e.g., no HEAD yet, or not a git repo)
+		// Return empty snapshot — silent no-op
+	}
+
+	return snapshot;
+}
+
+/**
+ * Get the unified diff for a single tracked file.
+ *
+ * - Created  → git diff --no-index /dev/null <file>  (always exits 1 when files differ)
+ * - Edited   → git diff HEAD -- <file>
+ * - Deleted  → git diff HEAD -- <file>  (shows removal)
+ *
+ * Returns an array of raw diff lines (caller handles colorisation).
+ */
+export function getFileDiff(cwd: string, entry: FileEntry): string[] {
+	try {
+		if (entry.changeType === ChangeType.Created) {
+			// New file — diff against /dev/null for proper unified-diff format.
+			// git exits with code 1 when files differ (the normal case), so spawnSync
+			// is used to avoid an exception on non-zero exit.
+			const r = spawnSync("git", ["diff", "--no-index", "/dev/null", entry.path], {
+				cwd,
+				encoding: "utf-8",
+				timeout: 10_000,
+			});
+			if (r.stdout?.trim()) return r.stdout.split("\n");
+
+			// Fallback: render raw file content as additions
+			const content = readFileSync(entry.path, "utf-8");
+			return [`--- /dev/null`, `+++ b/${entry.relPath}`, ...content.split("\n").map((l) => `+${l}`)];
+		}
+
+		// Edited or Deleted — git diff HEAD shows both staged and unstaged changes
+		const r = spawnSync("git", ["diff", "HEAD", "--", entry.path], {
+			cwd,
+			encoding: "utf-8",
+			timeout: 10_000,
+		});
+		if (r.stdout?.trim()) return r.stdout.split("\n");
+		return ["(no changes detected vs HEAD)"];
+	} catch {
+		return ["(error computing diff)"];
+	}
+}

package/src/index.ts

@@ -0,0 +1,524 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { basename, relative, resolve } from "node:path";
+import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+import { loadConfig, resolveColors } from "./config";
+import { getFileDiff, getGitDiff, isGitRepo } from "./git";
+import { renderWidget } from "./renderer";
+import { FileTracker } from "./tracker";
+import type { FileEntry, GitDiffSnapshot } from "./types";
+import { ChangeType } from "./types";
+
+const WIDGET_KEY = "pi-diff-files";
+const STATUS_KEY = "pi-diff-files";
+
+// Filter modes cycle: all → created → edited → deleted → all
+type FilterMode = "all" | "created" | "edited" | "deleted";
+const FILTER_CYCLE: FilterMode[] = ["all", "created", "edited", "deleted"];
+const FILTER_LABEL: Record<FilterMode, string> = {
+	all: "all",
+	created: "+created",
+	edited: "~edited",
+	deleted: "-deleted",
+};
+
+// ─── Open a file in the best available GUI editor ───────────────────────────
+
+function openInEditor(filePath: string): string {
+	const candidates = ["nvim", "cursor", "code", "subl", "zed", "atom"];
+
+	// Prefer $VISUAL / $EDITOR if they reference a known GUI editor
+	const configured = (process.env.VISUAL ?? process.env.EDITOR ?? "").split(" ")[0];
+	if (configured) {
+		const base = basename(configured);
+		if (candidates.some((e) => base.includes(e))) {
+			spawn(configured, [filePath], { detached: true, stdio: "ignore" }).unref();
+			return `Opened in ${base}`;
+		}
+	}
+
+	for (const editor of candidates) {
+		const w = spawnSync("which", [editor], { encoding: "utf-8", stdio: "pipe" });
+		if (w.status === 0) {
+			spawn(editor, [filePath], { detached: true, stdio: "ignore" }).unref();
+			return `Opened in ${editor}`;
+		}
+	}
+
+	// Platform fallback
+	const opener = process.platform === "darwin" ? "open" : "xdg-open";
+	spawn(opener, [filePath], { detached: true, stdio: "ignore" }).unref();
+	return "Opened in default app";
+}
+
+// ─── Interactive /diff-files viewer ──────────────────────────────────────────
+
+class FilesViewComponent {
+	private mode: "list" | "diff" = "list";
+	private cursor = 0;
+	private diffScroll = 0;
+	private filterMode: FilterMode = "all";
+	private statusMsg = "";
+	private cachedWidth?: number;
+	private cachedLines?: string[];
+
+	constructor(
+		private readonly entries: ReadonlyArray<FileEntry>,
+		private readonly diffs: Map<string, string[]>,
+		private readonly theme: any,
+		private readonly onClose: () => void,
+	) {}
+
+	// ── Keyboard handling ──────────────────────────────────────────────────────
+
+	handleInput(data: string): void {
+		if (this.mode === "list") {
+			this.handleListInput(data);
+		} else {
+			this.handleDiffInput(data);
+		}
+	}
+
+	private handleListInput(data: string): void {
+		const n = this.entries.length;
+		if (matchesKey(data, "j") || matchesKey(data, "down")) {
+			this.cursor = n > 0 ? Math.min(this.cursor + 1, n - 1) : 0;
+			this.invalidate();
+		} else if (matchesKey(data, "k") || matchesKey(data, "up")) {
+			this.cursor = Math.max(0, this.cursor - 1);
+			this.invalidate();
+		} else if (matchesKey(data, "return")) {
+			if (this.entries[this.cursor]) {
+				this.mode = "diff";
+				this.diffScroll = 0;
+				this.invalidate();
+			}
+		} else if (matchesKey(data, "o")) {
+			const entry = this.entries[this.cursor];
+			if (entry) {
+				this.statusMsg = openInEditor(entry.path);
+				this.invalidate();
+			}
+		} else if (matchesKey(data, "f")) {
+			const idx = FILTER_CYCLE.indexOf(this.filterMode);
+			this.filterMode = FILTER_CYCLE[(idx + 1) % FILTER_CYCLE.length]!;
+			this.cursor = 0;
+			this.invalidate();
+		} else if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+			this.onClose();
+		}
+	}
+
+	private handleDiffInput(data: string): void {
+		const viewH = this.viewportHeight();
+		const maxScroll = Math.max(0, this.currentDiffLines().length - viewH);
+
+		if (matchesKey(data, "j") || matchesKey(data, "down")) {
+			this.diffScroll = Math.min(this.diffScroll + 1, maxScroll);
+			this.invalidate();
+		} else if (matchesKey(data, "k") || matchesKey(data, "up")) {
+			this.diffScroll = Math.max(0, this.diffScroll - 1);
+			this.invalidate();
+		} else if (matchesKey(data, "ctrl+d")) {
+			this.diffScroll = Math.min(this.diffScroll + Math.floor(viewH / 2), maxScroll);
+			this.invalidate();
+		} else if (matchesKey(data, "ctrl+u")) {
+			this.diffScroll = Math.max(0, this.diffScroll - Math.floor(viewH / 2));
+			this.invalidate();
+		} else if (matchesKey(data, "o")) {
+			const entry = this.entries[this.cursor];
+			if (entry) {
+				this.statusMsg = openInEditor(entry.path);
+				this.invalidate();
+			}
+		} else if (matchesKey(data, "escape") || matchesKey(data, "q")) {
+			this.mode = "list";
+			this.statusMsg = "";
+			this.invalidate();
+		}
+	}
+
+	private filteredEntries(): ReadonlyArray<FileEntry> {
+		if (this.filterMode === "all") return this.entries;
+		const target =
+			this.filterMode === "created"
+				? ChangeType.Created
+				: this.filterMode === "edited"
+					? ChangeType.Edited
+					: ChangeType.Deleted;
+		return this.entries.filter((e) => e.changeType === target);
+	}
+
+	// ── Rendering ──────────────────────────────────────────────────────────────
+
+	render(width: number): string[] {
+		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+		const lines = this.mode === "list" ? this.renderList(width) : this.renderDiff(width);
+		this.cachedWidth = width;
+		this.cachedLines = lines;
+		return lines;
+	}
+
+	private renderList(width: number): string[] {
+		const { entries, theme: th } = this;
+		const visible = this.filteredEntries();
+		// Clamp cursor to visible range
+		const cursor = Math.min(this.cursor, Math.max(0, visible.length - 1));
+		const lines: string[] = [];
+
+		// ── Header with filter indicator ──
+		lines.push("");
+		const filterTag = this.filterMode !== "all" ? th.fg("dim", `  ·${FILTER_LABEL[this.filterMode]}·`) : "";
+		const countStr = this.filterMode === "all" ? `${entries.length}` : `${visible.length}/${entries.length}`;
+		const title = ` Changed Files (${countStr}) `;
+		const sideLen = Math.max(
+			0,
+			width - title.length - 3 - (this.filterMode !== "all" ? FILTER_LABEL[this.filterMode].length + 4 : 0),
+		);
+		lines.push(
+			truncateToWidth(
+				th.fg("borderMuted", "─".repeat(3)) +
+					th.fg("accent", title) +
+					filterTag +
+					th.fg("borderMuted", "─".repeat(Math.max(0, sideLen))),
+				width,
+			),
+		);
+		lines.push("");
+
+		if (visible.length === 0) {
+			const msg = entries.length === 0 ? "No files changed yet." : `No ${this.filterMode} files.`;
+			lines.push(truncateToWidth(`  ${th.fg("dim", msg)}`, width));
+		} else {
+			for (let i = 0; i < visible.length; i++) {
+				const e = visible[i]!;
+				const selected = i === cursor;
+				const symColor =
+					e.changeType === ChangeType.Created
+						? "toolDiffAdded"
+						: e.changeType === ChangeType.Edited
+							? "warning"
+							: "toolDiffRemoved";
+				const sym = e.changeType === ChangeType.Created ? "+" : e.changeType === ChangeType.Edited ? "~" : "-";
+				const arrow = selected ? th.fg("accent", "▶") : " ";
+				const nameColor = selected ? "toolTitle" : "muted";
+
+				lines.push(truncateToWidth(` ${arrow} ${th.fg(symColor, sym)} ${th.fg(nameColor, e.relPath)}`, width));
+			}
+		}
+
+		lines.push("");
+		lines.push(truncateToWidth(th.fg("borderMuted", "─".repeat(width)), width));
+		if (this.statusMsg) {
+			lines.push(truncateToWidth(`  ${th.fg("success", this.statusMsg)}`, width));
+		}
+		lines.push(
+			truncateToWidth(
+				`  ${th.fg("dim", "j/k  navigate    Enter  diff    o  open    f  filter    Esc  close")}`,
+				width,
+			),
+		);
+		lines.push("");
+		return lines;
+	}
+
+	private renderDiff(width: number): string[] {
+		const { theme: th, cursor, diffScroll } = this;
+		const entry = this.entries[cursor];
+		const lines: string[] = [];
+
+		if (!entry) return lines;
+
+		const rawDiff = this.currentDiffLines();
+		const viewH = this.viewportHeight();
+		const maxScroll = Math.max(0, rawDiff.length - viewH);
+		const scroll = Math.min(diffScroll, maxScroll);
+
+		// ── Header ──
+		lines.push("");
+		const symColor =
+			entry.changeType === ChangeType.Created
+				? "toolDiffAdded"
+				: entry.changeType === ChangeType.Edited
+					? "warning"
+					: "toolDiffRemoved";
+		const sym = entry.changeType === ChangeType.Created ? "+" : entry.changeType === ChangeType.Edited ? "~" : "-";
+		const title = ` ${sym} ${entry.relPath} `;
+		const sideLen = Math.max(0, width - title.length - 3);
+		lines.push(
+			truncateToWidth(
+				th.fg("borderMuted", "─".repeat(3)) + th.fg(symColor, title) + th.fg("borderMuted", "─".repeat(sideLen)),
+				width,
+			),
+		);
+		lines.push("");
+
+		// ── Diff body ──
+		if (rawDiff.length === 1 && rawDiff[0]?.startsWith("(")) {
+			lines.push(truncateToWidth(`  ${th.fg("dim", rawDiff[0])}`, width));
+		} else {
+			if (scroll > 0) {
+				lines.push(truncateToWidth(`  ${th.fg("muted", `↑ ${scroll} lines above`)}`, width));
+			}
+			for (const raw of rawDiff.slice(scroll, scroll + viewH)) {
+				lines.push(truncateToWidth(this.colourDiffLine(raw), width));
+			}
+			const below = rawDiff.length - scroll - viewH;
+			if (below > 0) {
+				lines.push(truncateToWidth(`  ${th.fg("muted", `↓ ${below} lines below`)}`, width));
+			}
+		}
+
+		// ── Footer ──
+		lines.push("");
+		lines.push(truncateToWidth(th.fg("borderMuted", "─".repeat(width)), width));
+		if (this.statusMsg) {
+			lines.push(truncateToWidth(`  ${th.fg("success", this.statusMsg)}`, width));
+		}
+		lines.push(
+			truncateToWidth(
+				`  ${th.fg("dim", "j/k  scroll    Ctrl+D/U  half-page    o  open in editor    Esc  back to list")}`,
+				width,
+			),
+		);
+		lines.push("");
+		return lines;
+	}
+
+	private colourDiffLine(raw: string): string {
+		const th = this.theme;
+		if (raw.startsWith("+++") || raw.startsWith("---")) return `  ${th.fg("dim", raw)}`;
+		if (raw.startsWith("@@")) return `  ${th.fg("accent", raw)}`;
+		if (raw.startsWith("+")) return `  ${th.fg("toolDiffAdded", raw)}`;
+		if (raw.startsWith("-")) return `  ${th.fg("toolDiffRemoved", raw)}`;
+		if (/^(diff |index |new file|deleted|Binary)/.test(raw)) return `  ${th.fg("dim", raw)}`;
+		return `  ${th.fg("dim", raw)}`;
+	}
+
+	// ── Helpers ────────────────────────────────────────────────────────────────
+
+	private currentDiffLines(): string[] {
+		const entry = this.entries[this.cursor];
+		if (!entry) return [];
+		return this.diffs.get(entry.path) ?? ["(no diff available)"];
+	}
+
+	private viewportHeight(): number {
+		// Terminal rows minus header (≈5) and footer (≈4) lines
+		return Math.max(5, (process.stdout.rows ?? 40) - 9);
+	}
+
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+}
+
+// ─── Extension ───────────────────────────────────────────────────────────────
+
+export default function diffFilesExtension(pi: any): void {
+	const config = loadConfig();
+	const tracker = new FileTracker();
+
+	// Bash snapshots: toolCallId → git diff snapshot taken before bash ran
+	const bashSnapshots = new Map<string, GitDiffSnapshot>();
+
+	const inGit = isGitRepo(config.cwd);
+
+	function updateWidget(ctx: any, theme?: any): void {
+		const colors = resolveColors(theme);
+
+		// Resolve change types from current git state
+		if (inGit) {
+			const currentDiff = getGitDiff(config.cwd);
+			tracker.resolveFromGitDiff(currentDiff);
+		}
+
+		const lines = renderWidget(tracker.getEntries(), colors, config);
+		if (lines.length > 0) {
+			ctx.ui.setWidget(WIDGET_KEY, lines, { placement: "aboveEditor" });
+		} else {
+			ctx.ui.setWidget(WIDGET_KEY, undefined);
+		}
+
+		// ── Footer status ──────────────────────────────────────────────────
+		const entries = tracker.getEntries();
+		const uiTheme = ctx.ui?.theme;
+		if (entries.length === 0 || !uiTheme?.fg) {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+		} else {
+			const created = entries.filter((e) => e.changeType === ChangeType.Created).length;
+			const edited = entries.filter((e) => e.changeType === ChangeType.Edited).length;
+			const deleted = entries.filter((e) => e.changeType === ChangeType.Deleted).length;
+			const inner: string[] = [];
+			if (created > 0) inner.push(uiTheme.fg("toolDiffAdded", `+${created}`));
+			if (edited > 0) inner.push(uiTheme.fg("warning", `~${edited}`));
+			if (deleted > 0) inner.push(uiTheme.fg("toolDiffRemoved", `-${deleted}`));
+			const status = uiTheme.fg("muted", "D(") + inner.join(uiTheme.fg("dim", "  ")) + uiTheme.fg("muted", ")");
+			ctx.ui.setStatus(STATUS_KEY, status);
+		}
+	}
+
+	// ── write/edit tool_call ──────────────────────────────────────────────
+	// Record file paths the agent is about to touch
+	pi.on("tool_call", async (event: any, _ctx: any) => {
+		if (event.toolName === "write" || event.toolName === "edit") {
+			const fp = event.input?.path ?? event.input?.file_path ?? "";
+			if (!fp) return;
+
+			const absPath = resolve(config.cwd, fp);
+			const relPath = relative(config.cwd, absPath) || absPath;
+			let changeType: ChangeType;
+
+			if (event.toolName === "edit") {
+				changeType = ChangeType.Edited;
+			} else {
+				changeType = existsSync(absPath) ? ChangeType.Edited : ChangeType.Created;
+			}
+
+			tracker.add(absPath, relPath, changeType);
+			return;
+		}
+
+		// ── bash tool_call ────────────────────────────────────────────────
+		// Snapshot git state before the bash command runs
+		if (event.toolName === "bash" && inGit) {
+			const snapshot = getGitDiff(config.cwd);
+			bashSnapshots.set(event.toolCallId, snapshot);
+		}
+	});
+
+	// ── bash tool_result ────────────────────────────────────────────────
+	// Diff current state vs snapshot to find new changes
+	pi.on("tool_result", async (event: any, _ctx: any) => {
+		if (event.toolName !== "bash") return;
+		if (event.isError) return;
+
+		const before = bashSnapshots.get(event.toolCallId);
+		bashSnapshots.delete(event.toolCallId);
+		if (!before) return;
+
+		const after = getGitDiff(config.cwd);
+
+		// Find entries in after that are new or changed compared to before
+		const newEntries: GitDiffSnapshot = new Map();
+		for (const [path, changeType] of after) {
+			if (!before.has(path)) {
+				// New entry — file wasn't in the before snapshot
+				newEntries.set(path, changeType);
+			} else if (before.get(path) !== changeType) {
+				// Changed type (e.g., was M, now A because the file was deleted and recreated)
+				newEntries.set(path, changeType);
+			}
+		}
+
+		if (newEntries.size > 0) {
+			tracker.mergeBashDiff(newEntries, config.cwd);
+		}
+	});
+
+	// ── Flash state ─────────────────────────────────────────────────────
+	let sizeAtTurnStart = 0;
+	let flashTimer: ReturnType<typeof setTimeout> | null = null;
+
+	function renderFlashWidget(ctx: any, theme: any, addedCount: number): void {
+		const colors = resolveColors(theme);
+		const entries = tracker.getEntries();
+		const visible = config.includeDeleted
+			? entries
+			: entries.filter((e: FileEntry) => e.changeType !== ChangeType.Deleted);
+
+		const lines: string[] = [];
+		// Flash header — briefly shows how many files changed this turn
+		lines.push(
+			`${colors.fgCreated}↯ ${addedCount} ${addedCount === 1 ? "file" : "files"} added this turn${colors.rst}`,
+		);
+		// Entries up to maxLines − 1 (the flash line takes one slot)
+		const shown = visible.slice(0, Math.max(1, config.maxLines - 1));
+		for (const e of shown) {
+			const prefix =
+				e.changeType === ChangeType.Created
+					? `${colors.fgCreated}+${colors.rst}`
+					: e.changeType === ChangeType.Edited
+						? `${colors.fgEdited}~${colors.rst}`
+						: `${colors.fgDeleted}-${colors.rst}`;
+			lines.push(` ${prefix} ${colors.fgDim}${e.relPath}${colors.rst}`);
+		}
+		const remaining = visible.length - shown.length;
+		if (remaining > 0) {
+			lines.push(`${colors.fgMuted}  … ${remaining} more${colors.rst}`);
+		}
+		ctx.ui.setWidget(WIDGET_KEY, lines, { placement: "aboveEditor" });
+	}
+
+	// ── turn_start ────────────────────────────────────────────────────────
+	pi.on("turn_start", async (_event: any, _ctx: any) => {
+		sizeAtTurnStart = tracker.size;
+	});
+
+	// ── turn_end ────────────────────────────────────────────────────────
+	// Flash widget briefly when new files appear, then settle to normal.
+	pi.on("turn_end", async (_event: any, ctx: any) => {
+		if (tracker.size === 0) return;
+
+		if (flashTimer) {
+			clearTimeout(flashTimer);
+			flashTimer = null;
+		}
+
+		const addedThisTurn = tracker.size - sizeAtTurnStart;
+
+		if (addedThisTurn > 0) {
+			renderFlashWidget(ctx, ctx?.theme, addedThisTurn);
+			flashTimer = setTimeout(() => {
+				flashTimer = null;
+				updateWidget(ctx, ctx?.theme);
+			}, 1200);
+		} else {
+			updateWidget(ctx, ctx?.theme);
+		}
+	});
+
+	// ── session_start ───────────────────────────────────────────────────
+	// Reset state for new sessions
+	pi.on("session_start", async (_event: any, ctx: any) => {
+		tracker.clear();
+		bashSnapshots.clear();
+		ctx.ui.setWidget(WIDGET_KEY, undefined);
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+	});
+
+	// ── /diff-files command ─────────────────────────────────────────────────
+	pi.registerCommand("diff-files", {
+		description: "Show all files changed in this session with inline diff viewer",
+		handler: async (_args: any, ctx: any) => {
+			const entries = tracker.getEntries();
+
+			if (!ctx.hasUI) {
+				if (entries.length === 0) {
+					ctx.ui.notify("No files changed yet.", "info");
+					return;
+				}
+				const lines = entries.map((e: FileEntry) => {
+					const prefix =
+						e.changeType === ChangeType.Created ? "+" : e.changeType === ChangeType.Edited ? "~" : "-";
+					return `${prefix} ${e.relPath}`;
+				});
+				ctx.ui.notify(lines.join("\n"), "info");
+				return;
+			}
+
+			// Pre-compute diffs for every tracked file before opening the panel.
+			const diffs = new Map<string, string[]>();
+			if (inGit) {
+				for (const entry of entries) {
+					diffs.set(entry.path, getFileDiff(config.cwd, entry));
+				}
+			}
+
+			await ctx.ui.custom((_tui: any, theme: any, _kb: any, done: () => void) => {
+				return new FilesViewComponent(entries, diffs, theme, () => done());
+			});
+		},
+	});
+}

package/src/renderer.ts

@@ -0,0 +1,51 @@
+import { ChangeType, type Colors, type FileEntry, type WidgetConfig } from "./types";
+
+/**
+ * Render file entries into widget lines.
+ *
+ * Format:
+ *   N files changed
+ *   + src/new-file.ts
+ *   ~ src/existing.ts
+ *   - src/removed.ts
+ *   … 3 more
+ */
+export function renderWidget(entries: ReadonlyArray<FileEntry>, colors: Colors, config: WidgetConfig): string[] {
+	if (entries.length === 0) return [];
+
+	// Filter deleted if not included
+	const visible = config.includeDeleted ? entries : entries.filter((e) => e.changeType !== ChangeType.Deleted);
+
+	if (visible.length === 0) return [];
+
+	const lines: string[] = [];
+
+	if (config.showHeader) {
+		const label = visible.length === 1 ? "1 file changed" : `${visible.length} files changed`;
+		lines.push(`${colors.fgHeader}${label}${colors.rst}`);
+	}
+
+	const shown = visible.slice(0, config.maxLines);
+	for (const entry of shown) {
+		let prefix: string;
+		switch (entry.changeType) {
+			case ChangeType.Created:
+				prefix = `${colors.fgCreated}+${colors.rst}`;
+				break;
+			case ChangeType.Edited:
+				prefix = `${colors.fgEdited}~${colors.rst}`;
+				break;
+			case ChangeType.Deleted:
+				prefix = `${colors.fgDeleted}-${colors.rst}`;
+				break;
+		}
+		lines.push(` ${prefix} ${colors.fgDim}${entry.relPath}${colors.rst}`);
+	}
+
+	const remaining = visible.length - config.maxLines;
+	if (remaining > 0) {
+		lines.push(`${colors.fgMuted}  … ${remaining} more${colors.rst}`);
+	}
+
+	return lines;
+}

package/src/tracker.ts

@@ -0,0 +1,76 @@
+import { ChangeType, type FileEntry, type GitDiffSnapshot } from "./types";
+
+/**
+ * Session-scoped file change tracker.
+ *
+ * Two sources of attribution:
+ *   1. write/edit tool events — direct, high confidence
+ *   2. bash tool events — via git diff before/after snapshot
+ *
+ * Change type is resolved via git diff at render time.
+ * The tracker stores attribution (which files the agent touched),
+ * not the final A/M/D status.
+ */
+export class FileTracker {
+	/** Tracks files the agent touched — key is absolute path */
+	private entries = new Map<string, FileEntry>();
+
+	/**
+	 * Record a file that the agent touched via write/edit.
+	 * If already tracked, keeps existing entry (insertion order preserved).
+	 * Created wins over Edited (never downgrade).
+	 */
+	add(path: string, relPath: string, changeType: ChangeType): void {
+		const existing = this.entries.get(path);
+		if (existing) {
+			if (existing.changeType === ChangeType.Created) return;
+			if (changeType === ChangeType.Edited) return;
+			// Upgrade Edited → Created
+			existing.changeType = ChangeType.Created;
+			return;
+		}
+
+		this.entries.set(path, { path, relPath, changeType });
+	}
+
+	/**
+	 * Merge bash diff entries into the tracker.
+	 * Only adds files that aren't already tracked (write/edit are more reliable).
+	 */
+	mergeBashDiff(diff: GitDiffSnapshot, cwd: string): void {
+		const { relative } = require("node:path");
+		for (const [path, changeType] of diff) {
+			if (this.entries.has(path)) continue;
+			const relPath = relative(cwd, path) || path;
+			this.entries.set(path, { path, relPath, changeType });
+		}
+	}
+
+	/**
+	 * Resolve change types from git diff.
+	 * Takes the current git diff output and updates tracked entries
+	 * to match actual A/M/D status.
+	 */
+	resolveFromGitDiff(gitDiff: GitDiffSnapshot): void {
+		for (const [path, entry] of this.entries) {
+			const gitType = gitDiff.get(path);
+			if (gitType !== undefined) {
+				entry.changeType = gitType;
+			}
+			// If file not in git diff, keep existing type
+			// (e.g., edited then reverted — still shows as tracked)
+		}
+	}
+
+	getEntries(): ReadonlyArray<FileEntry> {
+		return Array.from(this.entries.values());
+	}
+
+	clear(): void {
+		this.entries.clear();
+	}
+
+	get size(): number {
+		return this.entries.size;
+	}
+}

package/src/types.ts

@@ -0,0 +1,31 @@
+export enum ChangeType {
+	Created = "created",
+	Edited = "edited",
+	Deleted = "deleted",
+}
+
+export interface FileEntry {
+	path: string; // absolute path
+	relPath: string; // relative to cwd
+	changeType: ChangeType;
+}
+
+export interface Colors {
+	fgCreated: string;
+	fgEdited: string;
+	fgDeleted: string;
+	fgHeader: string;
+	fgMuted: string;
+	fgDim: string;
+	rst: string;
+}
+
+export interface WidgetConfig {
+	maxLines: number;
+	showHeader: boolean;
+	includeDeleted: boolean;
+	cwd: string;
+}
+
+/** Snapshot of git diff --name-status output */
+export type GitDiffSnapshot = Map<string, ChangeType>;