@shanepadgett/tau-agent 0.33.1 → 0.35.0

package/extensions/context/index.ts

@@ -1,36 +1,163 @@
+import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { getKeybindings } from "@earendil-works/pi-tui";
+import { prepareFileInjection } from "@shanepadgett/tau-agent";
 import { createGitRunner, loadRepoStatus } from "../../shared/git.ts";
 import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
+import { findProjectRoot, loadContextEntries, type ContextEntry, type ContextShowTarget } from "./definitions.ts";
 import { ContextPanel, ContextSyncStatusPanel } from "./panel.ts";
-import { findProjectRoot, loadContextEntries, type ContextEntry } from "./definitions.ts";
-import { hideContextSyncEvidenceTool, registerContextSyncEvidenceTool } from "./evidence.ts";
-import {
-	buildContextProjection,
-	contextProjectionKey,
-	contextProjectionMessage,
-	removeLegacyContextMessages,
-	selectContextEntries,
-} from "./projection.ts";
 import contextSettings from "./settings.ts";
-import { CONTEXT_SELECTION_TYPE, createContextSelectionState, replayContextSelection } from "./state.ts";
-import { runContextSync } from "./sync.ts";
+import { type ContextSyncDetails, runContextSync } from "./sync.ts";
 import { formatContextValidationFailure, validateContextCatalog } from "./validation.ts";
 
+const CONTEXT_BRIEF_TYPE = "tau.context.brief";
+
+const SHOW_RANK = {
+	signature: 0,
+	signatureWithDocs: 1,
+	declaration: 2,
+	declarationWithImports: 3,
+} as const;
+
+function collectInjectionPlan(selected: readonly ContextEntry[]): {
+	read: string[];
+	shows: ContextShowTarget[];
+	outline: string[];
+	references: string[];
+} {
+	const read = new Set(selected.flatMap((entry) => entry.read));
+	const showByKey = new Map<string, ContextShowTarget>();
+	for (const entry of selected) {
+		for (const target of entry.show) {
+			if (read.has(target.path)) continue;
+			const key = `${target.path}\0${target.name}`;
+			const existing = showByKey.get(key);
+			if (!existing || SHOW_RANK[target.view] > SHOW_RANK[existing.view]) showByKey.set(key, target);
+		}
+	}
+	const shows = [...showByKey.values()].sort(
+		(left, right) => left.path.localeCompare(right.path) || left.name.localeCompare(right.name),
+	);
+	const outline = new Set(selected.flatMap((entry) => entry.outline).filter((path) => !read.has(path)));
+	const references = [
+		...new Set(selected.flatMap((entry) => entry.references).filter((path) => !read.has(path) && !outline.has(path))),
+	].sort((left, right) => left.localeCompare(right));
+	return {
+		read: [...read].sort((left, right) => left.localeCompare(right)),
+		shows,
+		outline: [...outline].sort((left, right) => left.localeCompare(right)),
+		references,
+	};
+}
+
+function contextBriefContent(selected: readonly ContextEntry[], references: readonly string[], failed: number): string {
+	const authority =
+		failed === 0
+			? "The complete files, show targets, and outlines that follow are current. Treat them as authoritative and do not read them again. Show rows are declaration slices only — do not assume the rest of the file is loaded. Use a ranged read for bodies an outline omits, and re-read a file only after you change it."
+			: "Successful complete-file, show, and outline rows that follow are current; failed rows contain no source context. Treat successful rows as authoritative and do not read them again. Show rows are declaration slices only — do not assume the rest of the file is loaded. Use a ranged read for bodies an outline omits, and re-read a file only after you change it.";
+	return [
+		"Active repository context, injected once from the current catalog:",
+		...selected.map((entry) => `- ${entry.id}: ${entry.description}`),
+		"",
+		"Unloaded references:",
+		...(references.length ? references.map((path) => `- ${path}`) : ["(none)"]),
+		"",
+		authority,
+	].join("\n");
+}
+
+async function injectSelectedContext(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	root: string,
+	selected: readonly ContextEntry[],
+): Promise<void> {
+	const plan = collectInjectionPlan(selected);
+	const prepared = await prepareFileInjection(pi, {
+		cwd: root,
+		source: "context",
+		batchId: randomUUID(),
+		files: [
+			...plan.read.map((path) => ({ path, mode: "full" as const })),
+			...plan.shows.map((target) => ({
+				path: target.path,
+				mode: "show" as const,
+				name: target.name,
+				view: target.view,
+			})),
+			...plan.outline.map((path) => ({ path, mode: "outline" as const })),
+		],
+	});
+	const failed = prepared.filter((message) => message.details.status === "failed").length;
+	pi.sendMessage({
+		customType: CONTEXT_BRIEF_TYPE,
+		content: contextBriefContent(selected, plan.references, failed),
+		display: false,
+	});
+	for (const message of prepared) pi.sendMessage(message);
+	if (failed > 0) {
+		ctx.ui.notify(
+			`Injected ${prepared.length - failed} of ${prepared.length} files from ${selected.length} context entries; ${failed} failed`,
+			"warning",
+		);
+	}
+}
+
+function hasAbortedAssistant(messages: readonly unknown[]): boolean {
+	return messages.some(
+		(message) =>
+			typeof message === "object" &&
+			message !== null &&
+			"role" in message &&
+			message.role === "assistant" &&
+			"stopReason" in message &&
+			message.stopReason === "aborted",
+	);
+}
+
+async function handleAgentEndValidation(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	settings: typeof contextSettings.defaults,
+	lastValidationFailure: string | undefined,
+): Promise<string | undefined> {
+	if (!settings.sync.enabled || !settings.validation.enabled || !ctx.isProjectTrusted()) return undefined;
+	const root = await findProjectRoot(ctx.cwd);
+	const git = createGitRunner(pi, ctx);
+	if (!(await loadRepoStatus(git))) return lastValidationFailure;
+	const failure = formatContextValidationFailure(
+		await validateContextCatalog(git, root, settings.validation.ignoreGlobs),
+	);
+	if (!failure) return undefined;
+	if (failure === lastValidationFailure) return lastValidationFailure;
+	ctx.ui.notify("Context catalog validation failed; running context-sync", "error");
+	const result = ctx.mode === "tui" ? await runContextSyncWithEditor(pi, ctx, {}) : await runContextSync(pi, ctx, {});
+	if (!result || result.outcome === "cancelled") {
+		ctx.ui.notify("Context sync cancelled", "info");
+		return failure;
+	}
+	const afterFailure = formatContextValidationFailure(
+		await validateContextCatalog(git, root, settings.validation.ignoreGlobs),
+	);
+	if (result.outcome === "failed" || afterFailure) {
+		ctx.ui.notify(
+			result.outcome === "failed" ? result.summary : "Context catalog still invalid after context-sync",
+			"error",
+		);
+		return afterFailure ?? `${failure}\n${result.reason}`;
+	}
+	ctx.ui.notify(result.summary, "info");
+	return undefined;
+}
+
 export default function contextExtension(pi: ExtensionAPI): void {
 	let settings = contextSettings.defaults;
 	let lastValidationFailure: string | undefined;
 	let syncCommandRegistered = false;
-	let lifecycleGeneration = 0;
-	let projectionCache: { key: string; content: string } | undefined;
-
-	registerContextSyncEvidenceTool(pi);
 
 	const refreshSettings = async (ctx: { cwd: string; isProjectTrusted(): boolean }) => {
 		settings = await loadTauExtensionSettings(ctx, contextSettings);
 		if (settings.sync.enabled) registerContextSyncCommand();
-		hideContextSyncEvidenceTool(pi);
 	};
 
 	const registerContextSyncCommand = () => {
@@ -48,45 +175,21 @@ export default function contextExtension(pi: ExtensionAPI): void {
 					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 };
+				const result = await runContextSyncWithEditor(pi, ctx, {
+					nudge: args.trim() || undefined,
 				});
-				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();
+				if (!result) return;
+				if (result.outcome === "cancelled") {
+					ctx.ui.notify(result.summary, "info");
+					return;
 				}
+				ctx.ui.notify(result.summary, result.outcome === "failed" ? "error" : "info");
 			},
 		});
 	};
 
 	pi.registerCommand("context", {
-		description: "Select active repository context entries",
+		description: "Inject repository context entries into the conversation",
 		handler: async (_args, ctx) => {
 			if (ctx.mode !== "tui" || !ctx.isProjectTrusted()) {
 				ctx.ui.notify("/context requires a trusted TUI project", "warning");
@@ -99,21 +202,15 @@ export default function contextExtension(pi: ExtensionAPI): void {
 				ctx.ui.notify(`No context entries found in ${join(root, ".pi", "contexts")}`, "warning");
 				return;
 			}
-			const active = replayContextSelection(ctx.sessionManager.getBranch()).entryIds;
 			const selected = await ctx.ui.custom<ContextEntry[] | undefined>(
-				(tui, theme, _keys, done) => new ContextPanel(tui, theme, entries, active, done),
+				(tui, theme, _keys, done) => new ContextPanel(tui, theme, entries, done),
 				{
 					overlay: true,
 					overlayOptions: { anchor: "top-center", width: "70%", minWidth: 64, maxHeight: "80%", margin: 2 },
 				},
 			);
-			if (selected === undefined) return;
-			pi.appendEntry(CONTEXT_SELECTION_TYPE, createContextSelectionState(selected.map((entry) => entry.id)));
-			projectionCache = undefined;
-			ctx.ui.notify(
-				selected.length ? `${selected.length} context entries active` : "Active context cleared",
-				"info",
-			);
+			if (selected === undefined || selected.length === 0) return;
+			await injectSelectedContext(pi, ctx, root, selected);
 		},
 	});
 
@@ -121,124 +218,59 @@ export default function contextExtension(pi: ExtensionAPI): void {
 	if (settings.sync.enabled) registerContextSyncCommand();
 
 	pi.on("session_start", async (_event, ctx) => {
-		lifecycleGeneration += 1;
-		projectionCache = undefined;
 		await refreshSettings(ctx);
 	});
-	pi.on("context", async (event, ctx) => {
-		const messages = removeLegacyContextMessages(event.messages);
-		if (!ctx.isProjectTrusted()) return { messages };
-		const entryIds = replayContextSelection(ctx.sessionManager.getBranch()).entryIds;
-		if (entryIds.length === 0) return { messages };
-		const generation = lifecycleGeneration;
-		const root = await findProjectRoot(ctx.cwd);
-		const selection = selectContextEntries(await loadContextEntries(root), entryIds);
-		const key = await contextProjectionKey(root, selection, ctx.signal, () => generation === lifecycleGeneration);
-		if (generation !== lifecycleGeneration) return { messages };
-		if (projectionCache?.key !== key) {
-			projectionCache = {
-				key,
-				content: await buildContextProjection(
-					pi,
-					root,
-					selection,
-					ctx.signal,
-					() => generation === lifecycleGeneration,
-				),
-			};
-		}
-		return { messages: [...messages, contextProjectionMessage(projectionCache.content)] };
-	});
 	pi.on("agent_start", async (_event, ctx) => {
 		await refreshSettings(ctx);
 	});
 	pi.on("agent_end", async (event, ctx) => {
-		if (
-			event.messages.some(
-				(message) =>
-					typeof message === "object" &&
-					message !== null &&
-					"role" in message &&
-					message.role === "assistant" &&
-					"stopReason" in message &&
-					message.stopReason === "aborted",
-			)
-		)
-			return;
+		if (hasAbortedAssistant(event.messages)) return;
 		settings = await loadTauExtensionSettings(ctx, contextSettings);
-		if (!settings.sync.enabled || !settings.validation.enabled || !ctx.isProjectTrusted()) {
-			lastValidationFailure = undefined;
-			return;
-		}
 		try {
-			const root = await findProjectRoot(ctx.cwd);
-			const git = createGitRunner(pi, ctx);
-			if (!(await loadRepoStatus(git))) return;
-			const failure = formatContextValidationFailure(
-				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; running context-sync", "error");
-			const widget = showContextSyncWidget(ctx);
+			lastValidationFailure = await handleAgentEndValidation(pi, ctx, settings, lastValidationFailure);
+		} catch (error) {
+			ctx.ui.notify(`Context validation failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+		}
+	});
+}
+
+async function runContextSyncWithEditor(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	options: { nudge?: string },
+): Promise<ContextSyncDetails | undefined> {
+	return ctx.ui.custom<ContextSyncDetails | undefined>((tui, theme, _keys, done) => {
+		const panel = new ContextSyncStatusPanel(tui, theme, "Synchronizing repository context");
+		void (async () => {
 			try {
 				const result = await runContextSync(pi, ctx, {
+					nudge: options.nudge,
+					signal: panel.signal,
 					onStatus: (status) => {
-						widget.update(status);
+						panel.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",
-					);
+				done(result);
+			} catch (error) {
+				if (panel.signal.aborted) {
+					done({
+						outcome: "cancelled",
+						summary: "Context sync cancelled",
+						reason: "Cancelled by user.",
+						changedContextFiles: [],
+					});
 					return;
 				}
-				lastValidationFailure = undefined;
-				ctx.ui.notify(result.summary, "info");
+				done({
+					outcome: "failed",
+					summary: `Context sync failed: ${error instanceof Error ? error.message : String(error)}`,
+					reason: error instanceof Error ? error.message : String(error),
+					changedContextFiles: [],
+				});
 			} finally {
-				widget.clear();
+				panel.dispose();
 			}
-		} catch (error) {
-			ctx.ui.notify(`Context validation failed: ${error instanceof Error ? error.message : String(error)}`, "error");
-		}
-	});
-	pi.on("session_tree", () => {
-		lifecycleGeneration += 1;
-		projectionCache = undefined;
-	});
-	pi.on("session_compact", () => {
-		lifecycleGeneration += 1;
-		projectionCache = undefined;
-	});
-	pi.on("session_shutdown", () => {
-		lifecycleGeneration += 1;
-		projectionCache = undefined;
-	});
-}
-
-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 panel;
 	});
-	return {
-		update(status) {
-			widget?.update(status);
-		},
-		clear() {
-			ctx.ui.setWidget("context-sync", undefined);
-			widget = undefined;
-		},
-	};
 }

package/extensions/context/panel.ts

@@ -21,7 +21,6 @@ export class ContextPanel implements Component {
 		tui: TUI,
 		theme: Theme,
 		entries: readonly ContextEntry[],
-		activeEntryIds: readonly string[],
 		done: (result: ContextEntry[] | undefined) => void,
 	) {
 		const firstEntry = entries[0];
@@ -30,7 +29,8 @@ export class ContextPanel implements Component {
 		this.theme = theme;
 		this.done = done;
 		this.current = firstEntry;
-		const tabNames = [...new Set(entries.map((entry) => entry.tab))].sort();
+		// loadContextEntries already emits tabs in NN_ folder order; keep first-seen order.
+		const tabNames = [...new Set(entries.map((entry) => entry.tab))];
 		this.tabs = new Tabs(
 			theme,
 			tabNames.map((tab) => {
@@ -68,42 +68,43 @@ export class ContextPanel implements Component {
 			border: "box",
 		};
 		this.panel = new ToolPanel(theme, this.config);
-		for (const [tab, list] of this.lists)
-			list.setSelectedIds(activeEntryIds.filter((id) => id.startsWith(`${tab}/`)));
+	}
+
+	private handlePanelChromeKey(data: string): boolean {
+		const keys = getKeybindings();
+		const paths = this.currentPaths();
+		const pageSize = this.pathPageSize();
+		if (paths.length > pageSize && matchesKey(data, Key.alt("up"))) {
+			this.fileOffset = Math.max(0, this.fileOffset - pageSize);
+			return true;
+		}
+		if (paths.length > pageSize && matchesKey(data, Key.alt("down"))) {
+			this.fileOffset = Math.min(paths.length - pageSize, this.fileOffset + pageSize);
+			return true;
+		}
+		if (matchesKey(data, Key.ctrl("c"))) {
+			for (const [tab, tabList] of this.lists) {
+				tabList.setSelectedIds([]);
+				this.selected.set(tab, []);
+			}
+			return true;
+		}
+		if (keys.matches(data, "tui.select.confirm")) {
+			this.done([...this.selected.values()].flatMap((items) => [...items]));
+			return true;
+		}
+		if (keys.matches(data, "tui.select.cancel")) {
+			this.done(undefined);
+			return true;
+		}
+		return false;
 	}
 
 	handleInput(data: string): void {
 		const list = this.activeList();
-		if (!list?.isFilterFocused()) {
-			const keys = getKeybindings();
-			const paths = this.currentPaths();
-			const pageSize = this.pathPageSize();
-			if (paths.length > pageSize && matchesKey(data, Key.alt("up"))) {
-				this.fileOffset = Math.max(0, this.fileOffset - pageSize);
-				this.sync();
-				return;
-			}
-			if (paths.length > pageSize && matchesKey(data, Key.alt("down"))) {
-				this.fileOffset = Math.min(paths.length - pageSize, this.fileOffset + pageSize);
-				this.sync();
-				return;
-			}
-			if (matchesKey(data, Key.ctrl("c"))) {
-				for (const [tab, tabList] of this.lists) {
-					tabList.setSelectedIds([]);
-					this.selected.set(tab, []);
-				}
-				this.sync();
-				return;
-			}
-			if (keys.matches(data, "tui.select.confirm")) {
-				this.done([...this.selected.values()].flatMap((items) => [...items]));
-				return;
-			}
-			if (keys.matches(data, "tui.select.cancel")) {
-				this.done(undefined);
-				return;
-			}
+		if (!list?.isFilterFocused() && this.handlePanelChromeKey(data)) {
+			this.sync();
+			return;
 		}
 		this.tabs.handleInput(data);
 		const current = this.activeList()?.getCurrentItem() ?? this.current;
@@ -154,9 +155,16 @@ export class ContextPanel implements Component {
 			invalidate: () => this.tabs.invalidate(),
 		};
 	}
-	private currentPaths(): Array<{ kind: "read" | "outline" | "reference"; path: string }> {
+	private currentPaths(): Array<{ kind: "read" | "show" | "outline" | "reference"; path: string }> {
 		return [
 			...this.current.read.map((path) => ({ kind: "read" as const, path })),
+			...this.current.show.map((target) => ({
+				kind: "show" as const,
+				path:
+					target.view === "declaration"
+						? `${target.name} · ${target.path}`
+						: `${target.name} [${target.view}] · ${target.path}`,
+			})),
 			...this.current.outline.map((path) => ({ kind: "outline" as const, path })),
 			...this.current.references.map((path) => ({ kind: "reference" as const, path })),
 		];
@@ -168,7 +176,7 @@ export class ContextPanel implements Component {
 		return this.currentPaths().length > pageSize ? Math.max(1, pageSize - 1) : pageSize;
 	}
 	private secondary(): string {
-		return `${[...this.selected.values()].reduce((sum, items) => sum + items.length, 0)} selected · ${this.current.read.length} read · ${this.current.outline.length} outline · ${this.current.references.length} references`;
+		return `${[...this.selected.values()].reduce((sum, items) => sum + items.length, 0)} selected · ${this.current.read.length} read · ${this.current.show.length} show · ${this.current.outline.length} outline · ${this.current.references.length} references`;
 	}
 	private hints() {
 		const list = this.activeList();
@@ -193,6 +201,7 @@ export class ContextSyncStatusPanel implements Component {
 	private readonly tui: TUI;
 	private readonly panel: ToolPanel;
 	private readonly config: ToolPanelConfig;
+	private readonly controller = new AbortController();
 	private readonly startedAt = Date.now();
 	private readonly timer: ReturnType<typeof setInterval>;
 	private lines: string[] = [];
@@ -214,7 +223,7 @@ export class ContextSyncStatusPanel implements Component {
 				},
 				invalidate: () => {},
 			},
-			footer: { kind: "hints", hints: [] },
+			footer: { kind: "hints", hints: [bindingHint("tui.select.cancel", "cancel")] },
 			border: "horizontal",
 		};
 		this.panel = new ToolPanel(theme, this.config);
@@ -223,6 +232,17 @@ export class ContextSyncStatusPanel implements Component {
 		this.timer.unref();
 	}
 
+	get signal(): AbortSignal {
+		return this.controller.signal;
+	}
+
+	handleInput(data: string): void {
+		if (!getKeybindings().matches(data, "tui.select.cancel")) return;
+		if (this.controller.signal.aborted) return;
+		this.update("Cancelling context sync");
+		this.controller.abort();
+	}
+
 	update(status: string): void {
 		const added = status
 			.split(/\r?\n/)