osdy-pi 0.1.7 → 0.1.9

package/README.md

@@ -76,6 +76,13 @@ Osdy Pi includes a small command group:
 /osdy-pi disable
 /osdy-pi status
 /osdy-pi sound setup
+/osdy-pi working-tree on
+/osdy-pi working-tree off
+/osdy-pi working-tree toggle
+/osdy-pi working-tree status
+/osdy-pi working-tree position top
+/osdy-pi working-tree position bottom
+/osdy-pi diff
 /osdy-pi osdy-theme
 /osdy-pi classic
 /osdy-pi-osdy-theme
@@ -86,12 +93,51 @@ Osdy Pi includes a small command group:
 - `disable` restores Pi's built-in header, editor, footer, and working visibility, then switches back to the previous theme or `dark`.
 - `status` shows whether the Osdy Pi UI is currently enabled, including the active style.
 - `sound setup` opens the guided global sound-setup wizard for audio notifications.
+- `working-tree on|off|toggle|status` controls the persistent git working-tree summary widget.
+- `working-tree position top|bottom` moves the summary widget above or below the editor.
+- `diff` opens a floating centered diff window to inspect the current per-file diff without leaving Pi.
 - `osdy-theme` is the default OsdyTheme header with pink, cyan, and purple styling, plus the mascot glow on the right edge.
 - `classic` keeps the previous classic header shape with the shared mascot.
 - `/osdy-pi-osdy-theme` and `/osdy-pi-classic` are direct aliases.
 
 After changing a local extension, run `/reload` or restart Pi so the updated commands are registered.
 
+### Working tree widget
+
+Osdy Pi can show a persistent git working-tree summary above or below the editor.
+
+Current behavior:
+
+- shows file count, `+/-` totals, and staged/unstaged/new counts;
+- previews the top changed files;
+- refreshes automatically when Pi finishes mutating tools such as `edit`, `write`, `ast_grep_replace`, or `bash`;
+- is intentionally scoped to changes observed during Pi-driven work for now.
+
+Use these commands to control it:
+
+```text
+/osdy-pi working-tree on
+/osdy-pi working-tree off
+/osdy-pi working-tree toggle
+/osdy-pi working-tree status
+/osdy-pi working-tree position top
+/osdy-pi working-tree position bottom
+/osdy-pi diff
+```
+
+The `/osdy-pi diff` viewer now opens in the most viable floating-window form for Osdy Pi: a centered floating dialog with a selector step and a patch step.
+
+1. select a changed file in the floating window
+2. open its patch in the same centered floating window
+3. return with `esc` / `backspace` or close with `q`
+
+Controls:
+
+- selector: type to filter, `↑` / `↓` or `j` / `k`, then `enter` or `→`
+- patch view: `PgUp` / `PgDn`
+- back: `esc` / `backspace` or `←`
+- close: `q`
+
 ## Audio notifications
 
 Osdy Pi can play your own sound files for these product-level events:
@@ -160,10 +206,18 @@ Notes:
 
 ## Local install
 
-If you cloned this repository and want to test it locally:
+If you cloned this repository and want to test it locally without colliding with an already installed global `osdy-pi`, use the isolated dev launcher:
+
+```bash
+npm run pi:dev
+```
+
+This command runs `pi -e .` with `PI_CODING_AGENT_DIR=.pi-dev`, so it uses a separate local Pi config/package/extensions directory and does not load your global installed `osdy-pi` package.
+
+You can still launch it manually if needed:
 
 ```bash
-pi -e .
+PI_CODING_AGENT_DIR="$PWD/.pi-dev" pi -e .
 ```
 
 To install it from a local path:
@@ -195,6 +249,7 @@ If you are working on the package locally, you can run:
 ```bash
 npm run typecheck
 npm run lint
+npm run pi:dev
 ```
 
 ## Uninstall or turn off

package/extensions/osdy-pi/constants.ts

@@ -18,6 +18,7 @@ export const WORKING_SPINNER_FRAMES = [
   "⠏",
 ];
 export const WORKING_WIDGET_KEY = "osdy-pi-working";
+export const WORKING_TREE_WIDGET_KEY = "osdy-pi-working-tree";
 export const MASCOT_MIN_ROWS = 34;
 export const MASCOT_GAP = 0;
 

package/extensions/osdy-pi/diff-panel.ts

@@ -0,0 +1,381 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+	matchesKey,
+	truncateToWidth,
+	visibleWidth,
+	type Component,
+	type TUI,
+} from "@earendil-works/pi-tui";
+import { truncateMiddle } from "./format.js";
+import type {
+	SimpleTheme,
+	WorkingTreeFileSummary,
+	WorkingTreeState,
+} from "./types.js";
+
+type DiffFileView = {
+	file: WorkingTreeFileSummary;
+	patch: string[];
+};
+
+async function runGit(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	args: string[],
+): Promise<string> {
+	const result = await pi.exec("git", args, { cwd: ctx.cwd });
+	if (result.code !== 0) {
+		throw new Error(result.stderr.trim() || `git ${args.join(" ")} failed`);
+	}
+	return result.stdout;
+}
+
+function normalizePatchLines(output: string): string[] {
+	return output
+		.split("\n")
+		.filter(
+			(line, index, lines) => !(index === lines.length - 1 && line === ""),
+		);
+}
+
+async function loadUntrackedPatch(
+	ctx: ExtensionContext,
+	path: string,
+): Promise<string[]> {
+	const absolutePath = resolve(ctx.cwd, path);
+	const content = await readFile(absolutePath, "utf8");
+	const lines = content.split("\n");
+	return [
+		`diff --git a/${path} b/${path}`,
+		"new file mode 100644",
+		"--- /dev/null",
+		`+++ b/${path}`,
+		`@@ -0,0 +1,${lines.length} @@`,
+		...lines.map((line) => `+${line}`),
+	];
+}
+
+async function loadFilePatch(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	file: WorkingTreeFileSummary,
+): Promise<string[]> {
+	if (file.untracked) {
+		return loadUntrackedPatch(ctx, file.path);
+	}
+	const [stagedPatch, unstagedPatch] = await Promise.all([
+		runGit(pi, ctx, ["diff", "--cached", "--no-ext-diff", "--", file.path]),
+		runGit(pi, ctx, ["diff", "--no-ext-diff", "--", file.path]),
+	]);
+	const merged = [stagedPatch, unstagedPatch]
+		.filter((patch) => patch.trim().length > 0)
+		.join("\n");
+	return normalizePatchLines(merged);
+}
+
+async function buildDiffFiles(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: WorkingTreeState,
+): Promise<DiffFileView[]> {
+	const files = state.snapshot?.files ?? [];
+	const entries = await Promise.all(
+		files.map(async (file) => {
+			try {
+				return {
+					file,
+					patch: await loadFilePatch(pi, ctx, file),
+				};
+			} catch (error) {
+				const message =
+					error instanceof Error ? error.message : "Patch unavailable";
+				return {
+					file,
+					patch: [message],
+				};
+			}
+		}),
+	);
+	return entries;
+}
+
+function fileFlags(theme: SimpleTheme, file: WorkingTreeFileSummary): string {
+	const flags: string[] = [];
+	if (file.untracked) flags.push(theme.fg("warning", "NEW"));
+	if (file.staged) flags.push(theme.fg("success", "STAGED"));
+	if (file.unstaged) flags.push(theme.fg("accent", "UNSTAGED"));
+	if (flags.length === 0) return theme.fg("muted", "[clean]");
+	return `${theme.fg("muted", "[")}${flags.join(theme.fg("muted", ", "))}${theme.fg("muted", "]")}`;
+}
+
+function padLine(line: string, width: number): string {
+	const currentWidth = visibleWidth(line);
+	return `${line}${" ".repeat(Math.max(0, width - currentWidth))}`;
+}
+
+function borderBox(
+	theme: SimpleTheme,
+	width: number,
+	title: string,
+	lines: string[],
+): string[] {
+	const innerWidth = Math.max(1, width - 2);
+	const header = truncateToWidth(` ${title} `, innerWidth, "...", true);
+	const left = "─".repeat(
+		Math.max(0, Math.floor((innerWidth - visibleWidth(header)) / 2)),
+	);
+	const right = "─".repeat(
+		Math.max(0, innerWidth - visibleWidth(header) - left.length),
+	);
+	const result = [
+		theme.fg("border", `╭${left}`) +
+			theme.fg("accent", header) +
+			theme.fg("border", `${right}╮`),
+	];
+	for (const line of lines) {
+		result.push(
+			theme.fg("border", "│") +
+				padLine(truncateToWidth(line, innerWidth, "...", true), innerWidth) +
+				theme.fg("border", "│"),
+		);
+	}
+	result.push(theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
+	return result;
+}
+
+class WorkingTreeDiffPanel implements Component {
+	private selectedIndex = 0;
+	private scrollOffset = 0;
+	private mode: "select" | "view" = "select";
+	private searchTerm = "";
+
+	constructor(
+		private readonly tui: TUI,
+		private readonly theme: SimpleTheme,
+		private readonly files: DiffFileView[],
+		private readonly close: () => void,
+	) {}
+
+	private get filteredFiles(): DiffFileView[] {
+		const query = this.searchTerm.trim().toLowerCase();
+		if (!query) return this.files;
+		return this.files.filter((entry) =>
+			entry.file.path.toLowerCase().includes(query),
+		);
+	}
+
+	private get selected(): DiffFileView | undefined {
+		return this.filteredFiles[this.selectedIndex];
+	}
+
+	private clampSelection(): void {
+		const files = this.filteredFiles;
+		this.selectedIndex = Math.max(
+			0,
+			Math.min(Math.max(0, files.length - 1), this.selectedIndex),
+		);
+	}
+
+	private moveSelection(delta: number): void {
+		const files = this.filteredFiles;
+		if (files.length === 0) return;
+		this.selectedIndex = Math.max(
+			0,
+			Math.min(files.length - 1, this.selectedIndex + delta),
+		);
+		this.scrollOffset = 0;
+		this.tui.requestRender();
+	}
+
+	private updateSearch(next: string): void {
+		this.searchTerm = next;
+		this.selectedIndex = 0;
+		this.scrollOffset = 0;
+		this.tui.requestRender();
+	}
+
+	private renderModal(width: number, title: string, lines: string[]): string[] {
+		return borderBox(this.theme, width, title, lines);
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, "ctrl+c") || matchesKey(data, "q")) {
+			this.close();
+			return;
+		}
+		if (this.mode === "select") {
+			if (matchesKey(data, "escape")) {
+				if (this.searchTerm.length > 0) {
+					this.updateSearch("");
+					return;
+				}
+				this.close();
+				return;
+			}
+			if (matchesKey(data, "backspace")) {
+				if (this.searchTerm.length > 0) {
+					this.updateSearch(this.searchTerm.slice(0, -1));
+					return;
+				}
+			}
+			if (matchesKey(data, "up") || matchesKey(data, "k")) {
+				this.moveSelection(-1);
+				return;
+			}
+			if (matchesKey(data, "down") || matchesKey(data, "j")) {
+				this.moveSelection(1);
+				return;
+			}
+			if (
+				matchesKey(data, "return") ||
+				matchesKey(data, "space") ||
+				matchesKey(data, "right") ||
+				matchesKey(data, "l")
+			) {
+				if (this.filteredFiles.length === 0) return;
+				this.mode = "view";
+				this.scrollOffset = 0;
+				this.tui.requestRender();
+				return;
+			}
+			if (data.length === 1 && data >= " " && data !== "\u007f") {
+				this.updateSearch(`${this.searchTerm}${data}`);
+				return;
+			}
+			return;
+		}
+		if (
+			matchesKey(data, "escape") ||
+			matchesKey(data, "backspace") ||
+			matchesKey(data, "left") ||
+			matchesKey(data, "h")
+		) {
+			this.mode = "select";
+			this.tui.requestRender();
+			return;
+		}
+		if (data === "\u001b[5~") {
+			this.scrollOffset = Math.max(0, this.scrollOffset - 12);
+			this.tui.requestRender();
+			return;
+		}
+		if (data === "\u001b[6~" || matchesKey(data, "space")) {
+			this.scrollOffset += 12;
+			this.tui.requestRender();
+		}
+	}
+
+	render(width: number): string[] {
+		this.clampSelection();
+		const filteredFiles = this.filteredFiles;
+		const selected = this.selected;
+		if (this.files.length === 0) {
+			return this.renderModal(width, "Osdy Pi Diff", [
+				this.theme.fg("muted", "q or esc to close"),
+				this.theme.fg("warning", "No tracked changes available."),
+			]);
+		}
+		if (this.mode === "select") {
+			const innerWidth = Math.max(20, width - 4);
+			const listStart = Math.max(
+				0,
+				Math.min(
+					this.selectedIndex - 4,
+					Math.max(0, filteredFiles.length - 10),
+				),
+			);
+			const listEntries = filteredFiles.slice(listStart, listStart + 10);
+			const listLines = listEntries.map((entry, index) => {
+				const fileIndex = listStart + index;
+				const isSelected = fileIndex === this.selectedIndex;
+				const marker = isSelected
+					? this.theme.fg("accent", "❯")
+					: this.theme.fg("muted", "·");
+				const path = truncateMiddle(
+					entry.file.path,
+					Math.max(12, innerWidth - 34),
+				);
+				const stats = `${this.theme.fg("success", `+${entry.file.additions}`)}/${this.theme.fg("error", `-${entry.file.removals}`)}`;
+				const badges = fileFlags(this.theme, entry.file);
+				return `${marker} ${this.theme.fg(isSelected ? "accent" : "toolOutput", path)} ${badges} ${stats}`;
+			});
+			return this.renderModal(width, "Osdy Pi Diff · Select file", [
+				this.theme.fg(
+					"muted",
+					"Type to filter · ↑↓ move · enter/right open · esc clear/close",
+				),
+				`${this.theme.fg("accent", "Search:")} ${this.theme.fg("toolOutput", this.searchTerm || "")}${this.searchTerm.length === 0 ? this.theme.fg("muted", "(all files)") : ""}`,
+				this.theme.fg(
+					"mdLink",
+					`Files ${filteredFiles.length === 0 ? 0 : this.selectedIndex + 1}/${filteredFiles.length} · total ${this.files.length}`,
+				),
+				...(listLines.length > 0
+					? listLines
+					: [this.theme.fg("warning", "No files match the current search.")]),
+			]);
+		}
+		if (!selected) {
+			return this.renderModal(width, "Osdy Pi Diff", [
+				this.theme.fg("muted", "esc to go back"),
+				this.theme.fg("warning", "No file selected."),
+			]);
+		}
+		const patchLines =
+			selected.patch.length > 0
+				? selected.patch
+				: ["(No patch lines for this file)"];
+		const availablePatchHeight = Math.max(8, this.tui.terminal.rows - 10);
+		const maxOffset = Math.max(0, patchLines.length - availablePatchHeight);
+		this.scrollOffset = Math.min(this.scrollOffset, maxOffset);
+		const visiblePatch = patchLines
+			.slice(this.scrollOffset, this.scrollOffset + availablePatchHeight)
+			.map((line) => {
+				if (line.startsWith("+") && !line.startsWith("+++"))
+					return this.theme.fg("success", line);
+				if (line.startsWith("-") && !line.startsWith("---"))
+					return this.theme.fg("error", line);
+				if (line.startsWith("@@")) return this.theme.fg("accent", line);
+				return this.theme.fg("toolOutput", line);
+			});
+		return this.renderModal(width, `Diff · ${selected.file.path}`, [
+			this.theme.fg(
+				"muted",
+				"PgUp/PgDn scroll · esc/backspace/left back · q close",
+			),
+			this.theme.fg(
+				"mdLink",
+				`Patch ${Math.min(this.scrollOffset + 1, patchLines.length)}/${patchLines.length}`,
+			),
+			...visiblePatch,
+		]);
+	}
+
+	invalidate(): void {}
+}
+
+export async function showWorkingTreeDiffPanel(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: WorkingTreeState,
+): Promise<void> {
+	const files = await buildDiffFiles(pi, ctx, state);
+	await ctx.ui.custom<void>(
+		(tui, theme, _keybindings, done) =>
+			new WorkingTreeDiffPanel(tui, theme, files, () => done()),
+		{
+			overlay: true,
+			overlayOptions: {
+				anchor: "center",
+				width: 112,
+				minWidth: 56,
+				maxHeight: "88%",
+				margin: 1,
+			},
+		},
+	);
+}

package/extensions/osdy-pi/runtime-helpers.ts

@@ -3,15 +3,24 @@ import type {
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { asciiAnimationMode } from "./animation.js";
-import { THEME_NAME, WORKING_WIDGET_KEY } from "./constants.js";
+import {
+	THEME_NAME,
+	WORKING_TREE_WIDGET_KEY,
+	WORKING_WIDGET_KEY,
+} from "./constants.js";
 import { modelLabel, usageLabel } from "./metrics.js";
-import type { OsdyState, WorkingWidgetState } from "./types.js";
+import type {
+	OsdyState,
+	WorkingTreeState,
+	WorkingWidgetState,
+} from "./types.js";
 import {
 	createEditorComponent,
 	createFooterComponent,
 	createHeaderComponent,
 	createWorkingWidgetFactory,
 } from "./ui.js";
+import { createWorkingTreeWidgetFactory } from "./working-tree.js";
 
 function shouldRememberTheme(
 	previousThemeName: string | undefined,
@@ -52,6 +61,7 @@ export function mountOsdyUi(
 	ctx: ExtensionContext,
 	state: OsdyState,
 	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
 ): void {
 	ctx.ui.setHeader(createHeaderComponent(pi, ctx, state));
 	ctx.ui.setFooter((_tui, theme, footerData) =>
@@ -63,6 +73,11 @@ export function mountOsdyUi(
 		createWorkingWidgetFactory(workingState),
 		{ placement: "aboveEditor" },
 	);
+	ctx.ui.setWidget(
+		WORKING_TREE_WIDGET_KEY,
+		createWorkingTreeWidgetFactory(workingTreeState),
+		{ placement: state.workingTreePlacement },
+	);
 	ctx.ui.setEditorComponent(createEditorComponent(pi, ctx));
 }
 
@@ -71,12 +86,13 @@ export function applyOsdyPi(
 	ctx: ExtensionContext,
 	state: OsdyState,
 	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
 	notify = false,
 ): void {
 	if (!ctx.hasUI) return;
 	rememberPreviousTheme(ctx, state);
 	applyOsdyTheme(ctx);
-	mountOsdyUi(pi, ctx, state, workingState);
+	mountOsdyUi(pi, ctx, state, workingState, workingTreeState);
 	if (notify) ctx.ui.notify("osdy-pi enabled", "info");
 }
 
@@ -86,6 +102,7 @@ export function disableOsdyPi(ctx: ExtensionContext, state: OsdyState): void {
 	ctx.ui.setEditorComponent(undefined);
 	ctx.ui.setFooter(undefined);
 	ctx.ui.setWidget(WORKING_WIDGET_KEY, undefined);
+	ctx.ui.setWidget(WORKING_TREE_WIDGET_KEY, undefined);
 	ctx.ui.setWorkingVisible(true);
 	const targetTheme = state.previousThemeName ?? "dark";
 	const result = ctx.ui.setTheme(targetTheme);
@@ -95,7 +112,7 @@ export function disableOsdyPi(ctx: ExtensionContext, state: OsdyState): void {
 
 export function notifyStatus(ctx: ExtensionContext, state: OsdyState): void {
 	ctx.ui.notify(
-		`osdy-pi ${state.enabled ? "enabled" : "disabled"} · theme ${ctx.ui.theme.name ?? "unknown"} · style ${state.headerVariant} · animation ${asciiAnimationMode()} · ${modelLabel(ctx)} · ${usageLabel(ctx).trim()}`,
+		`osdy-pi ${state.enabled ? "enabled" : "disabled"} · working-tree ${state.workingTreeEnabled ? "on" : "off"} · widget ${state.workingTreePlacement === "aboveEditor" ? "top" : "bottom"} · theme ${ctx.ui.theme.name ?? "unknown"} · style ${state.headerVariant} · animation ${asciiAnimationMode()} · ${modelLabel(ctx)} · ${usageLabel(ctx).trim()}`,
 		"info",
 	);
 }

package/extensions/osdy-pi/runtime.ts

@@ -9,7 +9,19 @@ import { createAudioPlaybackAdapter } from "./audio-playback.js";
 import { createAudioSoundSettingsStore } from "./audio-sound-settings.js";
 import { applyOsdyPi, disableOsdyPi, notifyStatus } from "./runtime-helpers.js";
 import { runSoundSetupWizard } from "./sound-setup-wizard.js";
-import type { HeaderVariant, OsdyState, WorkingWidgetState } from "./types.js";
+import type {
+	HeaderVariant,
+	OsdyState,
+	WorkingTreeState,
+	WorkingWidgetState,
+} from "./types.js";
+import { WORKING_TREE_WIDGET_KEY, WORKING_WIDGET_KEY } from "./constants.js";
+import {
+	clearWorkingTree,
+	refreshWorkingTree,
+	shouldRefreshWorkingTree,
+} from "./working-tree.js";
+import { showWorkingTreeDiffPanel } from "./diff-panel.js";
 import {
 	createWorkingController,
 	type WorkingController,
@@ -21,9 +33,11 @@ function scheduleOsdyRefresh(
 	ctx: ExtensionContext,
 	state: OsdyState,
 	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
 ): void {
 	setTimeout(() => {
-		if (state.enabled) applyOsdyPi(pi, ctx, state, workingState);
+		if (state.enabled)
+			applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
 	}, delayMs);
 }
 
@@ -32,11 +46,19 @@ function claimOsdyVisualLayer(
 	ctx: ExtensionContext,
 	state: OsdyState,
 	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
 ): void {
 	if (!state.enabled) return;
-	applyOsdyPi(pi, ctx, state, workingState);
+	applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
 	for (const delayMs of [300, 1000]) {
-		scheduleOsdyRefresh(delayMs, pi, ctx, state, workingState);
+		scheduleOsdyRefresh(
+			delayMs,
+			pi,
+			ctx,
+			state,
+			workingState,
+			workingTreeState,
+		);
 	}
 }
 
@@ -77,25 +99,30 @@ function isHeaderVariant(value: string): value is HeaderVariant {
 	return HEADER_VARIANTS.includes(value as HeaderVariant);
 }
 
-function enableOsdyPi(
+async function enableOsdyPi(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
 	state: OsdyState,
 	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
 	controller: WorkingController,
-): void {
+): Promise<void> {
 	state.enabled = true;
-	applyOsdyPi(pi, ctx, state, workingState, true);
+	applyOsdyPi(pi, ctx, state, workingState, workingTreeState, true);
 	controller.refreshWorking();
+	if (state.workingTreeEnabled)
+		await refreshWorkingTree(pi, ctx, workingTreeState);
 }
 
 function disableOsdyPiCommand(
 	ctx: ExtensionContext,
 	state: OsdyState,
+	workingTreeState: WorkingTreeState,
 	controller: WorkingController,
 ): void {
 	state.enabled = false;
 	controller.stopWorking();
+	clearWorkingTree(workingTreeState);
 	disableOsdyPi(ctx, state);
 }
 
@@ -104,10 +131,12 @@ function setHeaderVariant(
 	ctx: ExtensionContext,
 	state: OsdyState,
 	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
 	variant: HeaderVariant,
 ): void {
 	state.headerVariant = variant;
-	if (state.enabled) applyOsdyPi(pi, ctx, state, workingState);
+	if (state.enabled)
+		applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
 	ctx.ui.notify(`osdy-pi style: ${variant}`, "info");
 }
 
@@ -115,16 +144,40 @@ function getOsdyCommandCompletions(prefix: string) {
 	const trimmed = prefix.trim();
 	const parts = parseCommandArgs(trimmed);
 	if (parts.length === 0) {
-		return ["enable", "disable", "status", "sound", ...HEADER_VARIANTS].map(
-			(value) => ({ value, label: value }),
-		);
+		return [
+			"enable",
+			"disable",
+			"status",
+			"sound",
+			"working-tree",
+			"diff",
+			...HEADER_VARIANTS,
+		].map((value) => ({ value, label: value }));
 	}
 	if (trimmed === "sound") {
 		return [{ value: "sound setup", label: "sound setup" }];
 	}
+	if (trimmed === "working-tree") {
+		return [
+			"working-tree on",
+			"working-tree off",
+			"working-tree toggle",
+			"working-tree status",
+			"working-tree position top",
+			"working-tree position bottom",
+		].map((value) => ({ value, label: value }));
+	}
 	if (parts.length === 1) {
 		const valuePrefix = parts[0] ?? "";
-		return ["enable", "disable", "status", "sound", ...HEADER_VARIANTS]
+		return [
+			"enable",
+			"disable",
+			"status",
+			"sound",
+			"working-tree",
+			"diff",
+			...HEADER_VARIANTS,
+		]
 			.filter((value) => value.startsWith(valuePrefix))
 			.map((value) => ({ value, label: value }));
 	}
@@ -134,6 +187,28 @@ function getOsdyCommandCompletions(prefix: string) {
 			.filter((value) => value.startsWith(valuePrefix))
 			.map((value) => ({ value: `sound ${value}`, label: `sound ${value}` }));
 	}
+	if (parts[0] === "working-tree" && parts.length === 2) {
+		const valuePrefix = parts[1] ?? "";
+		return ["on", "off", "toggle", "status", "position"]
+			.filter((value) => value.startsWith(valuePrefix))
+			.map((value) => ({
+				value: `working-tree ${value}`,
+				label: `working-tree ${value}`,
+			}));
+	}
+	if (
+		parts[0] === "working-tree" &&
+		parts[1] === "position" &&
+		parts.length === 3
+	) {
+		const valuePrefix = parts[2] ?? "";
+		return ["top", "bottom", "status"]
+			.filter((value) => value.startsWith(valuePrefix))
+			.map((value) => ({
+				value: `working-tree position ${value}`,
+				label: `working-tree position ${value}`,
+			}));
+	}
 	return null;
 }
 
@@ -150,25 +225,161 @@ async function handleSoundCommand(
 	ctx.ui.notify("Usage: /osdy-pi sound setup", "warning");
 }
 
+function handleWorkingTreePositionCommand(
+	action: string | undefined,
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
+): void {
+	if (action === "top") {
+		state.workingTreePlacement = "aboveEditor";
+		if (state.enabled)
+			applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
+		ctx.ui.notify("osdy-pi working tree position: top", "info");
+		return;
+	}
+	if (action === "bottom") {
+		state.workingTreePlacement = "belowEditor";
+		if (state.enabled)
+			applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
+		ctx.ui.notify("osdy-pi working tree position: bottom", "info");
+		return;
+	}
+	if (action === "status" || action === undefined) {
+		ctx.ui.notify(
+			`osdy-pi working tree position ${state.workingTreePlacement === "aboveEditor" ? "top" : "bottom"}`,
+			"info",
+		);
+		return;
+	}
+	ctx.ui.notify(
+		"Usage: /osdy-pi working-tree position top | bottom | status",
+		"warning",
+	);
+}
+
+async function handleWorkingTreeCommand(
+	action: string | undefined,
+	rest: string[],
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
+): Promise<void> {
+	if (action === "position") {
+		handleWorkingTreePositionCommand(
+			rest[0],
+			pi,
+			ctx,
+			state,
+			workingState,
+			workingTreeState,
+		);
+		return;
+	}
+	if (action === "on") {
+		state.workingTreeEnabled = true;
+		workingTreeState.enabled = true;
+		await refreshWorkingTree(pi, ctx, workingTreeState);
+		ctx.ui.notify("osdy-pi working tree enabled", "info");
+		return;
+	}
+	if (action === "off") {
+		state.workingTreeEnabled = false;
+		workingTreeState.enabled = false;
+		clearWorkingTree(workingTreeState);
+		ctx.ui.notify("osdy-pi working tree disabled", "info");
+		return;
+	}
+	if (action === "toggle") {
+		const nextAction = state.workingTreeEnabled ? "off" : "on";
+		await handleWorkingTreeCommand(
+			nextAction,
+			[],
+			pi,
+			ctx,
+			state,
+			workingState,
+			workingTreeState,
+		);
+		return;
+	}
+	if (action === "status" || action === undefined) {
+		const status = state.workingTreeEnabled ? "enabled" : "disabled";
+		ctx.ui.notify(`osdy-pi working tree ${status}`, "info");
+		return;
+	}
+	ctx.ui.notify(
+		"Usage: /osdy-pi working-tree on | off | toggle | status | position ...",
+		"warning",
+	);
+}
+
+async function openDiffCommand(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
+): Promise<void> {
+	if (!state.workingTreeEnabled) {
+		ctx.ui.notify(
+			"Enable working-tree first with /osdy-pi working-tree on",
+			"warning",
+		);
+		return;
+	}
+	if (workingTreeState.loading) {
+		ctx.ui.notify("working tree is still refreshing", "warning");
+		return;
+	}
+	if (!workingTreeState.snapshot) {
+		await refreshWorkingTree(pi, ctx, workingTreeState);
+	}
+	ctx.ui.setHeader(undefined);
+	ctx.ui.setFooter(undefined);
+	ctx.ui.setWidget(WORKING_WIDGET_KEY, undefined);
+	ctx.ui.setWidget(WORKING_TREE_WIDGET_KEY, undefined);
+	ctx.ui.setWorkingVisible(false);
+	try {
+		await showWorkingTreeDiffPanel(pi, ctx, workingTreeState);
+	} finally {
+		if (state.enabled) {
+			applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
+		}
+	}
+}
+
 function registerCommand(
 	pi: ExtensionAPI,
 	state: OsdyState,
 	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
 	controller: WorkingController,
 	settingsStore: ReturnType<typeof createAudioSoundSettingsStore>,
 ): void {
 	pi.registerCommand("osdy-pi", {
 		description:
-			"Manage the Osdy Pi experience: enable, disable, status, style, or sound setup.",
+			"Manage the Osdy Pi experience: enable, disable, status, style, sound setup, working tree, or diff panel.",
 		getArgumentCompletions: getOsdyCommandCompletions,
 		handler: async (args, ctx) => {
 			const [action = "status", ...rest] = parseCommandArgs(args);
 			if (action === "enable") {
-				enableOsdyPi(pi, ctx, state, workingState, controller);
+				await enableOsdyPi(
+					pi,
+					ctx,
+					state,
+					workingState,
+					workingTreeState,
+					controller,
+				);
 				return;
 			}
 			if (action === "disable") {
-				disableOsdyPiCommand(ctx, state, controller);
+				disableOsdyPiCommand(ctx, state, workingTreeState, controller);
 				return;
 			}
 			if (action === "status") {
@@ -179,12 +390,35 @@ function registerCommand(
 				await handleSoundCommand(rest, ctx, settingsStore);
 				return;
 			}
+			if (action === "working-tree") {
+				await handleWorkingTreeCommand(
+					rest[0],
+					rest.slice(1),
+					pi,
+					ctx,
+					state,
+					workingState,
+					workingTreeState,
+				);
+				return;
+			}
+			if (action === "diff") {
+				await openDiffCommand(pi, ctx, state, workingState, workingTreeState);
+				return;
+			}
 			if (isHeaderVariant(action)) {
-				setHeaderVariant(pi, ctx, state, workingState, action);
+				setHeaderVariant(
+					pi,
+					ctx,
+					state,
+					workingState,
+					workingTreeState,
+					action,
+				);
 				return;
 			}
 			ctx.ui.notify(
-				"Usage: /osdy-pi enable | disable | status | sound setup | osdy-theme | classic",
+				"Usage: /osdy-pi enable | disable | status | sound setup | working-tree ... | diff | osdy-theme | classic",
 				"warning",
 			);
 		},
@@ -194,7 +428,14 @@ function registerCommand(
 		pi.registerCommand(`osdy-pi-${variant}`, {
 			description: `Switch Osdy Pi header to ${variant}.`,
 			handler: (_args, ctx) => {
-				setHeaderVariant(pi, ctx, state, workingState, variant);
+				setHeaderVariant(
+					pi,
+					ctx,
+					state,
+					workingState,
+					workingTreeState,
+					variant,
+				);
 				return Promise.resolve();
 			},
 		});
@@ -207,6 +448,8 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 		headerVariant: "osdy-theme",
 		gitLabel: "-",
 		agentsLabel: "-",
+		workingTreeEnabled: true,
+		workingTreePlacement: "aboveEditor",
 	};
 	const workingState: WorkingWidgetState = {
 		active: false,
@@ -215,6 +458,13 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 		timer: undefined,
 		tui: undefined,
 	};
+	const workingTreeState: WorkingTreeState = {
+		enabled: true,
+		loading: false,
+		snapshot: null,
+		error: undefined,
+		tui: undefined,
+	};
 	const controller = createWorkingController(state, workingState);
 	const settingsStore = createAudioSoundSettingsStore();
 	registerAudioNotificationFlags(pi);
@@ -240,12 +490,28 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 	pi.on("tool_execution_end", (event, ctx) => {
 		controller.onToolEnd();
 		audioRouter.onToolExecutionEnd(event.isError === true, ctx);
+		if (event.isError !== true && shouldRefreshWorkingTree(event.toolName)) {
+			void refreshWorkingTree(pi, ctx, workingTreeState);
+		}
+	});
+	pi.on("session_shutdown", () => {
+		controller.onShutdown();
+		workingTreeState.tui = undefined;
 	});
-	pi.on("session_shutdown", () => controller.onShutdown());
 	pi.on("session_start", (_event, ctx) => {
 		loadSessionMetadata(pi, ctx, state);
-		claimOsdyVisualLayer(pi, ctx, state, workingState);
+		claimOsdyVisualLayer(pi, ctx, state, workingState, workingTreeState);
+		if (state.workingTreeEnabled) {
+			void refreshWorkingTree(pi, ctx, workingTreeState);
+		}
 	});
 
-	registerCommand(pi, state, workingState, controller, settingsStore);
+	registerCommand(
+		pi,
+		state,
+		workingState,
+		workingTreeState,
+		controller,
+		settingsStore,
+	);
 }

package/extensions/osdy-pi/types.ts

@@ -4,12 +4,16 @@ export type AnimationMode = "off" | "intro" | "continuous";
 
 export type HeaderVariant = "osdy-theme" | "classic";
 
+export type WorkingTreePlacement = "aboveEditor" | "belowEditor";
+
 export type OsdyState = {
 	enabled: boolean;
 	headerVariant: HeaderVariant;
 	previousThemeName?: string;
 	gitLabel: string;
 	agentsLabel: string;
+	workingTreeEnabled: boolean;
+	workingTreePlacement: WorkingTreePlacement;
 };
 
 export type WorkingWidgetState = {
@@ -20,6 +24,33 @@ export type WorkingWidgetState = {
 	tui: TUI | undefined;
 };
 
+export type WorkingTreeFileSummary = {
+	path: string;
+	additions: number;
+	removals: number;
+	staged: boolean;
+	unstaged: boolean;
+	untracked: boolean;
+};
+
+export type WorkingTreeSnapshot = {
+	files: WorkingTreeFileSummary[];
+	totalFiles: number;
+	stagedFiles: number;
+	unstagedFiles: number;
+	untrackedFiles: number;
+	additions: number;
+	removals: number;
+};
+
+export type WorkingTreeState = {
+	enabled: boolean;
+	loading: boolean;
+	snapshot: WorkingTreeSnapshot | null;
+	error: string | undefined;
+	tui: TUI | undefined;
+};
+
 export type AssistantUsage = {
 	input?: number;
 	output?: number;

package/extensions/osdy-pi/working-tree.ts

@@ -0,0 +1,290 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type {
+	SimpleTheme,
+	WorkingTreeFileSummary,
+	WorkingTreeSnapshot,
+	WorkingTreeState,
+} from "./types.js";
+import { fitCenterVisible } from "./utils.js";
+
+const MUTATING_TOOL_NAMES = new Set(["edit", "write", "ast_grep_replace"]);
+
+type FileFlags = {
+	path: string;
+	staged: boolean;
+	unstaged: boolean;
+	untracked: boolean;
+	additions: number;
+	removals: number;
+};
+
+function requestWorkingTreeRender(state: WorkingTreeState): void {
+	state.tui?.requestRender();
+}
+
+function createEmptyFlags(path: string): FileFlags {
+	return {
+		path,
+		staged: false,
+		unstaged: false,
+		untracked: false,
+		additions: 0,
+		removals: 0,
+	};
+}
+
+function getOrCreateFile(map: Map<string, FileFlags>, path: string): FileFlags {
+	const current = map.get(path);
+	if (current) return current;
+	const next = createEmptyFlags(path);
+	map.set(path, next);
+	return next;
+}
+
+function parseDiffNumber(value: string): number {
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function normalizeGitPath(path: string): string {
+	const trimmed = path.trim();
+	if (!trimmed.includes(" -> ")) return trimmed;
+	const [, renamedPath = trimmed] = trimmed.split(" -> ");
+	return renamedPath.trim();
+}
+
+function mergeNumstat(
+	map: Map<string, FileFlags>,
+	output: string,
+	kind: "staged" | "unstaged",
+): void {
+	for (const line of output.split("\n")) {
+		if (!line.trim()) continue;
+		const [additionsRaw = "0", removalsRaw = "0", ...pathParts] =
+			line.split("\t");
+		const path = normalizeGitPath(pathParts.join("\t"));
+		if (!path) continue;
+		const file = getOrCreateFile(map, path);
+		file.additions += parseDiffNumber(additionsRaw);
+		file.removals += parseDiffNumber(removalsRaw);
+		if (kind === "staged") file.staged = true;
+		if (kind === "unstaged") file.unstaged = true;
+	}
+}
+
+function mergeStatus(map: Map<string, FileFlags>, output: string): void {
+	for (const line of output.split("\n")) {
+		if (!line.trim()) continue;
+		if (line.startsWith("?? ")) {
+			const path = normalizeGitPath(line.slice(3));
+			if (!path) continue;
+			const file = getOrCreateFile(map, path);
+			file.untracked = true;
+			file.unstaged = true;
+			continue;
+		}
+		if (line.length < 4) continue;
+		const x = line[0] ?? " ";
+		const y = line[1] ?? " ";
+		const path = normalizeGitPath(line.slice(3));
+		if (!path) continue;
+		const file = getOrCreateFile(map, path);
+		if (x !== " ") file.staged = true;
+		if (y !== " ") file.unstaged = true;
+	}
+}
+
+function toFileSummary(file: FileFlags): WorkingTreeFileSummary {
+	return {
+		path: file.path,
+		additions: file.additions,
+		removals: file.removals,
+		staged: file.staged,
+		unstaged: file.unstaged,
+		untracked: file.untracked,
+	};
+}
+
+function compareFiles(
+	left: WorkingTreeFileSummary,
+	right: WorkingTreeFileSummary,
+): number {
+	const leftMagnitude = left.additions + left.removals;
+	const rightMagnitude = right.additions + right.removals;
+	if (leftMagnitude !== rightMagnitude) return rightMagnitude - leftMagnitude;
+	return left.path.localeCompare(right.path);
+}
+
+async function hydrateUntrackedStats(
+	ctx: ExtensionContext,
+	fileMap: Map<string, FileFlags>,
+): Promise<void> {
+	await Promise.all(
+		Array.from(fileMap.values()).map(async (file) => {
+			if (!file.untracked || file.additions > 0 || file.removals > 0) return;
+			try {
+				const content = await readFile(resolve(ctx.cwd, file.path), "utf8");
+				file.additions = content.length === 0 ? 0 : content.split("\n").length;
+			} catch {
+				file.additions = 1;
+			}
+		}),
+	);
+}
+
+function createSnapshot(files: WorkingTreeFileSummary[]): WorkingTreeSnapshot {
+	const stagedFiles = files.filter((file) => file.staged).length;
+	const unstagedFiles = files.filter((file) => file.unstaged).length;
+	const untrackedFiles = files.filter((file) => file.untracked).length;
+	const additions = files.reduce((total, file) => total + file.additions, 0);
+	const removals = files.reduce((total, file) => total + file.removals, 0);
+	return {
+		files,
+		totalFiles: files.length,
+		stagedFiles,
+		unstagedFiles,
+		untrackedFiles,
+		additions,
+		removals,
+	};
+}
+
+async function runGit(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	args: string[],
+): Promise<string> {
+	const result = await pi.exec("git", args, { cwd: ctx.cwd });
+	if (result.code !== 0) {
+		throw new Error(result.stderr.trim() || `git ${args.join(" ")} failed`);
+	}
+	return result.stdout;
+}
+
+let refreshGeneration = 0;
+
+export async function refreshWorkingTree(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: WorkingTreeState,
+): Promise<void> {
+	if (!state.enabled) return;
+	const generation = ++refreshGeneration;
+	state.loading = true;
+	state.error = undefined;
+	requestWorkingTreeRender(state);
+
+	try {
+		await runGit(pi, ctx, ["rev-parse", "--is-inside-work-tree"]);
+		const [statusOutput, stagedOutput, unstagedOutput] = await Promise.all([
+			runGit(pi, ctx, ["status", "--short", "--untracked-files=all"]),
+			runGit(pi, ctx, ["diff", "--cached", "--numstat", "--no-ext-diff"]),
+			runGit(pi, ctx, ["diff", "--numstat", "--no-ext-diff"]),
+		]);
+		if (generation !== refreshGeneration) return;
+		const fileMap = new Map<string, FileFlags>();
+		mergeStatus(fileMap, statusOutput);
+		mergeNumstat(fileMap, stagedOutput, "staged");
+		mergeNumstat(fileMap, unstagedOutput, "unstaged");
+		await hydrateUntrackedStats(ctx, fileMap);
+		const files = Array.from(fileMap.values())
+			.map(toFileSummary)
+			.sort(compareFiles);
+		state.snapshot = createSnapshot(files);
+	} catch {
+		if (generation !== refreshGeneration) return;
+		state.snapshot = null;
+		state.error = "working tree unavailable";
+	} finally {
+		if (generation === refreshGeneration) {
+			state.loading = false;
+			requestWorkingTreeRender(state);
+		}
+	}
+}
+
+export function clearWorkingTree(state: WorkingTreeState): void {
+	refreshGeneration += 1;
+	state.loading = false;
+	state.snapshot = null;
+	state.error = undefined;
+	requestWorkingTreeRender(state);
+}
+
+export function shouldRefreshWorkingTree(toolName: string): boolean {
+	return MUTATING_TOOL_NAMES.has(toolName) || toolName === "bash";
+}
+
+function renderSummaryLine(
+	snapshot: WorkingTreeSnapshot,
+	theme: SimpleTheme,
+): string {
+	if (snapshot.totalFiles === 0) {
+		return theme.fg("mdLink", "Git changes · working tree clean");
+	}
+	const parts = [
+		theme.fg("mdLink", `Git changes · ${snapshot.totalFiles} files`),
+		theme.fg("success", `+${snapshot.additions}`),
+		theme.fg("error", `-${snapshot.removals}`),
+		theme.fg("mdLink", `staged ${snapshot.stagedFiles}`),
+		theme.fg("mdLink", `unstaged ${snapshot.unstagedFiles}`),
+	];
+	if (snapshot.untrackedFiles > 0) {
+		parts.push(theme.fg("mdLink", `new ${snapshot.untrackedFiles}`));
+	}
+	return parts.join(theme.fg("muted", " · "));
+}
+
+class WorkingTreeWidget implements Component {
+	constructor(
+		private readonly state: WorkingTreeState,
+		private readonly theme: SimpleTheme,
+	) {}
+
+	render(width: number): string[] {
+		if (!this.state.enabled) return [];
+		if (this.state.loading) {
+			return [
+				fitCenterVisible(
+					this.theme.fg("muted", "Git changes · refreshing..."),
+					width,
+				),
+			];
+		}
+		if (this.state.error) {
+			return [
+				fitCenterVisible(
+					this.theme.fg("warning", "Git changes unavailable"),
+					width,
+				),
+			];
+		}
+		const snapshot = this.state.snapshot;
+		if (!snapshot) return [];
+		return [
+			fitCenterVisible(
+				truncateToWidth(
+					renderSummaryLine(snapshot, this.theme),
+					Math.max(1, width),
+				),
+				width,
+			),
+		];
+	}
+
+	invalidate(): void {}
+}
+
+export function createWorkingTreeWidgetFactory(state: WorkingTreeState) {
+	return (tui: TUI, theme: SimpleTheme): Component => {
+		state.tui = tui;
+		return new WorkingTreeWidget(state, theme);
+	};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "osdy-pi",
-	"version": "0.1.7",
+	"version": "0.1.9",
 	"description": "Osdy Pi package: themes, header, and custom editor for Pi.",
 	"license": "MIT",
 	"type": "module",
@@ -12,7 +12,8 @@
 	],
 	"scripts": {
 		"typecheck": "tsc --noEmit",
-		"lint": "eslint ."
+		"lint": "eslint .",
+		"pi:dev": "node ./scripts/pi-dev.mjs"
 	},
 	"files": [
 		"README.md",