@shanepadgett/tau-agent 0.33.0 → 0.34.0

package/extensions/script-runner/index.ts

@@ -16,11 +16,12 @@ import {
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
-type Language = "python" | "typescript";
+type Language = "python3" | "node" | "deno";
 
 interface Runtimes {
-	python: string | undefined;
-	typescript: string | undefined;
+	python3: string | undefined;
+	node: string | undefined;
+	deno: string | undefined;
 }
 
 interface StoredScript {
@@ -32,26 +33,42 @@ const TIMEOUT_MS = 120_000;
 const MAX_STORED = 8;
 
 function detectRuntimes(): Runtimes {
-	let python: string | undefined;
-	for (const cmd of ["python3", "python"] as const) {
-		try {
-			execFileSync(cmd, ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
-			python = cmd;
-			break;
-		} catch {
-			// runtime not installed
-		}
+	let python3: string | undefined;
+	try {
+		execFileSync("python3", ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
+		python3 = "python3";
+	} catch {
+		// runtime not installed
 	}
 	const [major, minor] = process.versions.node.split(".").map(Number);
-	let typescript: string | undefined;
+	let node: string | undefined;
 	if (major > 22 || (major === 22 && minor >= 6)) {
-		typescript = process.execPath;
+		node = process.execPath;
+	}
+	let deno: string | undefined;
+	try {
+		execFileSync("deno", ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
+		deno = "deno";
+	} catch {
+		// runtime not installed
 	}
-	return { python, typescript };
+	return { python3, node, deno };
 }
 
 function capitalize(lang: Language): string {
-	return lang === "python" ? "Python" : "TypeScript";
+	if (lang === "python3") return "Python 3";
+	if (lang === "node") return "Node";
+	return "Deno";
+}
+
+function formatLangList(langs: readonly Language[]): string {
+	const names = langs.map(capitalize);
+	if (names.length <= 2) return names.join(" or ");
+	return `${names.slice(0, -1).join(", ")}, or ${names[names.length - 1]}`;
+}
+
+function languageLabel(lang: string): string {
+	return lang === "node" ? "node (Node.js)" : lang;
 }
 
 function newScriptId(): string {
@@ -68,9 +85,7 @@ function applyEdits(source: string, edits: ReadonlyArray<{ oldText: string; newT
 	for (const edit of edits) {
 		const idx = next.indexOf(edit.oldText);
 		if (idx === -1) {
-			throw new Error(
-				"An edits oldText was not found in the script. Copy the exact text from the script you wrote.",
-			);
+			throw new Error("edits oldText not found. Copy exact text from the script you wrote.");
 		}
 		next = next.slice(0, idx) + edit.newText + next.slice(idx + edit.oldText.length);
 	}
@@ -93,14 +108,64 @@ function renderEditsPreview(edits: ReadonlyArray<{ oldText: string; newText: str
 		.join("\n");
 }
 
+function resolveScriptSource(
+	scripts: Map<string, StoredScript>,
+	language: Language,
+	params: {
+		script?: string;
+		scriptId?: string;
+		edits?: ReadonlyArray<{ oldText: string; newText: string }>;
+	},
+): { scriptId: string; source: string } {
+	const edits = params.edits;
+	if (edits && edits.length > 0) {
+		const scriptId = params.scriptId;
+		if (!scriptId) throw new Error("edits require scriptId from the failed run.");
+		const stored = scripts.get(scriptId);
+		if (!stored) throw new Error(`No stored script for scriptId ${scriptId}. Evicted; resend full script.`);
+		if (stored.language !== language) {
+			throw new Error(`Language mismatch: scriptId ${scriptId} is ${stored.language}, not ${language}.`);
+		}
+		return { scriptId, source: applyEdits(stored.source, edits) };
+	}
+	if (typeof params.script !== "string" || params.script.length === 0) {
+		throw new Error("Provide script, or edits + scriptId.");
+	}
+	return { scriptId: params.scriptId ?? newScriptId(), source: params.script };
+}
+
+function formatTruncatedTail(text: string): { body: string; note: string } {
+	const trunc = truncateTail(text, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+	const note = trunc.truncated
+		? `\n\n[output truncated: kept tail ${trunc.outputLines} / ${trunc.totalLines} lines]`
+		: "";
+	return { body: trunc.content, note };
+}
+
+function successScriptResult(stdout: string): { content: [{ type: "text"; text: string }]; details: undefined } {
+	const { body, note } = formatTruncatedTail(stdout.trim());
+	const out = body.trim();
+	return {
+		content: [{ type: "text", text: out ? `${out}${note}` : `(no output)${note}` }],
+		details: undefined,
+	};
+}
+
+function throwScriptFailure(scriptId: string, result: { stdout: string; stderr: string }): never {
+	const diag = result.stderr.trim() || result.stdout.trim();
+	const { body, note } = formatTruncatedTail(diag);
+	const detail = body ? `${body}${note}\n\n` : "";
+	throw new Error(`${detail}scriptId: ${scriptId}`);
+}
+
 export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 	const runtimes = detectRuntimes();
-	const detected = (["python", "typescript"] as const).filter(
-		(lang): lang is Language => (lang === "python" ? runtimes.python : runtimes.typescript) !== undefined,
+	const detected = (["python3", "node", "deno"] as const).filter(
+		(lang): lang is Language => runtimes[lang] !== undefined,
 	);
 	if (detected.length === 0) return;
 
-	const langPhrase = detected.map(capitalize).join(" or ");
+	const langPhrase = formatLangList(detected);
 
 	const scripts = new Map<string, StoredScript>();
 	let tempDir: string | undefined;
@@ -115,14 +180,13 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 	}
 
 	function resolveCommand(language: Language): string {
-		if (language === "python") {
-			const cmd = runtimes.python;
-			if (!cmd) throw new Error("Python is not available on this machine.");
-			return cmd;
+		const cmd = runtimes[language];
+		if (cmd) return cmd;
+		if (language === "python3") throw new Error("Python 3 is not available on this machine.");
+		if (language === "node") {
+			throw new Error("Node unavailable (needs Node >= 22.6 with --experimental-strip-types).");
 		}
-		const cmd = runtimes.typescript;
-		if (!cmd) throw new Error("TypeScript is not available (requires Node >= 22.6).");
-		return cmd;
+		throw new Error("Deno is not available on this machine.");
 	}
 
 	async function ensureTempDir(): Promise<string> {
@@ -139,9 +203,14 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 		signal: AbortSignal | undefined,
 	): Promise<ExecResult> {
 		const dir = await ensureTempDir();
-		const file = join(dir, language === "python" ? "_run.py" : "_run.ts");
+		const file = join(dir, language === "python3" ? "_run.py" : "_run.ts");
 		await writeFile(file, source, "utf8");
-		const args = language === "python" ? [file] : ["--experimental-strip-types", file];
+		const args =
+			language === "python3"
+				? [file]
+				: language === "node"
+					? ["--experimental-strip-types", file]
+					: ["run", "-A", file];
 		const result = await pi.exec(command, args, { cwd, signal, timeout: TIMEOUT_MS });
 		return {
 			...result,
@@ -152,13 +221,13 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 
 	const paramsSchema = Type.Object(
 		{
-			language: StringEnum(detected, { description: "Execution language available on this machine." }),
+			language: StringEnum(detected, {
+				description: "Execution runtime.",
+			}),
 			script: Type.Optional(
-				Type.String({ description: "Full script source for a new run. Omit when retrying with edits." }),
-			),
-			scriptId: Type.Optional(
-				Type.String({ description: "scriptId returned by a failed run. Required when retrying with edits." }),
+				Type.String({ description: "Full source for a new run. Omit when retrying with edits." }),
 			),
+			scriptId: Type.Optional(Type.String({ description: "From a failed run. Required with edits." })),
 			edits: Type.Optional(
 				Type.Array(
 					Type.Object({
@@ -166,8 +235,7 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 						newText: Type.String({ description: "Replacement text." }),
 					}),
 					{
-						description:
-							"Targeted oldText/newText patches applied to the stored script before rerun. Prefer this over resending the whole script.",
+						description: "Patches applied to the stored script before rerun.",
 					},
 				),
 			),
@@ -175,15 +243,26 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 		{ additionalProperties: false },
 	);
 
+	const runtimeNotes = [
+		detected.includes("node")
+			? "language=node: local Node.js via node --experimental-strip-types (not tsc/ts-node)."
+			: undefined,
+		detected.includes("deno") ? "language=deno: local Deno via deno run -A." : undefined,
+	].filter((note): note is string => note !== undefined);
+
 	const tool = defineTool<typeof paramsSchema, undefined>({
 		name: "script_runner",
 		label: "Script Runner",
-		description: `Run a ${langPhrase} script in the project working directory and return its output. On a non-zero exit, returns a scriptId; retry by sending targeted {oldText,newText} edits against the script you already wrote (same language + scriptId) instead of resending the whole script. Available on this machine: ${langPhrase}.`,
-		promptSnippet: `Run ${langPhrase} scripts; fix failures with targeted edits instead of rewriting the whole script.`,
+		description: [
+			`Run a ${langPhrase} script in the project cwd and return stdout.`,
+			...runtimeNotes,
+			"On non-zero exit: result includes scriptId. Retry with same language + scriptId + edits [{oldText,newText}]; do not resend the full script unless the approach is wrong.",
+			`Available: ${langPhrase}.`,
+		].join("\n"),
+		promptSnippet: `Run ${langPhrase} scripts; on failure retry with edits + scriptId.`,
 		promptGuidelines: [
-			`Prefer script_runner over bash for ${langPhrase} when computation, data handling, or bulk file work is cleaner than chaining built-in tools.`,
-			`When script_runner fails, do not resend the full script. Call script_runner again with the same language, the returned scriptId, and an edits array of {oldText,newText} patches against the script you just wrote. Only resend a full script if the approach itself was wrong.`,
-			`script_runner never exposes the script file path, and you already know the script you sent. Never try to read it back.`,
+			`Prefer script_runner over bash for ${langPhrase} when computation, data handling, or bulk file work is cleaner than chaining tools.`,
+			"script_runner never exposes the script path; you already have the source. Never try to read it back.",
 		],
 		parameters: paramsSchema,
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
@@ -191,65 +270,23 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 			if (signal?.aborted) {
 				return { content: [{ type: "text", text: "Cancelled." }], details: undefined };
 			}
-
 			const command = resolveCommand(language);
-			const edits = params.edits;
-			let scriptId: string | undefined = params.scriptId;
-			let source: string;
-
-			if (edits && edits.length > 0) {
-				if (!scriptId) throw new Error("edits require the scriptId returned by the failed run.");
-				const stored = scripts.get(scriptId);
-				if (!stored) {
-					throw new Error(
-						`No stored script for scriptId ${scriptId}. It may have been evicted; resend the full script.`,
-					);
-				}
-				if (stored.language !== language) {
-					throw new Error(`Language mismatch: scriptId ${scriptId} is ${stored.language}, not ${language}.`);
-				}
-				source = applyEdits(stored.source, edits);
-			} else {
-				if (typeof params.script !== "string" || params.script.length === 0) {
-					throw new Error("Provide a script for a new run, or edits + scriptId to retry.");
-				}
-				source = params.script;
-				if (!scriptId) scriptId = newScriptId();
-			}
-
+			const { scriptId, source } = resolveScriptSource(scripts, language, params);
 			remember(scriptId, { language, source });
-			await onUpdate?.({ content: [{ type: "text", text: `Running ${language}...` }], details: undefined });
-
+			await onUpdate?.({
+				content: [{ type: "text", text: `Running ${languageLabel(language)}...` }],
+				details: undefined,
+			});
 			const result = await runScript(language, command, source, ctx.cwd, signal);
 			if (result.code === 0 && !result.killed) {
 				scripts.delete(scriptId);
-				const trunc = truncateTail(result.stdout.trim(), {
-					maxLines: DEFAULT_MAX_LINES,
-					maxBytes: DEFAULT_MAX_BYTES,
-				});
-				const out = trunc.content.trim();
-				const note = trunc.truncated
-					? `\n\n[output truncated: kept tail ${trunc.outputLines} / ${trunc.totalLines} lines]`
-					: "";
-				return {
-					content: [{ type: "text", text: out ? `${out}${note}` : `(no output)${note}` }],
-					details: undefined,
-				};
+				return successScriptResult(result.stdout);
 			}
-
-			const diag = result.stderr.trim() || result.stdout.trim();
-			const trunc = truncateTail(diag, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
-			const note = trunc.truncated
-				? `\n\n[output truncated: kept tail ${trunc.outputLines} / ${trunc.totalLines} lines]`
-				: "";
-			const detail = trunc.content ? `${trunc.content}${note}\n\n` : "";
-			throw new Error(
-				`${detail}scriptId: ${scriptId}\nRetry with edits: [{oldText,newText}] using the same language and scriptId; do not resend the full script.`,
-			);
+			throwScriptFailure(scriptId, result);
 		},
 		renderCall(args, theme, context) {
 			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-			const header = `${theme.fg("toolTitle", theme.bold("script_runner"))} ${theme.fg("muted", args.language)}`;
+			const header = `${theme.fg("toolTitle", theme.bold("script_runner"))} ${theme.fg("muted", languageLabel(args.language))}`;
 			const edits = args.edits;
 			const body =
 				edits && edits.length > 0

package/extensions/silent-command-runner/index.ts

@@ -146,25 +146,11 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		attentionHoldId = undefined;
 	});
 
-	async function runChangedCommands(
-		cwd: string,
-		turnStart: number,
+	async function collectCommandFailures(
+		projectRoot: string,
+		changed: readonly CommandConfig[],
 		notify: (message: string, type?: "info" | "warning" | "error") => void,
-	): Promise<void> {
-		if (!settings.enabled || settings.commands.length === 0) return;
-
-		const projectRoot = await resolveProjectRoot(cwd);
-		const paths = await walkFiles(projectRoot);
-		const changed = await scanChangedCommands(projectRoot, settings.commands, paths, turnPaths, turnStart);
-		if (!sessionActive || changed.length === 0) return;
-
-		notify(
-			changed.length === 1
-				? `silent-command-runner: running ${changed[0]?.name ?? "command"}`
-				: `silent-command-runner: running ${changed.length} commands`,
-			"info",
-		);
-
+	): Promise<FailedCommandDetails[] | undefined> {
 		const failures: FailedCommandDetails[] = [];
 		const controller = new AbortController();
 		abortController = controller;
@@ -175,32 +161,61 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 				try {
 					result = await runCommand(pi, projectRoot, command, controller.signal, settings.maxOutputBytes);
 				} catch (error: unknown) {
-					if (controller.signal.aborted) return;
+					if (controller.signal.aborted) return undefined;
 					throw error;
 				}
-				if (controller.signal.aborted) return;
+				if (controller.signal.aborted) return undefined;
 				if (result.code !== 0 || result.killed) failures.push(result);
 			}
 		} finally {
 			if (abortController === controller) abortController = undefined;
 		}
-		if (!sessionActive) return;
+		return failures;
+	}
 
+	function reportCommandResults(
+		changed: readonly CommandConfig[],
+		failures: readonly FailedCommandDetails[],
+		notify: (message: string, type?: "info" | "warning" | "error") => void,
+	): void {
 		const failedNames = new Set(failures.map((failure) => failure.name));
 		const passed = changed.filter((command) => !failedNames.has(command.name));
 		if (passed.length > 0) notify(`silent-command-runner: passed ${formatCommandNames(passed)}`, "info");
 		if (failures.length === 0) return;
-
 		pi.sendMessage<FailureDetails>(
 			{
 				customType: MESSAGE_TYPE,
 				content: formatAgentMessage(failures),
 				display: true,
-				details: { failed: failures },
+				details: { failed: [...failures] },
 			},
 			{ deliverAs: "followUp" },
 		);
 	}
+
+	async function runChangedCommands(
+		cwd: string,
+		turnStart: number,
+		notify: (message: string, type?: "info" | "warning" | "error") => void,
+	): Promise<void> {
+		if (!settings.enabled || settings.commands.length === 0) return;
+
+		const projectRoot = await resolveProjectRoot(cwd);
+		const paths = await walkFiles(projectRoot);
+		const changed = await scanChangedCommands(projectRoot, settings.commands, paths, turnPaths, turnStart);
+		if (!sessionActive || changed.length === 0) return;
+
+		notify(
+			changed.length === 1
+				? `silent-command-runner: running ${changed[0]?.name ?? "command"}`
+				: `silent-command-runner: running ${changed.length} commands`,
+			"info",
+		);
+
+		const failures = await collectCommandFailures(projectRoot, changed, notify);
+		if (failures === undefined || !sessionActive) return;
+		reportCommandResults(changed, failures, notify);
+	}
 }
 
 function normalizeSettings(value: typeof silentCommandRunnerSettings.defaults): Settings {