@shanepadgett/tau-agent 0.1.0

package/extensions/footer/index.ts

@@ -0,0 +1,534 @@
+// lean: footer mixes git-status parse + usage/cost math + render; high churn
+// (fallow hotspot). Do NOT proactive-split — wait for a change that forces a
+// natural seam, then extract that concern only.
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, relative } from "node:path";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { type Component, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { onTauEvent } from "../../shared/events.ts";
+import { loadTauExtensionSettings, updateTauExtensionSettings } from "../../shared/settings/load.ts";
+import footerSettings from "./settings.ts";
+
+interface FooterItem {
+	id: string;
+	priority: number;
+	text: string;
+}
+
+interface GitSummary {
+	branch: string;
+	text: string;
+}
+
+interface UsageSummary {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	latestCacheHitRate: number | undefined;
+	cost: number;
+}
+
+const COMMAND = "footer";
+const USAGE = "Usage: /footer [on|off|refresh]";
+
+export default function footerExtension(pi: ExtensionAPI): void {
+	let enabled = true;
+	let activeCtx: ExtensionContext | undefined;
+	let footerInstalled = false;
+	let requestRender: (() => void) | undefined;
+	let unsubscribeFooterItems: (() => void) | undefined;
+	const gitByCwd = new Map<string, GitSummary | undefined>();
+	let gitRefresh: Promise<void> | undefined;
+	let dailyCost: number | undefined;
+	let dailyRefresh: Promise<void> | undefined;
+	const items = new Map<string, FooterItem>();
+
+	function render(): void {
+		requestRender?.();
+	}
+
+	function setActiveCtx(ctx: ExtensionContext): void {
+		activeCtx = ctx;
+		if (enabled && !footerInstalled) installFooter(ctx);
+	}
+
+	function installFooter(ctx: ExtensionContext): void {
+		footerInstalled = true;
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			requestRender = () => tui.requestRender();
+			const unsubscribeBranch = footerData.onBranchChange(() => {
+				void refreshGit(ctx).then(render);
+			});
+
+			return {
+				dispose() {
+					unsubscribeBranch();
+					if (requestRender) requestRender = undefined;
+				},
+				invalidate() {
+					render();
+				},
+				render(width: number): string[] {
+					if (!enabled) return [];
+					const currentCtx = activeCtx ?? ctx;
+					const git = gitByCwd.get(currentCtx.cwd);
+					const model = currentCtx.model ? `${currentCtx.model.provider}/${currentCtx.model.id}` : "no-model";
+					const thinking = pi.getThinkingLevel();
+					const topLeft = [gitText(git), `${model} (${thinking})`].filter(Boolean).join(" • ");
+					const sessionUsage = sessionCost(currentCtx);
+					const session = formatCost(sessionUsage.cost);
+					const daily = dailyCost === undefined ? "$?" : formatCost(dailyCost);
+					const topRight = statsText(theme, currentCtx, sessionUsage, session, daily);
+					const bottomLeft = [shortenPath(currentCtx.cwd), sessionName(currentCtx)].filter(Boolean).join(" • ");
+					const bottomRight = [extensionStatusesText(footerData.getExtensionStatuses()), footerItemsText(items)]
+						.filter(Boolean)
+						.join(" • ");
+
+					return [
+						renderSplit(width, theme.fg("dim", topLeft), topRight),
+						renderSplit(width, theme.fg("dim", bottomLeft), theme.fg("dim", bottomRight)),
+					];
+				},
+			} satisfies Component & { dispose(): void; invalidate(): void };
+		});
+	}
+
+	async function refreshGit(ctx: ExtensionContext): Promise<void> {
+		if (gitRefresh) return gitRefresh;
+		const cwd = ctx.cwd;
+		gitRefresh = (async () => {
+			const result = await pi.exec(
+				"git",
+				["--no-optional-locks", "status", "--porcelain=v1", "--branch", "--untracked-files=normal"],
+				{ cwd, timeout: 1_000 },
+			);
+			gitByCwd.set(cwd, result.code === 0 ? parseGitStatus(result.stdout) : undefined);
+		})()
+			.catch(() => {
+				gitByCwd.set(cwd, undefined);
+			})
+			.finally(() => {
+				gitRefresh = undefined;
+			});
+		return gitRefresh;
+	}
+
+	async function refreshDailyCost(): Promise<void> {
+		if (dailyRefresh) return dailyRefresh;
+		dailyRefresh = scanDailyCost()
+			.then((cost) => {
+				dailyCost = cost;
+			})
+			.catch(() => {})
+			.finally(() => {
+				dailyRefresh = undefined;
+			});
+		return dailyRefresh;
+	}
+
+	function refresh(ctx: ExtensionContext, includeDaily = true): void {
+		const tasks = includeDaily ? [refreshGit(ctx), refreshDailyCost()] : [refreshGit(ctx)];
+		void Promise.all(tasks).then(render);
+	}
+
+	function rerender(ctx: ExtensionContext): void {
+		setActiveCtx(ctx);
+		render();
+	}
+
+	function setEnabled(ctx: ExtensionContext, next: boolean): void {
+		enabled = next;
+		if (enabled) {
+			installFooter(ctx);
+			refresh(ctx);
+			return;
+		}
+		ctx.ui.setFooter(undefined);
+		footerInstalled = false;
+	}
+
+	unsubscribeFooterItems = onTauEvent(pi, "footer.items", "tau:footer-item", (item) => {
+		if (!item.id.trim()) return;
+		const text = item.text?.trim();
+		const existing = items.get(item.id);
+		if (!text) {
+			if (!existing) return;
+			items.delete(item.id);
+			render();
+			return;
+		}
+
+		const next = { id: item.id, priority: item.priority ?? 0, text };
+		if (existing?.priority === next.priority && existing.text === next.text) return;
+		items.set(item.id, next);
+		render();
+	});
+
+	pi.registerCommand(COMMAND, {
+		description: "Toggle Tau footer",
+		handler: async (args, ctx) => {
+			await ctx.waitForIdle();
+			setActiveCtx(ctx);
+
+			const arg = args.trim().toLowerCase();
+			if (!arg) {
+				const next = !enabled;
+				setEnabled(ctx, next);
+				await saveEnabled(ctx, next);
+				ctx.ui.notify(enabled ? "Footer enabled" : "Footer disabled", "info");
+				return;
+			}
+
+			if (arg === "on" || arg === "off") {
+				const next = arg === "on";
+				setEnabled(ctx, next);
+				await saveEnabled(ctx, next);
+				ctx.ui.notify(enabled ? "Footer enabled" : "Footer disabled", "info");
+				return;
+			}
+
+			if (arg === "refresh") {
+				refresh(ctx);
+				ctx.ui.notify("Footer refresh started", "info");
+				return;
+			}
+
+			ctx.ui.notify(USAGE, "error");
+		},
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		const settings = await loadTauExtensionSettings(ctx, footerSettings);
+		setEnabled(ctx, settings.enabled);
+		onStateChange(ctx);
+	});
+	pi.on("session_tree", (_event, ctx) => onStateChange(ctx, false));
+	pi.on("model_select", (_event, ctx) => rerender(ctx));
+	pi.on("thinking_level_select", (_event, ctx) => rerender(ctx));
+	pi.on("agent_start", (_event, ctx) => onStateChange(ctx, false));
+	pi.on("turn_end", (_event, ctx) => onStateChange(ctx));
+	pi.on("agent_end", (_event, ctx) => onStateChange(ctx));
+
+	pi.on("session_shutdown", (_event, ctx) => {
+		unsubscribeFooterItems?.();
+		unsubscribeFooterItems = undefined;
+		requestRender = undefined;
+		activeCtx = undefined;
+		footerInstalled = false;
+		ctx.ui.setFooter(undefined);
+	});
+
+	function onStateChange(ctx: ExtensionContext, includeDaily = true): void {
+		setActiveCtx(ctx);
+		refresh(ctx, includeDaily);
+	}
+}
+
+async function saveEnabled(ctx: ExtensionContext, enabled: boolean): Promise<void> {
+	await updateTauExtensionSettings("global", ctx, footerSettings, (current) => ({ ...current, enabled }));
+}
+
+function parseGitStatus(stdout: string): GitSummary | undefined {
+	let branch = "";
+	let staged = 0;
+	let modified = 0;
+	let untracked = 0;
+	let conflicts = 0;
+
+	for (const line of stdout.split("\n")) {
+		if (!line) continue;
+		if (line.startsWith("## ")) {
+			branch = line.slice(3).split("...")[0]?.trim() ?? "";
+			continue;
+		}
+
+		const x = line[0];
+		const y = line[1];
+		if (x === "?" && y === "?") {
+			untracked += 1;
+			continue;
+		}
+		if (isConflict(x, y)) {
+			conflicts += 1;
+			continue;
+		}
+		if (x && x !== " ") staged += 1;
+		if (y && y !== " ") modified += 1;
+	}
+
+	if (!branch) return undefined;
+	const parts = [
+		staged ? `+${staged}` : "",
+		modified ? `~${modified}` : "",
+		untracked ? `?${untracked}` : "",
+		conflicts ? `!${conflicts}` : "",
+	].filter(Boolean);
+	return { branch, text: parts.length ? parts.join(" ") : "clean" };
+}
+
+function gitText(git: GitSummary | undefined): string {
+	if (!git) return "";
+	return git.text === "clean" ? git.branch : `${git.branch} (${git.text})`;
+}
+
+function isConflict(x: string | undefined, y: string | undefined): boolean {
+	return x === "U" || y === "U" || (x === "A" && y === "A") || (x === "D" && y === "D");
+}
+
+function sessionCost(ctx: ExtensionContext): UsageSummary {
+	let usage = zeroUsage();
+	for (const entry of ctx.sessionManager.getBranch()) {
+		if (entry.type !== "message") continue;
+		if (entry.message.role === "assistant") {
+			usage = addUsage(usage, normalizeUsage((entry.message as AssistantMessage).usage));
+			continue;
+		}
+		if (entry.message.role !== "toolResult" || entry.message.toolName !== "subagent") continue;
+		const childUsage = subagentUsage(entry.message.details);
+		if (childUsage) usage = addUsage(usage, childUsage);
+	}
+	return usage;
+}
+
+function statsText(theme: Theme, ctx: ExtensionContext, usage: UsageSummary, session: string, daily: string): string {
+	const tokens = [
+		`↑${formatTokens(usage.input)}`,
+		`↓${formatTokens(usage.output)}`,
+		`R${formatTokens(usage.cacheRead)}`,
+		`W${formatTokens(usage.cacheWrite)}`,
+	];
+	if ((usage.cacheRead || usage.cacheWrite) && usage.latestCacheHitRate !== undefined)
+		tokens.push(`CH${usage.latestCacheHitRate.toFixed(1)}%`);
+	return [contextText(theme, ctx), theme.fg("dim", tokens.join(" ")), theme.fg("dim", `S|${session} D|${daily}`)]
+		.filter(Boolean)
+		.join(theme.fg("dim", " • "));
+}
+
+function contextText(theme: Theme, ctx: ExtensionContext): string {
+	const usage = ctx.getContextUsage();
+	const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+	const percentValue = typeof usage?.percent === "number" ? usage.percent : undefined;
+	const percent = percentValue === undefined ? "?" : `${percentValue.toFixed(1)}%`;
+	return `${theme.fg(contextPercentColor(percentValue), percent)}${theme.fg("dim", `/${formatTokens(contextWindow)}`)}`;
+}
+
+function contextPercentColor(percent: number | undefined): ThemeColor {
+	if (percent === undefined) return "dim";
+	if (percent > 80) return "error";
+	if (percent > 50) return "warning";
+	return "dim";
+}
+
+function formatTokens(count: number): string {
+	if (count < 1000) return `${Math.round(count)}`;
+	if (count < 10_000) return `${(count / 1000).toFixed(1)}k`;
+	if (count < 1_000_000) return `${Math.round(count / 1000)}k`;
+	if (count < 10_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+	return `${Math.round(count / 1_000_000)}M`;
+}
+
+async function scanDailyCost(): Promise<number> {
+	const range = localDayRange(Date.now());
+	const seen = new Set<string>();
+	let total = 0;
+
+	for (const path of await sessionFiles()) {
+		try {
+			if ((await stat(path)).mtimeMs < range.startMs) continue;
+			const raw = await readFile(path, "utf8");
+			for (const line of raw.split("\n")) {
+				const entry = parseRecord(line);
+				if (!entry || entry.type !== "message") continue;
+				const message = asRecord(entry.message);
+				if (!message) continue;
+				const timestamp = timestampMs(message.timestamp, entry.timestamp);
+				if (timestamp < range.startMs || timestamp >= range.endMs) continue;
+				let usage: UsageSummary;
+				let identity: unknown[];
+				if (message.role === "assistant") {
+					usage = normalizeUsage(message.usage);
+					identity = [message.provider, message.model];
+				} else if (message.role === "toolResult" && message.toolName === "subagent") {
+					const childUsage = subagentUsage(message.details);
+					if (!childUsage) continue;
+					usage = childUsage;
+					identity = ["subagent", message.toolCallId];
+				} else continue;
+				const key = [
+					...identity,
+					timestamp,
+					usage.input,
+					usage.output,
+					usage.cacheRead,
+					usage.cacheWrite,
+					usage.cost,
+				].join(":");
+				if (seen.has(key)) continue;
+				seen.add(key);
+				total += usage.cost;
+			}
+		} catch {
+			// One bad session file should not break the footer.
+		}
+	}
+
+	return total;
+}
+
+async function sessionFiles(): Promise<string[]> {
+	const root = join(homedir(), ".pi", "agent", "sessions");
+	const files: string[] = [];
+	try {
+		for (const dir of await readdir(root, { withFileTypes: true })) {
+			if (!dir.isDirectory()) continue;
+			const child = join(root, dir.name);
+			for (const file of await readdir(child, { withFileTypes: true })) {
+				if (file.isFile() && file.name.endsWith(".jsonl")) files.push(join(child, file.name));
+			}
+		}
+	} catch {
+		return [];
+	}
+	return files;
+}
+
+function parseRecord(line: string): Record<string, unknown> | undefined {
+	const trimmed = line.trim();
+	if (!trimmed) return undefined;
+	try {
+		return asRecord(JSON.parse(trimmed));
+	} catch {
+		return undefined;
+	}
+}
+
+function normalizeUsage(value: unknown): UsageSummary {
+	const record = asRecord(value);
+	const cost = asRecord(record?.cost);
+	const input = numberOrZero(record?.input);
+	const output = numberOrZero(record?.output);
+	const cacheRead = numberOrZero(record?.cacheRead);
+	const cacheWrite = numberOrZero(record?.cacheWrite);
+	const promptTokens = input + cacheRead + cacheWrite;
+	const costTotal =
+		numberOrZero(cost?.total) ||
+		numberOrZero(cost?.input) +
+			numberOrZero(cost?.output) +
+			numberOrZero(cost?.cacheRead) +
+			numberOrZero(cost?.cacheWrite);
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		latestCacheHitRate: promptTokens > 0 ? (cacheRead / promptTokens) * 100 : undefined,
+		cost: costTotal,
+	};
+}
+
+function subagentUsage(details: unknown): UsageSummary | undefined {
+	const usage = asRecord(asRecord(details)?.usage);
+	if (!usage) return undefined;
+	const input = numberOrZero(usage.input);
+	const output = numberOrZero(usage.output);
+	const cacheRead = numberOrZero(usage.cacheRead);
+	const cacheWrite = numberOrZero(usage.cacheWrite);
+	const promptTokens = input + cacheRead + cacheWrite;
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		latestCacheHitRate: promptTokens > 0 ? (cacheRead / promptTokens) * 100 : undefined,
+		cost: numberOrZero(usage.cost),
+	};
+}
+
+function addUsage(left: UsageSummary, right: UsageSummary): UsageSummary {
+	return {
+		input: left.input + right.input,
+		output: left.output + right.output,
+		cacheRead: left.cacheRead + right.cacheRead,
+		cacheWrite: left.cacheWrite + right.cacheWrite,
+		latestCacheHitRate: right.latestCacheHitRate ?? left.latestCacheHitRate,
+		cost: left.cost + right.cost,
+	};
+}
+
+function zeroUsage(): UsageSummary {
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, latestCacheHitRate: undefined, cost: 0 };
+}
+
+function timestampMs(messageTimestamp: unknown, entryTimestamp: unknown): number {
+	if (typeof messageTimestamp === "number") return messageTimestamp;
+	if (typeof entryTimestamp === "string") return Date.parse(entryTimestamp);
+	return Number.NaN;
+}
+
+function localDayRange(nowMs: number): { endMs: number; startMs: number } {
+	const start = new Date(nowMs);
+	start.setHours(0, 0, 0, 0);
+	const end = new Date(start);
+	end.setDate(end.getDate() + 1);
+	return { startMs: start.getTime(), endMs: end.getTime() };
+}
+
+function footerItemsText(items: ReadonlyMap<string, FooterItem>): string {
+	return [...items.values()]
+		.sort((left, right) => right.priority - left.priority || left.id.localeCompare(right.id))
+		.map((item) => item.text)
+		.join(" • ");
+}
+
+function extensionStatusesText(statuses: ReadonlyMap<string, string>): string {
+	return [...statuses]
+		.filter(([, text]) => text.trim())
+		.sort(([left], [right]) => left.localeCompare(right))
+		.map(([, text]) => text.trim())
+		.join(" • ");
+}
+
+function renderSplit(width: number, left: string, right: string): string {
+	if (width <= 0) return "";
+	const rightWidth = visibleWidth(right);
+	if (!right) return truncateToWidth(left, width);
+	if (!left) return truncateToWidth(right, width);
+	const leftWidth = Math.max(0, width - rightWidth - 1);
+	if (leftWidth <= 0) return truncateToWidth(right, width);
+	const clippedLeft = truncateToWidth(left, leftWidth);
+	const pad = " ".repeat(Math.max(1, width - visibleWidth(clippedLeft) - rightWidth));
+	return truncateToWidth(`${clippedLeft}${pad}${right}`, width);
+}
+
+function shortenPath(cwd: string): string {
+	const home = homedir();
+	if (cwd === home) return "~";
+	if (cwd.startsWith(`${home}/`)) return `~/${relative(home, cwd)}`;
+	return cwd;
+}
+
+function sessionName(ctx: ExtensionContext): string {
+	const entries = ctx.sessionManager.getEntries();
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const entry = entries[index];
+		if (entry?.type !== "session_info") continue;
+		const name = entry.name?.trim();
+		if (name) return name;
+	}
+	return "";
+}
+
+function formatCost(value: number): string {
+	return `$${value.toFixed(2)}`;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" ? (value as Record<string, unknown>) : undefined;
+}
+
+function numberOrZero(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}

package/extensions/footer/settings.ts

@@ -0,0 +1,13 @@
+import { Type } from "typebox";
+import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
+
+export default defineTauExtensionSettings({
+	key: "footer",
+	defaults: { enabled: true as boolean },
+	schema: Type.Object(
+		{
+			enabled: Type.Optional(Type.Boolean({ default: true, description: "Enable Tau's compact footer." })),
+		},
+		{ additionalProperties: false },
+	),
+});

package/extensions/ideas/README.md

@@ -0,0 +1,10 @@
+# Ideas
+
+Capture rough, unrefined ideas for the current repository without turning them
+into plans or committed docs too early.
+
+Use `/ideas <text>` to park a thought. Use `/ideas` in the TUI to browse, edit,
+delete, or load an idea back into the prompt when it is ready to shape into a
+request.
+
+Rough ideas are not plans. This is the parking lot.

package/extensions/ideas/browser.ts

@@ -0,0 +1,66 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { Key } from "@earendil-works/pi-tui";
+import { rawHint } from "@shanepadgett/tau-tui";
+import {
+	createTextRecordSelectPanel,
+	type TextRecordSelectPanelConfig,
+	type TextRecordSelectResult,
+} from "@shanepadgett/tau-tui";
+import { deleteIdea, type Idea, ideasFilePath, loadIdeas, updateIdea } from "./store.ts";
+
+const CONFIG: Omit<TextRecordSelectPanelConfig, "path"> = {
+	title: "Ideas",
+	emptyMessage: "No ideas yet. Use /ideas <text> to log one.",
+	primaryLabel: "insert",
+	expandActiveItem: true,
+	actions: [
+		{ id: "edit", key: Key.ctrl("e"), hint: rawHint("ctrl+e", "edit") },
+		{ id: "delete", key: Key.ctrl("d"), hint: rawHint("ctrl+d", "delete") },
+	],
+};
+
+export async function browseIdeas(ctx: ExtensionCommandContext): Promise<Idea | undefined> {
+	if (ctx.mode !== "tui" || !ctx.hasUI) {
+		ctx.ui.notify("Ideas browser requires TUI mode.", "error");
+		return undefined;
+	}
+
+	const path = await ideasFilePath(ctx.cwd);
+
+	while (true) {
+		const ideas = await loadIdeas(ctx.cwd);
+		const result = await show(ctx, ideas, path);
+
+		if (result.kind === "cancel") return undefined;
+		if (result.kind === "primary") return result.item;
+
+		if (result.actionId === "delete") {
+			const ok = await ctx.ui.confirm("Delete idea?", result.item.text);
+			if (ok) {
+				await deleteIdea(ctx.cwd, result.item.id);
+				ctx.ui.notify("Idea deleted.", "info");
+			}
+			continue;
+		}
+
+		// edit: native multiline editor, prefilled with the current text.
+		const edited = await ctx.ui.editor("Edit idea", result.item.text);
+		if (edited == null) continue;
+		if (!edited.trim()) {
+			ctx.ui.notify("Edit cancelled (empty).", "info");
+			continue;
+		}
+		await updateIdea(ctx.cwd, result.item.id, edited);
+		ctx.ui.notify("Idea updated.", "info");
+	}
+}
+
+async function show(
+	ctx: ExtensionCommandContext,
+	ideas: readonly Idea[],
+	path: string,
+): Promise<TextRecordSelectResult<Idea>> {
+	return ctx.ui.custom<TextRecordSelectResult<Idea>>((_tui, theme, _keybindings, done) =>
+		createTextRecordSelectPanel(theme, ideas, { ...CONFIG, path }, done),
+	);
+}

package/extensions/ideas/index.ts

@@ -0,0 +1,31 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { preview } from "../../shared/text.ts";
+import { browseIdeas } from "./browser.ts";
+import { addIdea } from "./store.ts";
+
+export default function ideasExtension(pi: ExtensionAPI): void {
+	pi.registerCommand("ideas", {
+		description: "Log a rough idea for this repo, or browse ideas with no args",
+		handler: async (args, ctx) => {
+			await ctx.waitForIdle();
+
+			const text = args.trim();
+			if (text) {
+				const idea = await addIdea(ctx.cwd, text);
+				ctx.ui.notify(`Logged idea: ${preview(idea.text, 60)}`, "info");
+				return;
+			}
+
+			if (ctx.mode !== "tui") {
+				ctx.ui.notify("Use /ideas <text> to log, or run in TUI to browse.", "info");
+				return;
+			}
+
+			const idea = await browseIdeas(ctx);
+			if (idea) {
+				ctx.ui.setEditorText(idea.text);
+				ctx.ui.notify("Idea loaded into the editor — edit and submit.", "info");
+			}
+		},
+	});
+}

package/extensions/ideas/store.ts

@@ -0,0 +1,32 @@
+import { appendRecord, type DatedRecord, loadRecords, recordFilePath, saveRecords } from "../../shared/jsonl-store.ts";
+
+export type Idea = DatedRecord;
+
+const IDEAS_FILENAME = "ideas.jsonl";
+const LABEL = "idea";
+
+export function ideasFilePath(cwd: string): Promise<string> {
+	return recordFilePath(cwd, IDEAS_FILENAME);
+}
+
+export function loadIdeas(cwd: string): Promise<Idea[]> {
+	return loadRecords(cwd, IDEAS_FILENAME, LABEL);
+}
+
+export function addIdea(cwd: string, text: string): Promise<Idea> {
+	return appendRecord(cwd, IDEAS_FILENAME, text);
+}
+
+export async function updateIdea(cwd: string, id: string, text: string): Promise<Idea[]> {
+	const ideas = await loadIdeas(cwd);
+	const next = ideas.map((idea) => (idea.id === id ? { ...idea, text: text.trim() } : idea));
+	await saveRecords(cwd, IDEAS_FILENAME, next);
+	return next;
+}
+
+export async function deleteIdea(cwd: string, id: string): Promise<Idea[]> {
+	const ideas = await loadIdeas(cwd);
+	const next = ideas.filter((idea) => idea.id !== id);
+	await saveRecords(cwd, IDEAS_FILENAME, next);
+	return next;
+}

package/extensions/image-gen/README.md

@@ -0,0 +1,11 @@
+# Image Generation
+
+`image_gen` generates raster images and edits up to five local raster images with OpenAI Codex. It uses the current `gpt-image-2` model and saves results under `~/.local/share/tau-agent/images/` by default. Pass an explicit PNG path when the image should be saved in the current repository or another chosen location.
+
+Use `/login` and select OpenAI Codex before invoking the tool. No `OPENAI_API_KEY` is needed.
+
+Run `/reload` after installing or changing the extension.
+
+The model invokes `image_gen` with a prompt. Size, quality, and background use the Codex automatic settings. For edits, it also supplies one to five local PNG, JPEG, or WebP paths. Successful PNGs up to 12 MiB are returned inline for inspection; larger results remain available at the saved path.
+
+This extension calls a private Codex backend. OpenAI may change its availability or protocol without notice.