@shanepadgett/tau-agent 0.1.0

package/extensions/manage-sessions/manager-ui.ts

@@ -0,0 +1,323 @@
+import { homedir } from "node:os";
+import { relative } from "node:path";
+import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, getKeybindings, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { errorText, formatAge, preview } from "../../shared/text.ts";
+import { bindingHint, rawHint, type ToolKeyHint } from "@shanepadgett/tau-tui";
+import { type SelectableListActionResult, SelectableList } from "@shanepadgett/tau-tui";
+import { Tabs } from "@shanepadgett/tau-tui";
+import { ToolPanel, type ToolPanelConfig } from "@shanepadgett/tau-tui";
+import {
+	archiveSession,
+	deleteSessionFile,
+	getArchiveRoot,
+	listManagedSessions,
+	type ManagedSession,
+	type SessionScope,
+	unarchiveSession,
+} from "./sessions.ts";
+
+type TabId = "active" | "archive";
+type PendingKind = "archive" | "delete" | "unarchive";
+
+interface PendingAction {
+	kind: PendingKind;
+	items: readonly ManagedSession[];
+	tab: TabId;
+}
+
+export async function showSessionManager(ctx: ExtensionCommandContext): Promise<void> {
+	if (ctx.mode !== "tui" || !ctx.hasUI) {
+		ctx.ui.notify("Session manager requires TUI mode.", "error");
+		return;
+	}
+
+	const currentSessionFile = ctx.sessionManager.getSessionFile() ?? undefined;
+	const initial = await listManagedSessions(ctx.cwd, "current", currentSessionFile);
+
+	await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
+		const manager = new SessionManagerPanel(
+			ctx,
+			theme,
+			currentSessionFile,
+			initial,
+			() => done(undefined),
+			() => tui.requestRender(),
+		);
+		return manager.component;
+	});
+}
+
+class SessionManagerPanel {
+	readonly component: Component;
+	private scope: SessionScope = "current";
+	private active: readonly ManagedSession[];
+	private archive: readonly ManagedSession[];
+	private pending: PendingAction | undefined;
+	private executing = false;
+	private readonly ctx: ExtensionCommandContext;
+	private readonly theme: Theme;
+	private readonly currentSessionFile: string | undefined;
+	private readonly done: () => void;
+	private readonly requestRender: () => void;
+	private readonly activeList: SelectableList<ManagedSession>;
+	private readonly archiveList: SelectableList<ManagedSession>;
+	private readonly tabs: Tabs;
+	private readonly panelConfig: ToolPanelConfig;
+
+	constructor(
+		ctx: ExtensionCommandContext,
+		theme: Theme,
+		currentSessionFile: string | undefined,
+		initial: { active: readonly ManagedSession[]; archive: readonly ManagedSession[] },
+		done: () => void,
+		requestRender: () => void,
+	) {
+		this.ctx = ctx;
+		this.theme = theme;
+		this.currentSessionFile = currentSessionFile;
+		this.done = done;
+		this.requestRender = requestRender;
+		this.active = initial.active;
+		this.archive = initial.archive;
+		this.activeList = this.createList("active", this.active);
+		this.archiveList = this.createList("archive", this.archive);
+		this.tabs = new Tabs(theme, this.tabItems(), "active");
+		this.panelConfig = {
+			title: "Manage sessions",
+			secondary: this.secondaryText(),
+			body: this.tabs,
+			footer: { kind: "hints", hints: this.footerHints() },
+		};
+		const panel = new ToolPanel(theme, this.panelConfig);
+		this.component = {
+			render: (width) => panel.render(width),
+			invalidate: () => panel.invalidate(),
+			handleInput: (data) => this.handleInput(data),
+		};
+	}
+
+	private createList(tab: TabId, items: readonly ManagedSession[]): SelectableList<ManagedSession> {
+		return new SelectableList(this.theme, {
+			items,
+			emptyMessage: tab === "active" ? "No saved sessions." : "No archived sessions.",
+			selection: { kind: "multi" },
+			maxVisible: 14,
+			actions:
+				tab === "active"
+					? [
+							{ id: "archive", key: "a", hint: rawHint("a", "archive"), target: "currentOrSelection" },
+							{
+								id: "archiveOlder",
+								key: Key.shift("a"),
+								hint: rawHint("A", "archive older"),
+								target: "olderThanCursor",
+							},
+							{ id: "delete", key: "d", hint: rawHint("d", "delete"), target: "currentOrSelection" },
+							{
+								id: "deleteOlder",
+								key: Key.shift("d"),
+								hint: rawHint("D", "delete older"),
+								target: "olderThanCursor",
+							},
+						]
+					: [
+							{ id: "unarchive", key: "u", hint: rawHint("u", "unarchive"), target: "currentOrSelection" },
+							{
+								id: "unarchiveOlder",
+								key: Key.shift("u"),
+								hint: rawHint("U", "unarchive older"),
+								target: "olderThanCursor",
+							},
+							{ id: "delete", key: "d", hint: rawHint("d", "delete"), target: "currentOrSelection" },
+							{
+								id: "deleteOlder",
+								key: Key.shift("d"),
+								hint: rawHint("D", "delete older"),
+								target: "olderThanCursor",
+							},
+						],
+			renderItem: (item, state, width) => this.renderRow(item, state.active, width),
+			onResult: (result) => {
+				if (result.kind === "action") this.prepareAction(tab, result);
+			},
+			onSelectionChange: () => {},
+		});
+	}
+
+	private handleInput(data: string): void {
+		if (this.executing) return;
+		const keybindings = getKeybindings();
+
+		if (this.pending) {
+			if (keybindings.matches(data, "tui.select.confirm")) {
+				void this.confirmPending();
+				return;
+			}
+			if (keybindings.matches(data, "tui.select.cancel")) {
+				this.pending = undefined;
+				this.syncPanel();
+				return;
+			}
+			return;
+		}
+
+		if (matchesKey(data, Key.enter)) return;
+		if (matchesKey(data, Key.escape)) {
+			this.done();
+			return;
+		}
+		if (matchesKey(data, "s")) {
+			void this.toggleScope();
+			return;
+		}
+
+		this.tabs.handleInput(data);
+		this.syncPanel();
+	}
+
+	private prepareAction(tab: TabId, result: SelectableListActionResult<ManagedSession>): void {
+		if (result.items.length === 0) {
+			this.ctx.ui.notify(
+				result.target === "olderThanCursor" ? "No older sessions." : "No sessions selected.",
+				"info",
+			);
+			return;
+		}
+
+		const kind = result.actionId.startsWith("archive")
+			? "archive"
+			: result.actionId.startsWith("unarchive")
+				? "unarchive"
+				: "delete";
+		this.pending = { kind, items: result.items, tab };
+		this.syncPanel();
+	}
+
+	private async confirmPending(): Promise<void> {
+		const pending = this.pending;
+		if (!pending) return;
+		this.pending = undefined;
+		this.executing = true;
+
+		let failures = 0;
+		for (const session of pending.items) {
+			try {
+				if (pending.kind === "archive") await archiveSession(session.path);
+				else if (pending.kind === "unarchive") await unarchiveSession(session.path);
+				else await deleteSessionFile(session.path);
+			} catch (error) {
+				failures++;
+				this.ctx.ui.notify(`${preview(session.name, 40)}: ${errorText(error)}`, "error");
+			}
+		}
+
+		await this.reload();
+		this.listFor(pending.tab).clearSelection();
+		this.executing = false;
+		this.ctx.ui.notify(
+			this.resultMessage(pending.kind, pending.items.length - failures, failures),
+			failures ? "error" : "info",
+		);
+		this.syncPanel();
+	}
+
+	private async toggleScope(): Promise<void> {
+		this.scope = this.scope === "current" ? "all" : "current";
+		this.activeList.clearSelection();
+		this.archiveList.clearSelection();
+		await this.reload();
+		this.syncPanel();
+	}
+
+	private async reload(): Promise<void> {
+		try {
+			const sessions = await listManagedSessions(this.ctx.cwd, this.scope, this.currentSessionFile);
+			this.active = sessions.active;
+			this.archive = sessions.archive;
+			this.activeList.setItems(this.active);
+			this.archiveList.setItems(this.archive);
+			this.tabs.setTabs(this.tabItems());
+		} catch (error) {
+			this.ctx.ui.notify(`Could not load sessions: ${errorText(error)}`, "error");
+		}
+	}
+
+	private syncPanel(): void {
+		this.panelConfig.secondary = this.secondaryText();
+		this.panelConfig.footer = this.pending
+			? {
+					kind: "destructiveAck",
+					message: this.pendingMessage(this.pending),
+					hints: [bindingHint("tui.select.confirm", "confirm"), bindingHint("tui.select.cancel", "cancel")],
+				}
+			: { kind: "hints", hints: this.footerHints() };
+		this.requestRender();
+	}
+
+	private tabItems() {
+		return [
+			{
+				id: "active",
+				label: "Sessions",
+				count: this.active.length,
+				body: this.activeList,
+				getKeyHints: () => this.activeList.getKeyHints(),
+			},
+			{
+				id: "archive",
+				label: "Archive",
+				count: this.archive.length,
+				body: this.archiveList,
+				getKeyHints: () => this.archiveList.getKeyHints(),
+			},
+		];
+	}
+
+	private footerHints(): readonly ToolKeyHint[] {
+		return [
+			...this.tabs.getKeyHints(),
+			rawHint("s", this.scope === "current" ? "all projects" : "current folder"),
+			bindingHint("tui.select.cancel", "close"),
+		];
+	}
+
+	private renderRow(item: ManagedSession, active: boolean, width: number): string[] {
+		const path = this.scope === "all" && item.cwd ? shortenPath(item.cwd) : undefined;
+		const age = formatAge(item.modified.getTime());
+		const count = item.messageCount > 0 ? `${item.messageCount} msgs` : undefined;
+		const requiredSuffix = [path, age].filter((part) => part !== undefined).join("  ");
+		const fullSuffix = [path, count, age].filter((part) => part !== undefined).join("  ");
+		const fullSuffixFits = visibleWidth(fullSuffix) + 9 <= width;
+		const suffix = this.theme.fg("dim", count && fullSuffixFits ? fullSuffix : requiredSuffix);
+		const nameWidth = Math.max(8, width - visibleWidth(suffix) - 1);
+		const name = this.theme.fg(active ? "accent" : "text", preview(item.name, nameWidth));
+		return [truncateToWidth(`${name} ${suffix}`, width, "")];
+	}
+
+	private listFor(tab: TabId): SelectableList<ManagedSession> {
+		return tab === "active" ? this.activeList : this.archiveList;
+	}
+
+	private secondaryText(): string {
+		return `scope: ${this.scope === "current" ? "current folder" : "all projects"} · archive: ${getArchiveRoot()}`;
+	}
+
+	private pendingMessage(action: PendingAction): string {
+		const verb = action.kind === "archive" ? "Archive" : action.kind === "unarchive" ? "Unarchive" : "Delete";
+		return `${verb} ${action.items.length} session${action.items.length === 1 ? "" : "s"}?`;
+	}
+
+	private resultMessage(kind: PendingKind, count: number, failures: number): string {
+		const verb = kind === "archive" ? "Archived" : kind === "unarchive" ? "Unarchived" : "Deleted";
+		const base = `${verb} ${count} session${count === 1 ? "" : "s"}.`;
+		return failures > 0 ? `${base} ${failures} failed.` : base;
+	}
+}
+
+function shortenPath(cwd: string): string {
+	const home = homedir();
+	if (cwd === home) return "~";
+	if (cwd.startsWith(`${home}/`)) return `~/${relative(home, cwd)}`;
+	return cwd;
+}

package/extensions/manage-sessions/sessions.ts

@@ -0,0 +1,126 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, rename, unlink } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { getAgentDir, type SessionInfo, SessionManager } from "@earendil-works/pi-coding-agent";
+
+export type SessionScope = "current" | "all";
+
+export interface ManagedSession {
+	id: string;
+	path: string;
+	name: string;
+	cwd: string;
+	modified: Date;
+	messageCount: number;
+}
+
+function getSessionsRoot(): string {
+	return join(getAgentDir(), "sessions");
+}
+
+export function getArchiveRoot(): string {
+	return join(getAgentDir(), "session-archive");
+}
+
+export async function listManagedSessions(
+	cwd: string,
+	scope: SessionScope,
+	currentSessionFile?: string,
+): Promise<{ active: ManagedSession[]; archive: ManagedSession[] }> {
+	const currentSessionPath = currentSessionFile ? resolve(currentSessionFile) : undefined;
+	const activeSessions = scope === "current" ? await SessionManager.list(cwd) : await SessionManager.listAll();
+	const active = activeSessions
+		.filter((session) => resolve(session.path) !== currentSessionPath)
+		.map(toManagedSession);
+
+	if (scope === "current") {
+		// Mirrors Pi's default session dir encoding so archive paths match active paths.
+		const safeCwd = `--${resolve(cwd)
+			.replace(/^[/\\]/, "")
+			.replace(/[/\\:]/g, "-")}--`;
+		const archiveProjectDir = join(getArchiveRoot(), safeCwd);
+		return {
+			active,
+			archive: (await SessionManager.list(cwd, archiveProjectDir)).map(toManagedSession),
+		};
+	}
+
+	let archive: ManagedSession[] = [];
+	try {
+		const projectDirs = (await readdir(getArchiveRoot(), { withFileTypes: true }))
+			.filter((entry) => entry.isDirectory())
+			.map((entry) => join(getArchiveRoot(), entry.name));
+
+		for (const projectDir of projectDirs) {
+			archive = archive.concat((await SessionManager.listAll(projectDir)).map(toManagedSession));
+		}
+	} catch {
+		archive = [];
+	}
+
+	archive.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+	return { active, archive };
+}
+
+export async function archiveSession(sessionPath: string): Promise<void> {
+	const relativePath = relative(getSessionsRoot(), sessionPath);
+	if (relativePath === "" || relativePath === ".." || relativePath.startsWith("../") || isAbsolute(relativePath)) {
+		throw new Error("Cannot archive session outside sessions root.");
+	}
+
+	const destination = join(getArchiveRoot(), relativePath);
+	if (existsSync(destination)) {
+		throw new Error("Archived session already exists.");
+	}
+
+	await mkdir(dirname(destination), { recursive: true });
+	await rename(sessionPath, destination);
+}
+
+export async function unarchiveSession(sessionPath: string): Promise<void> {
+	const relativePath = relative(getArchiveRoot(), sessionPath);
+	if (relativePath === "" || relativePath === ".." || relativePath.startsWith("../") || isAbsolute(relativePath)) {
+		throw new Error("Cannot unarchive session outside archive root.");
+	}
+
+	const destination = join(getSessionsRoot(), relativePath);
+	if (existsSync(destination)) {
+		throw new Error("Active session already exists.");
+	}
+
+	await mkdir(dirname(destination), { recursive: true });
+	await rename(sessionPath, destination);
+}
+
+export async function deleteSessionFile(sessionPath: string): Promise<{ method: "trash" | "unlink" }> {
+	const trashArgs = sessionPath.startsWith("-") ? ["--", sessionPath] : [sessionPath];
+	const trashResult = spawnSync("trash", trashArgs, { encoding: "utf-8" });
+
+	if (trashResult.status === 0 || !existsSync(sessionPath)) {
+		return { method: "trash" };
+	}
+
+	try {
+		await unlink(sessionPath);
+		return { method: "unlink" };
+	} catch (error) {
+		const unlinkError = error instanceof Error ? error.message : String(error);
+		const trashDetails = [trashResult.error?.message, trashResult.stderr?.trim().split("\n")[0]].filter(
+			(detail) => detail && detail.length > 0,
+		);
+		const trashError = trashDetails.length > 0 ? ` (trash: ${trashDetails.join(" · ").slice(0, 200)})` : "";
+		throw new Error(`Delete failed: ${unlinkError}${trashError}`);
+	}
+}
+
+function toManagedSession(session: SessionInfo): ManagedSession {
+	return {
+		id: session.path,
+		path: session.path,
+		name: session.name ?? session.firstMessage,
+		cwd: session.cwd,
+		modified: session.modified,
+		messageCount: session.messageCount,
+	};
+}

package/extensions/patch/README.md

@@ -0,0 +1,48 @@
+# patch
+
+Replaces the built-in `edit` and `write` tools with one multi-file patch tool. The agent applies structured patches to create, edit, move, and delete files while this extension is active.
+
+## What it does
+
+Registers a `patch` tool that accepts a Codex-style patch body: one envelope, one or more file sections. It supports new files, full rewrites, contextual edits, renames, and deletions. Tau also supports `*** Replace File:` for explicit full-file replacement.
+
+Malformed patch envelopes fail without changing files. Section-level failures — parse errors, duplicate paths, missing files, match failures, and existing move targets — fail those sections while independent valid sections still apply.
+
+## How to use
+
+Patch marker lines may have leading/trailing whitespace.
+
+Tool arguments must put the patch in the `input` string. Do not use the patch body as a JSON object key.
+
+```json
+{
+ "input": "*** Begin Patch\n*** Add File: path/to/new.ts\n+file content here\n*** End Patch"
+}
+```
+
+```text
+*** Begin Patch
+*** Add File: path/to/new.ts
++file content here
+*** Replace File: path/to/existing-full-rewrite.ts
++full replacement content here
+*** Update File: path/to/existing.ts
+ context line
+-old line
++new line
+*** Update File: path/to/old-location.ts
+*** Move to: path/to/new-location.ts
+ const handler = () => {}
+-module.exports = handler;
++export default handler;
+*** Delete File: path/to/remove.ts
+*** End Patch
+```
+
+- **Add File** — writes whole-file content. Only `+` lines become file content. May overwrite existing files.
+- **Replace File** — writes whole-file content and reports as a replacement. Only `+` lines become file content.
+- **Update File** — edits existing files with context, removal, and addition lines. Unanchored repeated matches use the first forward match. A pure `+` hunk appends to EOF; include context body lines for positional inserts.
+- **Move to** — appears immediately after an Update File header. The target must not already exist.
+- **Delete File** — removes an existing file.
+
+If an update match fails, reread the current file and retry with corrected context.