@shanepadgett/tau-agent 0.16.0 → 0.18.0

package/extensions/context/index.ts

@@ -1,34 +1,82 @@
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
-import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { Type } from "typebox";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getKeybindings } from "@earendil-works/pi-tui";
 import { emitTauEvent } from "../../shared/events.ts";
 import { createGitRunner, loadRepoStatus } from "../../shared/git.ts";
 import { createInjectedContext } from "../../shared/injected-context.ts";
 import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
-import { ContextPanel } from "./panel.ts";
+import { ContextPanel, ContextSyncStatusPanel } from "./panel.ts";
 import { findProjectRoot, loadContextEntries, type ContextEntry } from "./definitions.ts";
+import { hideContextSyncEvidenceTool, registerContextSyncEvidenceTool } from "./evidence.ts";
 import contextSettings from "./settings.ts";
-import { runContextSync, type ContextSyncDetails } from "./sync.ts";
+import { runContextSync } from "./sync.ts";
 import { formatContextValidationFailure, validateContextCatalog } from "./validation.ts";
 
-const contextSyncParams = Type.Object({}, { additionalProperties: false });
+export default function contextExtension(pi: ExtensionAPI): void {
+	let settings = contextSettings.defaults;
+	let lastValidationFailure: string | undefined;
+	let syncCommandRegistered = false;
+
+	registerContextSyncEvidenceTool(pi);
 
-function compactResult(details: ContextSyncDetails) {
-	const value = {
-		outcome: details.outcome,
-		summary: details.summary,
-		reason: details.reason,
-		changedContextFiles: details.changedContextFiles,
+	const refreshSettings = async (ctx: { cwd: string; isProjectTrusted(): boolean }) => {
+		settings = await loadTauExtensionSettings(ctx, contextSettings);
+		if (settings.sync.enabled) registerContextSyncCommand();
+		hideContextSyncEvidenceTool(pi);
 	};
-	return { content: [{ type: "text" as const, text: JSON.stringify(value) }], details };
-}
 
-export default function contextExtension(pi: ExtensionAPI): void {
-	let validationSettings = contextSettings.defaults.validation;
-	let lastValidationFailure: string | undefined;
-	const activeToolExecutions = new Map<string, { toolName: string; done: Promise<void>; complete: () => void }>();
+	const registerContextSyncCommand = () => {
+		if (syncCommandRegistered) return;
+		syncCommandRegistered = true;
+		pi.registerCommand("context-sync", {
+			description: "Synchronize repository context from current Git changes via context-sync subagent",
+			handler: async (args, ctx) => {
+				if (!(await loadTauExtensionSettings(ctx, contextSettings)).sync.enabled) {
+					ctx.ui.notify("Context sync is disabled in settings", "warning");
+					return;
+				}
+				if (ctx.mode !== "tui" || !ctx.isProjectTrusted()) {
+					ctx.ui.notify("/context-sync requires a trusted TUI project", "warning");
+					return;
+				}
+				await ctx.waitForIdle();
+				const controller = new AbortController();
+				const widget = showContextSyncWidget(ctx);
+				const stopListening = ctx.ui.onTerminalInput((data) => {
+					if (!getKeybindings().matches(data, "tui.select.cancel")) return;
+					if (!controller.signal.aborted) widget.update("Cancelling context sync");
+					controller.abort();
+					return { consume: true };
+				});
+				try {
+					const result = await runContextSync(pi, ctx, {
+						nudge: args.trim() || undefined,
+						signal: controller.signal,
+						onStatus: (status) => {
+							widget.update(status);
+						},
+					});
+					if (controller.signal.aborted) {
+						ctx.ui.notify("Context sync cancelled", "info");
+						return;
+					}
+					const level = result.outcome === "failed" ? "error" : "info";
+					ctx.ui.notify(result.summary, level);
+				} catch (error) {
+					ctx.ui.notify(
+						controller.signal.aborted
+							? "Context sync cancelled"
+							: `Context sync failed: ${error instanceof Error ? error.message : String(error)}`,
+						controller.signal.aborted ? "info" : "error",
+					);
+				} finally {
+					stopListening();
+					widget.clear();
+				}
+			},
+		});
+	};
 
 	pi.registerCommand("context", {
 		description: "Select repository context entries and inject their files",
@@ -85,98 +133,14 @@ export default function contextExtension(pi: ExtensionAPI): void {
 		},
 	});
 
-	pi.registerCommand("context-sync", {
-		description: "Synchronize repository context from current Git changes",
-		handler: async (args, ctx) => {
-			if (args.trim()) {
-				ctx.ui.notify("Usage: /context-sync", "warning");
-				return;
-			}
-			if (ctx.mode !== "tui" || !ctx.isProjectTrusted()) {
-				ctx.ui.notify("/context-sync requires a trusted TUI project", "warning");
-				return;
-			}
-			await ctx.waitForIdle();
-			ctx.ui.setStatus("context-sync", "synchronizing context");
-			try {
-				const result = await runContextSync(pi, ctx);
-				ctx.ui.notify(result.summary, "info");
-			} catch (error) {
-				ctx.ui.notify(`Context sync failed: ${error instanceof Error ? error.message : String(error)}`, "error");
-			} finally {
-				ctx.ui.setStatus("context-sync", undefined);
-			}
-		},
-	});
-
-	pi.registerTool(
-		defineTool<typeof contextSyncParams, ContextSyncDetails | undefined>({
-			name: "context_sync",
-			label: "context_sync",
-			description:
-				"Synchronize repository context membership after context validation reports changed, stale, or unassigned files.",
-			parameters: contextSyncParams,
-			async execute(id, _params, _signal, onUpdate, ctx) {
-				await Promise.all(
-					[...activeToolExecutions]
-						.filter(([toolCallId, execution]) => toolCallId !== id && execution.toolName !== "context_sync")
-						.map(([, execution]) => execution.done),
-				);
-				return compactResult(
-					await runContextSync(pi, ctx, (status) =>
-						onUpdate?.({ content: [{ type: "text", text: status }], details: undefined }),
-					),
-				);
-			},
-			renderCall(_args, theme, context) {
-				const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-				text.setText(theme.fg("toolTitle", "context_sync"));
-				return text;
-			},
-			renderResult(result, options, theme, context) {
-				const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-				const details = result.details;
-				const output = result.content.map((part) => (part.type === "text" ? part.text : "")).join("");
-				text.setText(
-					options.isPartial
-						? theme.fg("dim", output)
-						: context.expanded && details
-							? [
-									details.summary,
-									details.reason,
-									...details.changes.map((change) =>
-										change.action === "set-entry"
-											? `${change.action} ${change.tab}/${change.concept}/${change.entry}: ${change.files.join(", ")}`
-											: `${change.action} ${change.tab}/${change.concept}/${change.entry}`,
-									),
-									...details.changedContextFiles,
-								].join("\n")
-							: (details?.summary ?? theme.fg("error", output)),
-				);
-				return text;
-			},
-		}),
-	);
-
-	pi.on("tool_execution_start", (event) => {
-		let complete = () => {};
-		const done = new Promise<void>((resolve) => {
-			complete = resolve;
-		});
-		activeToolExecutions.set(event.toolCallId, { toolName: event.toolName, done, complete });
-	});
-
-	pi.on("tool_execution_end", (event) => {
-		const execution = activeToolExecutions.get(event.toolCallId);
-		activeToolExecutions.delete(event.toolCallId);
-		execution?.complete();
-	});
+	// Default on: register immediately so /context-sync exists before session_start in tests and early UI.
+	if (settings.sync.enabled) registerContextSyncCommand();
 
 	pi.on("session_start", async (_event, ctx) => {
-		validationSettings = (await loadTauExtensionSettings(ctx, contextSettings)).validation;
+		await refreshSettings(ctx);
 	});
 	pi.on("agent_start", async (_event, ctx) => {
-		validationSettings = (await loadTauExtensionSettings(ctx, contextSettings)).validation;
+		await refreshSettings(ctx);
 	});
 	pi.on("agent_end", async (event, ctx) => {
 		if (
@@ -191,7 +155,8 @@ export default function contextExtension(pi: ExtensionAPI): void {
 			)
 		)
 			return;
-		if (!validationSettings.enabled || !ctx.isProjectTrusted()) {
+		settings = await loadTauExtensionSettings(ctx, contextSettings);
+		if (!settings.sync.enabled || !settings.validation.enabled || !ctx.isProjectTrusted()) {
 			lastValidationFailure = undefined;
 			return;
 		}
@@ -200,25 +165,58 @@ export default function contextExtension(pi: ExtensionAPI): void {
 			const git = createGitRunner(pi, ctx);
 			if (!(await loadRepoStatus(git))) return;
 			const failure = formatContextValidationFailure(
-				await validateContextCatalog(git, root, validationSettings.ignoreGlobs),
+				await validateContextCatalog(git, root, settings.validation.ignoreGlobs),
 			);
 			if (!failure) {
 				lastValidationFailure = undefined;
 				return;
 			}
+			// Same unresolved failure fingerprint: do not re-spawn until the dirty/catalog signal changes.
 			if (failure === lastValidationFailure) return;
 			lastValidationFailure = failure;
-			ctx.ui.notify("Context catalog validation failed", "error");
-			pi.sendMessage(
-				{ customType: "tau.context-validation", content: failure, display: false },
-				{ triggerTurn: true },
-			);
+			ctx.ui.notify("Context catalog validation failed; running context-sync", "error");
+			const widget = showContextSyncWidget(ctx);
+			try {
+				const result = await runContextSync(pi, ctx, {
+					onStatus: (status) => {
+						widget.update(status);
+					},
+				});
+				const afterFailure = formatContextValidationFailure(
+					await validateContextCatalog(git, root, settings.validation.ignoreGlobs),
+				);
+				if (result.outcome === "failed" || afterFailure) {
+					lastValidationFailure = afterFailure ?? `${failure}\n${result.reason}`;
+					ctx.ui.notify(
+						result.outcome === "failed" ? result.summary : "Context catalog still invalid after context-sync",
+						"error",
+					);
+					return;
+				}
+				lastValidationFailure = undefined;
+				ctx.ui.notify(result.summary, "info");
+			} finally {
+				widget.clear();
+			}
 		} catch (error) {
 			ctx.ui.notify(`Context validation failed: ${error instanceof Error ? error.message : String(error)}`, "error");
 		}
 	});
-	pi.on("session_shutdown", () => {
-		for (const execution of activeToolExecutions.values()) execution.complete();
-		activeToolExecutions.clear();
+}
+
+function showContextSyncWidget(ctx: ExtensionContext): { update(status: string): void; clear(): void } {
+	let widget: ContextSyncStatusPanel | undefined;
+	ctx.ui.setWidget("context-sync", (tui, theme) => {
+		widget = new ContextSyncStatusPanel(tui, theme, "Synchronizing repository context");
+		return widget;
 	});
+	return {
+		update(status) {
+			widget?.update(status);
+		},
+		clear() {
+			ctx.ui.setWidget("context-sync", undefined);
+			widget = undefined;
+		},
+	};
 }

package/extensions/context/panel.ts

@@ -187,3 +187,63 @@ export class ContextPanel implements Component {
 		this.tui.requestRender();
 	}
 }
+
+export class ContextSyncStatusPanel implements Component {
+	private readonly tui: TUI;
+	private readonly panel: ToolPanel;
+	private readonly config: ToolPanelConfig;
+	private readonly startedAt = Date.now();
+	private readonly timer: ReturnType<typeof setInterval>;
+	private lines: string[] = [];
+	private lineCount = 0;
+
+	constructor(tui: TUI, theme: Theme, status: string) {
+		this.tui = tui;
+		this.config = {
+			title: "Context sync",
+			body: {
+				render: (width) => {
+					const visible =
+						this.lineCount > 5
+							? [`${this.lineCount - 4} earlier lines omitted`, ...this.lines.slice(-4)]
+							: this.lines;
+					return visible.map((line, index) =>
+						truncateToWidth(theme.fg(index === 0 && this.lineCount > 5 ? "dim" : "muted", line), width, "…"),
+					);
+				},
+				invalidate: () => {},
+			},
+			footer: { kind: "hints", hints: [] },
+			border: "horizontal",
+		};
+		this.panel = new ToolPanel(theme, this.config);
+		this.update(status);
+		this.timer = setInterval(() => this.tui.requestRender(), 1_000);
+		this.timer.unref();
+	}
+
+	update(status: string): void {
+		const added = status
+			.split(/\r?\n/)
+			.map((line) => line.trim())
+			.filter(Boolean);
+		this.lineCount += added.length;
+		this.lines = [...this.lines, ...added].slice(-5);
+		this.tui.requestRender();
+	}
+
+	render(width: number): string[] {
+		const elapsed = Math.floor((Date.now() - this.startedAt) / 1_000);
+		this.config.title =
+			elapsed < 60 ? `Context sync · ${elapsed}s` : `Context sync · ${Math.floor(elapsed / 60)}m ${elapsed % 60}s`;
+		return this.panel.render(width);
+	}
+
+	invalidate(): void {
+		this.panel.invalidate();
+	}
+
+	dispose(): void {
+		clearInterval(this.timer);
+	}
+}

package/extensions/context/settings.ts

@@ -4,6 +4,10 @@ import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
 export default defineTauExtensionSettings({
 	key: "context",
 	defaults: {
+		sync: {
+			enabled: true as boolean,
+			automation: true as boolean,
+		},
 		validation: {
 			enabled: false as boolean,
 			ignoreGlobs: [] as string[],
@@ -11,11 +15,36 @@ export default defineTauExtensionSettings({
 	},
 	schema: Type.Object(
 		{
+			sync: Type.Optional(
+				Type.Object(
+					{
+						enabled: Type.Optional(
+							Type.Boolean({
+								default: true,
+								description:
+									"Master switch for context-sync. When false: no /context-sync, parent cannot call the agent, validation does not auto-run sync.",
+							}),
+						),
+						automation: Type.Optional(
+							Type.Boolean({
+								default: true,
+								description:
+									"When true with sync.enabled, the coding agent may call context-sync. When false, only manual /context-sync (validation auto-run still allowed if validation.enabled).",
+							}),
+						),
+					},
+					{ additionalProperties: false },
+				),
+			),
 			validation: Type.Optional(
 				Type.Object(
 					{
 						enabled: Type.Optional(
-							Type.Boolean({ default: false, description: "Validate context membership after agent turns." }),
+							Type.Boolean({
+								default: false,
+								description:
+									"Validate context membership after agent turns and auto-run context-sync on failure (requires sync.enabled).",
+							}),
 						),
 						ignoreGlobs: Type.Optional(
 							Type.Array(Type.String(), {