@shanepadgett/tau-agent 0.42.3 → 0.44.0

package/extensions/context/sync.ts

@@ -1,276 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFile, readdir } from "node:fs/promises";
-import { extname, join, relative, sep } from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { createGitRunner, loadRepoStatus } from "../../shared/git.ts";
-import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
-import { discoverAgents } from "../subagent/agents.ts";
-import {
-	createSubagentThread,
-	disposeSubagentThread,
-	extensionPathsForTools,
-	runSubagentTurn,
-} from "../subagent/run.ts";
-import { pathExists } from "./definitions.ts";
-import contextSettings from "./settings.ts";
-import { formatContextValidationFailure, listEligibleDirtyPaths, validateContextCatalog } from "./validation.ts";
-
-const CONTEXT_SYNC_AGENT = "context-sync";
-
-export interface ContextSyncDetails {
-	outcome: "applied" | "no-change" | "failed" | "cancelled";
-	summary: string;
-	reason: string;
-	changedContextFiles: string[];
-	agentResponse?: string;
-	validationFailure?: string;
-}
-
-type SyncStatus = (status: string) => void | Promise<void>;
-type GitRunner = ReturnType<typeof createGitRunner>;
-
-let syncQueue = Promise.resolve();
-
-export async function runContextSync(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	options: { nudge?: string; signal?: AbortSignal; onStatus?: SyncStatus } = {},
-): Promise<ContextSyncDetails> {
-	return withSyncLock(() => runContextSyncLocked(pi, ctx, options));
-}
-
-function noChangeResult(reason: string, agentResponse?: string): ContextSyncDetails {
-	return {
-		outcome: "no-change",
-		summary: "Existing context mappings already fit the changed scope.",
-		reason,
-		changedContextFiles: [],
-		agentResponse,
-	};
-}
-
-async function inspectSyncNeed(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	nudge: string | undefined,
-	onStatus?: SyncStatus,
-): Promise<
-	| { kind: "done"; result: ContextSyncDetails }
-	| { kind: "run"; git: GitRunner; root: string; ignoreGlobs: readonly string[] }
-> {
-	await onStatus?.("Inspecting repository context");
-	const git = createGitRunner(pi, ctx);
-	const status = await loadRepoStatus(git);
-	if (!status) throw new Error("No Git repository found");
-	const settings = await loadTauExtensionSettings(ctx, contextSettings);
-	const ignoreGlobs = settings.validation.ignoreGlobs;
-	const validation = await validateContextCatalog(git, status.root, ignoreGlobs);
-	const dirtyEligible = await listEligibleDirtyPaths(git, status.root, ignoreGlobs);
-	const force = Boolean(nudge?.trim());
-	if (!force && validation.stale.length === 0 && validation.uncovered.length === 0 && dirtyEligible.length === 0) {
-		return {
-			kind: "done",
-			result: noChangeResult("No eligible dirty files, stale catalog paths, or sync nudge."),
-		};
-	}
-	return { kind: "run", git, root: status.root, ignoreGlobs };
-}
-
-async function resolveContextSyncDefinition(ctx: ExtensionContext) {
-	const discovery = await discoverAgents(ctx.cwd, ctx.isProjectTrusted());
-	const definition = discovery.agents.get(CONTEXT_SYNC_AGENT);
-	if (definition) return definition;
-	const reason =
-		discovery.invalid
-			.get(CONTEXT_SYNC_AGENT)
-			?.map((item) => item.reason)
-			.join("; ") ?? "unknown agent";
-	throw new Error(`Context sync agent unavailable: ${reason}`);
-}
-
-async function runContextSyncAgent(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	root: string,
-	nudge: string | undefined,
-	signal: AbortSignal,
-	onStatus: SyncStatus | undefined,
-	beforeCatalog: Map<string, string>,
-): Promise<ContextSyncDetails | { agentResponse: string }> {
-	const definition = await resolveContextSyncDefinition(ctx);
-	const task = buildContextSyncTask(root, nudge);
-	await onStatus?.("Running context-sync subagent");
-	const thread = await createSubagentThread({
-		id: `context-sync-${Date.now()}`,
-		displayName: definition.names[0] ?? definition.name,
-		definition,
-		extensionPaths: extensionPathsForTools(pi, definition.tools),
-		initialTask: task,
-		ctx,
-		thinkingLevel: pi.getThinkingLevel(),
-		signal,
-		onWarning: (warning) => {
-			ctx.ui.notify(`Context sync agent: ${warning}`, "warning");
-		},
-	});
-	try {
-		const result = await runSubagentTurn({
-			thread,
-			task,
-			initial: true,
-			signal,
-			onUpdate: async (details) => {
-				const activity = details.currentActivity ?? details.response;
-				if (activity) await onStatus?.(activity.slice(0, 160));
-			},
-		});
-		if (signal.aborted || result.details.status === "aborted") return cancelledResult(result.content);
-		if (result.details.status !== "completed") {
-			return {
-				outcome: "failed",
-				summary: "Context sync subagent failed.",
-				reason: result.details.error ?? result.content,
-				changedContextFiles: changedCatalogPaths(beforeCatalog, await catalogFileSnapshot(root)),
-				agentResponse: result.content,
-			};
-		}
-		return { agentResponse: result.content };
-	} finally {
-		await disposeSubagentThread(thread);
-	}
-}
-
-async function finalizeContextSync(
-	git: GitRunner,
-	root: string,
-	ignoreGlobs: readonly string[],
-	beforeCatalog: Map<string, string>,
-	agentResponse: string,
-	onStatus?: SyncStatus,
-): Promise<ContextSyncDetails> {
-	const changedContextFiles = changedCatalogPaths(beforeCatalog, await catalogFileSnapshot(root));
-	await onStatus?.("Verifying context catalog");
-	const validationFailure = formatContextValidationFailure(await validateContextCatalog(git, root, ignoreGlobs));
-	if (validationFailure) {
-		return {
-			outcome: "failed",
-			summary: "Context sync finished but catalog invariants still fail.",
-			reason: validationFailure,
-			changedContextFiles,
-			agentResponse,
-			validationFailure,
-		};
-	}
-	if (changedContextFiles.length === 0) {
-		return noChangeResult(agentResponse.trim() || "Context-sync subagent made no catalog edits.", agentResponse);
-	}
-	return {
-		outcome: "applied",
-		summary: `Updated context catalog (${changedContextFiles.length} file${changedContextFiles.length === 1 ? "" : "s"}).`,
-		reason: agentResponse.trim() || "Context-sync subagent updated the catalog.",
-		changedContextFiles,
-		agentResponse,
-	};
-}
-
-async function runContextSyncLocked(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	options: { nudge?: string; signal?: AbortSignal; onStatus?: SyncStatus },
-): Promise<ContextSyncDetails> {
-	if (!ctx.isProjectTrusted()) throw new Error("Context sync requires a trusted project");
-	const signal = options.signal ?? ctx.signal ?? new AbortController().signal;
-	if (signal.aborted) return cancelledResult();
-
-	const need = await inspectSyncNeed(pi, ctx, options.nudge, options.onStatus);
-	if (need.kind === "done") return need.result;
-	if (signal.aborted) return cancelledResult();
-
-	const beforeCatalog = await catalogFileSnapshot(need.root);
-	const agentResult = await runContextSyncAgent(
-		pi,
-		ctx,
-		need.root,
-		options.nudge,
-		signal,
-		options.onStatus,
-		beforeCatalog,
-	);
-	if ("outcome" in agentResult) return agentResult;
-	if (signal.aborted) return cancelledResult(agentResult.agentResponse);
-	return finalizeContextSync(
-		need.git,
-		need.root,
-		need.ignoreGlobs,
-		beforeCatalog,
-		agentResult.agentResponse,
-		options.onStatus,
-	);
-}
-
-function cancelledResult(agentResponse?: string): ContextSyncDetails {
-	return {
-		outcome: "cancelled",
-		summary: "Context sync cancelled",
-		reason: agentResponse?.trim() || "Cancelled by user.",
-		changedContextFiles: [],
-		agentResponse,
-	};
-}
-
-function buildContextSyncTask(root: string, nudge?: string): string {
-	const trimmed = nudge?.trim();
-	return [
-		`Keep the repository context catalog at ${root} honest.`,
-		"Job: update `.pi/contexts` so work packs match the codebase.",
-		"Use normal repo tools. Prefer patch for catalog edits under `.pi/contexts`.",
-		"Walk domain → concept → job entry before placing paths. Harness verifies catalog coverage after you finish.",
-		trimmed ? `Human nudge (soft steer, does not skip the ladder or coverage):\n${trimmed}` : undefined,
-	]
-		.filter((line): line is string => Boolean(line))
-		.join("\n\n");
-}
-
-async function withSyncLock<T>(task: () => Promise<T>): Promise<T> {
-	const previous = syncQueue;
-	let release = () => {};
-	syncQueue = new Promise<void>((resolve) => {
-		release = resolve;
-	});
-	await previous;
-	try {
-		return await task();
-	} finally {
-		release();
-	}
-}
-
-async function catalogFileSnapshot(root: string): Promise<Map<string, string>> {
-	const snapshot = new Map<string, string>();
-	const base = join(root, ".pi", "contexts");
-	if (!(await pathExists(base))) return snapshot;
-	const stack = [base];
-	while (stack.length > 0) {
-		const directory = stack.pop();
-		if (!directory) continue;
-		for (const entry of await readdir(directory, { withFileTypes: true })) {
-			const fullPath = join(directory, entry.name);
-			if (entry.isDirectory()) {
-				stack.push(fullPath);
-				continue;
-			}
-			if (!entry.isFile() || extname(entry.name) !== ".toml") continue;
-			const relativePath = relative(root, fullPath).split(sep).join("/");
-			const content = await readFile(fullPath, "utf8");
-			snapshot.set(relativePath, createHash("sha256").update(content).digest("hex"));
-		}
-	}
-	return snapshot;
-}
-
-function changedCatalogPaths(before: Map<string, string>, after: Map<string, string>): string[] {
-	const paths = new Set([...before.keys(), ...after.keys()]);
-	return [...paths]
-		.filter((path) => before.get(path) !== after.get(path))
-		.sort((left, right) => left.localeCompare(right));
-}

package/extensions/context/validation.ts

@@ -1,88 +0,0 @@
-import { stat } from "node:fs/promises";
-import { join } from "node:path";
-import type { GitRunner } from "../../shared/git.ts";
-import { contextEntryPaths, isContextEligiblePath, isSensitiveContextPath, loadContextEntries } from "./definitions.ts";
-
-export interface ContextValidationResult {
-	stale: Array<{ path: string; ids: string[] }>;
-	uncovered: string[];
-}
-
-export async function listEligibleDirtyPaths(
-	git: GitRunner,
-	root: string,
-	ignoreGlobs: readonly string[],
-): Promise<string[]> {
-	const status = await git.run(["status", "--porcelain=v2", "-z", "--untracked-files=all"], { cwd: root });
-	return [...parseDirtyPaths(status)]
-		.filter((path) => !isSensitiveContextPath(path) && isContextEligiblePath(path, ignoreGlobs))
-		.sort((left, right) => left.localeCompare(right));
-}
-
-export async function validateContextCatalog(
-	git: GitRunner,
-	root: string,
-	ignoreGlobs: readonly string[],
-): Promise<ContextValidationResult> {
-	const entries = await loadContextEntries(root);
-	const memberships = new Map<string, string[]>();
-	for (const entry of entries)
-		for (const file of contextEntryPaths(entry)) memberships.set(file, [...(memberships.get(file) ?? []), entry.id]);
-
-	const stale: Array<{ path: string; ids: string[] }> = [];
-	for (const [path, ids] of memberships) {
-		if (!isContextEligiblePath(path, ignoreGlobs)) continue;
-		try {
-			if (!(await stat(join(root, path))).isFile()) stale.push({ path, ids });
-		} catch {
-			stale.push({ path, ids });
-		}
-	}
-
-	const uncovered = (await listEligibleDirtyPaths(git, root, ignoreGlobs))
-		.filter((path) => !memberships.has(path))
-		.sort((left, right) => left.localeCompare(right));
-	return { stale: stale.sort((left, right) => left.path.localeCompare(right.path)), uncovered };
-}
-
-export function formatContextValidationFailure(result: ContextValidationResult): string | undefined {
-	if (result.stale.length === 0 && result.uncovered.length === 0) return undefined;
-	const output = ["Context catalog validation failed."];
-	if (result.stale.length)
-		output.push(
-			"",
-			"Stale context file references:",
-			...result.stale.map((item) => `- ${item.path} (${item.ids.sort().join(", ")})`),
-		);
-	if (result.uncovered.length)
-		output.push("", "Changed files with no context membership:", ...result.uncovered.map((path) => `- ${path}`));
-	output.push(
-		"",
-		"With validation enabled, Tau runs context-sync automatically after agent turns. Manual: /context-sync or /context-sync <nudge>.",
-	);
-	return output.join("\n");
-}
-
-function parseDirtyPaths(status: string): Set<string> {
-	const records = status.split("\0");
-	const dirty = new Set<string>();
-	for (let index = 0; index < records.length; index++) {
-		const record = records[index];
-		if (!record) continue;
-		if (record.startsWith("? ")) {
-			dirty.add(record.slice(2).replaceAll("\\", "/"));
-			continue;
-		}
-		const fields = record.split(" ");
-		const state = fields[1] ?? "..";
-		if (record.startsWith("1 ") && !state.includes("D")) {
-			dirty.add(fields.slice(8).join(" ").replaceAll("\\", "/"));
-		} else if (record.startsWith("2 ")) {
-			if (!state.includes("D")) dirty.add(fields.slice(9).join(" ").replaceAll("\\", "/"));
-			index += 1;
-		} else if (record.startsWith("u ")) {
-			dirty.add(fields.slice(10).join(" ").replaceAll("\\", "/"));
-		}
-	}
-	return dirty;
-}

package/extensions/effort/README.md

@@ -1,7 +0,0 @@
-# Effort Extension
-
-Switches active chat model and thinking level as one effort tier. Available providers come from current logins, and each provider can fall back through its ranked models.
-
-Run `/effort` to choose a tier and provider. `/effort quick`, `/effort standard`, and `/effort deep` skip the tier prompt. Press `Ctrl+Shift+E` to cycle tiers on current provider.
-
-If selected provider has no usable model for tier, current model stays active. Footer shows an effort label whenever current provider, model, and thinking level match a configured tier; otherwise it shows no label.

package/extensions/effort/index.ts

@@ -1,134 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Key, type AutocompleteItem } from "@earendil-works/pi-tui";
-import { emitTauEvent, onTauEvent } from "../../shared/events.ts";
-import {
-	effortForSelection,
-	type EffortProviderCandidates,
-	type ModelEffort,
-	resolveEffortProviders,
-} from "../../shared/model-effort.ts";
-import { EFFORT_STATE_TYPE, effortState, nextEffort } from "./state.ts";
-
-const EFFORTS: readonly ModelEffort[] = ["quick", "standard", "deep"];
-
-export default function effortExtension(pi: ExtensionAPI): void {
-	let activeEffort: ModelEffort | undefined;
-	let applying = false;
-
-	function publish(): void {
-		emitTauEvent(pi, "tau:model-effort.changed", { effort: activeEffort });
-	}
-
-	function setEffort(effort: ModelEffort | undefined): void {
-		if (activeEffort === effort) return;
-		activeEffort = effort;
-		pi.appendEntry(EFFORT_STATE_TYPE, effortState(effort));
-		publish();
-	}
-
-	async function apply(
-		ctx: ExtensionContext,
-		effort: ModelEffort,
-		provider: EffortProviderCandidates,
-	): Promise<boolean> {
-		applying = true;
-		try {
-			for (const candidate of provider.candidates) {
-				if (!(await pi.setModel(candidate.model))) continue;
-				pi.setThinkingLevel(candidate.reasoning);
-				setEffort(effortForSelection(provider.provider, candidate.model.id, pi.getThinkingLevel()));
-				ctx.ui.notify(`Effort: ${effort} · ${provider.label}/${candidate.model.id}`, "info");
-				return true;
-			}
-			return false;
-		} finally {
-			applying = false;
-		}
-	}
-
-	async function chooseProvider(ctx: ExtensionContext, effort: ModelEffort): Promise<void> {
-		const providers = resolveEffortProviders(ctx, effort);
-		if (providers.length === 0) {
-			ctx.ui.notify(`No logged-in provider has a ${effort} effort model. Current model kept.`, "warning");
-			return;
-		}
-		const labels = providers.map((provider) => `${provider.label} · ${provider.provider}`);
-		const selected = await ctx.ui.select(`Provider for ${effort} effort`, labels);
-		if (!selected) return;
-		const provider = providers[labels.indexOf(selected)];
-		if (!provider) return;
-		if (!(await apply(ctx, effort, provider))) {
-			ctx.ui.notify(`Could not select a ${effort} model from ${provider.label}. Current model kept.`, "warning");
-		}
-	}
-
-	pi.registerCommand("effort", {
-		description: "Select effort tier and logged-in provider",
-		getArgumentCompletions(prefix: string): AutocompleteItem[] | null {
-			const value = prefix.trimStart();
-			if (/\s/.test(value)) return null;
-			const items = EFFORTS.filter((effort) => effort.startsWith(value)).map((effort) => ({
-				value: effort,
-				label: effort,
-			}));
-			return items.length ? items : null;
-		},
-		handler: async (args, ctx) => {
-			await ctx.waitForIdle();
-			if (!ctx.hasUI) {
-				ctx.ui.notify("/effort requires interactive UI.", "error");
-				return;
-			}
-			const arg = args.trim().toLowerCase();
-			if (arg && !isModelEffort(arg)) {
-				ctx.ui.notify("Usage: /effort [quick|standard|deep]", "error");
-				return;
-			}
-			let effort: ModelEffort | undefined = isModelEffort(arg) ? arg : undefined;
-			if (!arg) {
-				const selected = await ctx.ui.select("Effort", [...EFFORTS]);
-				if (selected && isModelEffort(selected)) effort = selected;
-			}
-			if (!effort) return;
-			await chooseProvider(ctx, effort);
-		},
-	});
-
-	pi.registerShortcut(Key.ctrlShift("e"), {
-		description: "Cycle effort for current provider",
-		handler: async (ctx) => {
-			if (!ctx.isIdle()) {
-				ctx.ui.notify("Wait for the current run before changing effort.", "warning");
-				return;
-			}
-			const effort = nextEffort(activeEffort);
-			const provider = resolveEffortProviders(ctx, effort).find((item) => item.provider === ctx.model?.provider);
-			if (!provider || !(await apply(ctx, effort, provider))) {
-				ctx.ui.notify(`Current provider has no available ${effort} effort model. Current model kept.`, "warning");
-			}
-		},
-	});
-
-	onTauEvent(pi, "model-effort.snapshot", "tau:model-effort.snapshot.requested", publish);
-
-	pi.on("session_start", (_event, ctx) => {
-		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
-		publish();
-	});
-	pi.on("session_tree", (_event, ctx) => {
-		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
-		publish();
-	});
-	pi.on("model_select", (event) => {
-		if (!applying) setEffort(effortForSelection(event.model.provider, event.model.id, pi.getThinkingLevel()));
-	});
-	pi.on("thinking_level_select", (event, ctx) => {
-		if (!applying) {
-			setEffort(effortForSelection(ctx.model?.provider, ctx.model?.id, event.level));
-		}
-	});
-}
-
-function isModelEffort(value: string): value is ModelEffort {
-	return value === "quick" || value === "standard" || value === "deep";
-}

package/extensions/effort/state.ts

@@ -1,18 +0,0 @@
-import type { ModelEffort } from "../../shared/model-effort.ts";
-
-export const EFFORT_STATE_TYPE = "tau.model-effort.state";
-
-export interface EffortStateV1 {
-	v: 1;
-	effort: ModelEffort | null;
-}
-
-export function effortState(effort: ModelEffort | undefined): EffortStateV1 {
-	return { v: 1, effort: effort ?? null };
-}
-
-export function nextEffort(effort: ModelEffort | undefined): ModelEffort {
-	if (effort === "quick") return "standard";
-	if (effort === "standard") return "deep";
-	return "quick";
-}

package/extensions/qna/inline-editor-row.ts

@@ -1,56 +0,0 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { type Editor, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
-
-export function renderInlineEditor(prefix: string, editor: Editor, width: number): string[] {
-	const available = Math.max(1, width - visibleWidth(prefix));
-	const lines = editorContentLines(editor.render(available));
-	const contentLines = lines.length ? lines : [""];
-	const continuation = " ".repeat(visibleWidth(prefix));
-	return contentLines.map((line, index) =>
-		truncateToWidth(`${index === 0 ? prefix : continuation}${line}`, width, ""),
-	);
-}
-
-export function renderNoteEditor(lines: string[], editor: Editor, width: number, theme: Theme, indent: string): void {
-	const prefix = `${indent}${theme.fg("muted", "└─ ")}`;
-	const available = Math.max(1, width - visibleWidth(prefix));
-	const editorLines = editorContentLines(editor.render(available));
-	const contentLines = editorLines.length ? editorLines : [""];
-	lines.push(truncateToWidth(`${prefix}${contentLines[0] ?? ""}`, width, ""));
-	const continuation = " ".repeat(visibleWidth(prefix));
-	for (const line of contentLines.slice(1)) lines.push(truncateToWidth(`${continuation}${line}`, width, ""));
-}
-
-export function pushSavedNote(lines: string[], note: string, width: number, theme: Theme, indent: string): void {
-	for (const line of wrapWithPrefix(`${indent}${theme.fg("muted", "└─ ")}`, theme.fg("muted", note), width)) {
-		lines.push(line);
-	}
-}
-
-export function wrapWithPrefix(prefix: string, text: string, width: number): string[] {
-	const restWidth = Math.max(1, width - visibleWidth(prefix));
-	return wrapTextWithAnsi(text, restWidth).map(
-		(line, index) => `${index === 0 ? prefix : " ".repeat(visibleWidth(prefix))}${line}`,
-	);
-}
-
-function editorContentLines(lines: string[]): string[] {
-	if (lines.length <= 2) return lines;
-	return lines.slice(1).filter((line) => !isEditorBorderLine(line));
-}
-
-function isEditorBorderLine(line: string): boolean {
-	const text = stripAnsi(line).trim();
-	return /^[┌┐└┘─]+$/.test(text) || /^─── [↑↓] \d+ more ─*$/.test(text);
-}
-
-function stripAnsi(text: string): string {
-	let result = text;
-	while (true) {
-		const start = result.indexOf("\u001b[");
-		if (start === -1) return result;
-		const end = result.indexOf("m", start + 2);
-		if (end === -1) return result;
-		result = result.slice(0, start) + result.slice(end + 1);
-	}
-}