@oh-my-pi/pi-coding-agent 6.9.69 → 8.0.0

package/src/task/worktree.ts

@@ -0,0 +1,166 @@
+import { randomUUID } from "node:crypto";
+import { cp, mkdir, rm } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import { $ } from "bun";
+
+export interface WorktreeBaseline {
+	repoRoot: string;
+	staged: string;
+	unstaged: string;
+	untracked: string[];
+}
+
+export function getEncodedProjectName(cwd: string): string {
+	return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+
+export async function getRepoRoot(cwd: string): Promise<string> {
+	const result = await $`git rev-parse --show-toplevel`.cwd(cwd).quiet().nothrow();
+	if (result.exitCode !== 0) {
+		throw new Error("Git repository not found for isolated task execution.");
+	}
+	const repoRoot = result.text().trim();
+	if (!repoRoot) {
+		throw new Error("Git repository root could not be resolved for isolated task execution.");
+	}
+	return repoRoot;
+}
+
+export async function ensureWorktree(baseCwd: string, id: string): Promise<string> {
+	const repoRoot = await getRepoRoot(baseCwd);
+	const encodedProject = getEncodedProjectName(repoRoot);
+	const worktreeDir = path.join(homedir(), ".omp", "wt", encodedProject, id);
+	await mkdir(path.dirname(worktreeDir), { recursive: true });
+	await $`git worktree remove -f ${worktreeDir}`.cwd(repoRoot).quiet().nothrow();
+	await rm(worktreeDir, { recursive: true, force: true });
+	await $`git worktree add --detach ${worktreeDir} HEAD`.cwd(repoRoot).quiet();
+	return worktreeDir;
+}
+
+export async function captureBaseline(repoRoot: string): Promise<WorktreeBaseline> {
+	const staged = await $`git diff --cached --binary`.cwd(repoRoot).quiet().text();
+	const unstaged = await $`git diff --binary`.cwd(repoRoot).quiet().text();
+	const untrackedRaw = await $`git ls-files --others --exclude-standard`.cwd(repoRoot).quiet().text();
+	const untracked = untrackedRaw
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0);
+
+	return {
+		repoRoot,
+		staged,
+		unstaged,
+		untracked,
+	};
+}
+
+async function writeTempPatchFile(patch: string): Promise<string> {
+	const tempPath = path.join(tmpdir(), `omp-task-patch-${randomUUID()}.patch`);
+	await Bun.write(tempPath, patch);
+	return tempPath;
+}
+
+async function applyPatch(
+	cwd: string,
+	patch: string,
+	options?: { cached?: boolean; env?: Record<string, string> },
+): Promise<void> {
+	if (!patch.trim()) return;
+	const tempPath = await writeTempPatchFile(patch);
+	try {
+		const command = options?.cached ? $`git apply --cached --binary ${tempPath}` : $`git apply --binary ${tempPath}`;
+		let runner = command.cwd(cwd).quiet();
+		if (options?.env) {
+			runner = runner.env(options.env);
+		}
+		await runner;
+	} finally {
+		await rm(tempPath, { force: true });
+	}
+}
+
+export async function applyBaseline(worktreeDir: string, baseline: WorktreeBaseline): Promise<void> {
+	await applyPatch(worktreeDir, baseline.staged, { cached: true });
+	await applyPatch(worktreeDir, baseline.staged);
+	await applyPatch(worktreeDir, baseline.unstaged);
+
+	for (const entry of baseline.untracked) {
+		const source = path.join(baseline.repoRoot, entry);
+		const destination = path.join(worktreeDir, entry);
+		const exists = await Bun.file(source).exists();
+		if (!exists) continue;
+		await mkdir(path.dirname(destination), { recursive: true });
+		await cp(source, destination, { recursive: true });
+	}
+}
+
+async function applyPatchToIndex(cwd: string, patch: string, indexFile: string): Promise<void> {
+	if (!patch.trim()) return;
+	const tempPath = await writeTempPatchFile(patch);
+	try {
+		await $`git apply --cached --binary ${tempPath}`
+			.cwd(cwd)
+			.env({
+				GIT_INDEX_FILE: indexFile,
+			})
+			.quiet();
+	} finally {
+		await rm(tempPath, { force: true });
+	}
+}
+
+async function listUntracked(cwd: string): Promise<string[]> {
+	const raw = await $`git ls-files --others --exclude-standard`.cwd(cwd).quiet().text();
+	return raw
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0);
+}
+
+export async function captureDeltaPatch(worktreeDir: string, baseline: WorktreeBaseline): Promise<string> {
+	const tempIndex = path.join(tmpdir(), `omp-task-index-${randomUUID()}`);
+	try {
+		await $`git read-tree HEAD`.cwd(worktreeDir).env({
+			GIT_INDEX_FILE: tempIndex,
+		});
+		await applyPatchToIndex(worktreeDir, baseline.staged, tempIndex);
+		await applyPatchToIndex(worktreeDir, baseline.unstaged, tempIndex);
+		const diff = await $`git diff --binary`
+			.cwd(worktreeDir)
+			.env({
+				GIT_INDEX_FILE: tempIndex,
+			})
+			.quiet()
+			.text();
+
+		const currentUntracked = await listUntracked(worktreeDir);
+		const baselineUntracked = new Set(baseline.untracked);
+		const newUntracked = currentUntracked.filter((entry) => !baselineUntracked.has(entry));
+
+		if (newUntracked.length === 0) return diff;
+
+		const untrackedDiffs = await Promise.all(
+			newUntracked.map((entry) =>
+				$`git diff --binary --no-index /dev/null ${entry}`.cwd(worktreeDir).quiet().nothrow().text(),
+			),
+		);
+		return `${diff}${diff && !diff.endsWith("\n") ? "\n" : ""}${untrackedDiffs.join("\n")}`;
+	} finally {
+		await rm(tempIndex, { force: true });
+	}
+}
+
+export async function cleanupWorktree(dir: string): Promise<void> {
+	try {
+		const commonDirRaw = await $`git rev-parse --git-common-dir`.cwd(dir).quiet().nothrow().text();
+		const commonDir = commonDirRaw.trim();
+		if (commonDir) {
+			const resolvedCommon = path.resolve(dir, commonDir);
+			const repoRoot = path.dirname(resolvedCommon);
+			await $`git worktree remove -f ${dir}`.cwd(repoRoot).quiet().nothrow();
+		}
+	} finally {
+		await rm(dir, { recursive: true, force: true });
+	}
+}

package/src/{core/tools → tools}/ask.ts

@@ -19,10 +19,10 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { type Theme, theme } from "../../modes/interactive/theme/theme";
-import askDescription from "../../prompts/tools/ask.md" with { type: "text" };
-import type { RenderResultOptions } from "../custom-tools/types";
-import { renderPromptTemplate } from "../prompt-templates";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import { type Theme, theme } from "$c/modes/theme/theme";
+import askDescription from "$c/prompts/tools/ask.md" with { type: "text" };
 import type { ToolSession } from "./index";
 import { ToolUIKit } from "./render-utils";
 
@@ -31,29 +31,21 @@ import { ToolUIKit } from "./render-utils";
 // =============================================================================
 
 const OptionItem = Type.Object({
-	label: Type.String({ description: "Display label for this option" }),
+	label: Type.String({ description: "Display label" }),
 });
 
 const QuestionItem = Type.Object({
-	id: Type.String({ description: "Short identifier for this question (e.g., 'auth', 'cache')" }),
-	question: Type.String({ description: "The question text" }),
-	options: Type.Array(OptionItem, { description: "Options for this question" }),
-	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections for this question" })),
+	id: Type.String({ description: "Question ID, e.g. 'auth', 'cache'" }),
+	question: Type.String({ description: "Question text" }),
+	options: Type.Array(OptionItem, { description: "Available options" }),
+	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections" })),
 });
 
 const askSchema = Type.Object({
-	question: Type.Optional(Type.String({ description: "The question to ask the user" })),
-	options: Type.Optional(Type.Array(OptionItem, { description: "Available options for the user to choose from." })),
-	multi: Type.Optional(
-		Type.Boolean({
-			description: "Allow multiple options to be selected (default: false)",
-		}),
-	),
-	questions: Type.Optional(
-		Type.Array(QuestionItem, {
-			description: "Multiple questions to ask in sequence, each with their own options",
-		}),
-	),
+	question: Type.Optional(Type.String({ description: "Question to ask" })),
+	options: Type.Optional(Type.Array(OptionItem, { description: "Available options" })),
+	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections (default: false)" })),
+	questions: Type.Optional(Type.Array(QuestionItem, { description: "Multiple questions in sequence" })),
 });
 
 /** Result for a single question */

package/src/{core/tools → tools}/bash-interceptor.ts

@@ -6,7 +6,7 @@
  * the specialized tools instead.
  */
 
-import { type BashInterceptorRule, DEFAULT_BASH_INTERCEPTOR_RULES } from "../settings-manager";
+import { type BashInterceptorRule, DEFAULT_BASH_INTERCEPTOR_RULES } from "$c/config/settings-manager";
 
 export interface InterceptionResult {
 	/** If true, the bash command should be blocked */

package/src/{core/tools → tools}/bash.ts

@@ -3,30 +3,33 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { truncateToVisualLines } from "../../modes/interactive/components/visual-truncate";
-import type { Theme } from "../../modes/interactive/theme/theme";
-import bashDescription from "../../prompts/tools/bash.md" with { type: "text" };
-import { type BashExecutorOptions, executeBash } from "../bash-executor";
-import type { RenderResultOptions } from "../custom-tools/types";
-import { renderPromptTemplate } from "../prompt-templates";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import { type BashExecutorOptions, executeBash } from "$c/exec/bash-executor";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import { truncateToVisualLines } from "$c/modes/components/visual-truncate";
+import type { Theme } from "$c/modes/theme/theme";
+import bashDescription from "$c/prompts/tools/bash.md" with { type: "text" };
+import type { OutputMeta } from "$c/tools/output-meta";
+import { ToolError } from "$c/tools/tool-errors";
+
 import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor";
 import type { ToolSession } from "./index";
+import { allocateOutputArtifact, createTailBuffer } from "./output-utils";
 import { resolveToCwd } from "./path-utils";
 import { ToolUIKit } from "./render-utils";
-import { formatTailTruncationNotice, type TruncationResult, truncateTail } from "./truncate";
+import { toolResult } from "./tool-result";
+import { DEFAULT_MAX_BYTES } from "./truncate";
 
 export const BASH_DEFAULT_PREVIEW_LINES = 10;
 
 const bashSchema = Type.Object({
-	command: Type.String({ description: "Bash command to execute" }),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
-	cwd: Type.Optional(Type.String({ description: "Working directory for the command (default: current directory)" })),
+	command: Type.String({ description: "Command to execute" }),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 300)" })),
+	cwd: Type.Optional(Type.String({ description: "Working directory (default: cwd)" })),
 });
 
 export interface BashToolDetails {
-	truncation?: TruncationResult;
-	fullOutputPath?: string;
-	fullOutput?: string;
+	meta?: OutputMeta;
 }
 
 export interface BashToolOptions {}
@@ -51,7 +54,7 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 
 	public async execute(
 		_toolCallId: string,
-		{ command, timeout, cwd }: { command: string; timeout?: number; cwd?: string },
+		{ command, timeout: rawTimeout = 300, cwd }: { command: string; timeout?: number; cwd?: string },
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
 		ctx?: AgentToolContext,
@@ -61,12 +64,12 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 			const rules = this.session.settings?.getBashInterceptorRules?.();
 			const interception = checkBashInterception(command, ctx?.toolNames ?? [], rules);
 			if (interception.block) {
-				throw new Error(interception.message);
+				throw new ToolError(interception.message ?? "Command blocked");
 			}
 			if (this.session.settings?.getBashInterceptorSimpleLsEnabled?.() !== false) {
 				const lsInterception = checkSimpleLsInterception(command, ctx?.toolNames ?? []);
 				if (lsInterception.block) {
-					throw new Error(lsInterception.message);
+					throw new ToolError(lsInterception.message ?? "Command blocked");
 				}
 			}
 		}
@@ -76,26 +79,39 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 		try {
 			cwdStat = await Bun.file(commandCwd).stat();
 		} catch {
-			throw new Error(`Working directory does not exist: ${commandCwd}`);
+			throw new ToolError(`Working directory does not exist: ${commandCwd}`);
 		}
 		if (!cwdStat.isDirectory()) {
-			throw new Error(`Working directory is not a directory: ${commandCwd}`);
+			throw new ToolError(`Working directory is not a directory: ${commandCwd}`);
 		}
 
-		// Track output for streaming updates
-		let currentOutput = "";
+		// Auto-convert milliseconds to seconds if value > 1000 (16+ min is unreasonable)
+		let timeoutSec = rawTimeout > 1000 ? rawTimeout / 1000 : rawTimeout;
+		// Clamp to reasonable range: 1s - 3600s (1 hour)
+		timeoutSec = Math.max(1, Math.min(3600, timeoutSec));
+		const timeoutMs = timeoutSec * 1000;
+
+		// Track output for streaming updates (tail only)
+		const tailBuffer = createTailBuffer(DEFAULT_MAX_BYTES);
+
+		// Set up artifacts environment and allocation
+		const artifactsDir = this.session.getArtifactsDir?.();
+		const extraEnv = artifactsDir ? { ARTIFACTS: artifactsDir } : undefined;
+		const { artifactPath, artifactId } = await allocateOutputArtifact(this.session, "bash");
 
 		const executorOptions: BashExecutorOptions = {
 			cwd: commandCwd,
-			timeout: timeout ? timeout * 1000 : undefined, // Convert to milliseconds
+			timeout: timeoutMs,
 			signal,
+			env: extraEnv,
+			artifactPath,
+			artifactId,
 			onChunk: (chunk) => {
-				currentOutput += chunk;
+				tailBuffer.append(chunk);
 				if (onUpdate) {
-					const truncation = truncateTail(currentOutput);
 					onUpdate({
-						content: [{ type: "text", text: truncation.content || "" }],
-						details: truncation.truncated ? { truncation, fullOutput: currentOutput } : {},
+						content: [{ type: "text", text: tailBuffer.text() }],
+						details: {},
 					});
 				}
 			},
@@ -104,33 +120,18 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 		// Handle errors
 		const result = await executeBash(command, executorOptions);
 		if (result.cancelled) {
-			throw new Error(result.output || "Command aborted");
+			throw new ToolError(result.output || "Command aborted");
 		}
 
-		// Apply tail truncation for final output
-		const truncation = truncateTail(result.output);
-		let outputText = truncation.content || "(no output)";
-
-		let details: BashToolDetails | undefined;
-
-		if (truncation.truncated) {
-			details = {
-				truncation,
-				fullOutputPath: result.fullOutputPath,
-				fullOutput: currentOutput,
-			};
-			outputText += formatTailTruncationNotice(truncation, {
-				fullOutputPath: result.fullOutputPath,
-				originalContent: result.output,
-			});
-		}
+		const outputText = result.output || "(no output)";
+		const details: BashToolDetails = {};
+		const resultBuilder = toolResult(details).text(outputText).truncationFromSummary(result, { direction: "tail" });
 
 		if (result.exitCode !== 0 && result.exitCode !== undefined) {
-			outputText += `\n\nCommand exited with code ${result.exitCode}`;
-			throw new Error(outputText);
+			throw new ToolError(`${outputText}\n\nCommand exited with code ${result.exitCode}`);
 		}
 
-		return { content: [{ type: "text", text: outputText }], details };
+		return resultBuilder.done();
 	}
 }
 
@@ -147,6 +148,8 @@ interface BashRenderArgs {
 interface BashRenderContext {
 	/** Raw output text */
 	output?: string;
+	/** Whether output came from artifact storage */
+	isFullOutput?: boolean;
 	/** Whether output is expanded */
 	expanded?: boolean;
 	/** Number of preview lines when collapsed */
@@ -198,38 +201,33 @@ export const bashToolRenderer = {
 		const ui = new ToolUIKit(uiTheme);
 		const { renderContext } = options;
 		const details = result.details;
-
 		const expanded = renderContext?.expanded ?? options.expanded;
 		const previewLines = renderContext?.previewLines ?? BASH_DEFAULT_PREVIEW_LINES;
 
 		// Get output from context (preferred) or fall back to result content
 		const output = renderContext?.output ?? (result.content?.find((c) => c.type === "text")?.text ?? "").trim();
-		const fullOutput = details?.fullOutput;
-		const displayOutput = expanded ? (fullOutput ?? output) : output;
-		const showingFullOutput = expanded && fullOutput !== undefined;
+		const displayOutput = output;
+		const showingFullOutput = expanded && renderContext?.isFullOutput === true;
 
 		// Build truncation warning lines (static, doesn't depend on width)
-		const truncation = details?.truncation;
-		const fullOutputPath = details?.fullOutputPath;
+		const truncation = details?.meta?.truncation;
 		const timeoutSeconds = renderContext?.timeout;
 		const timeoutLine =
 			typeof timeoutSeconds === "number"
 				? uiTheme.fg("dim", ui.wrapBrackets(`Timeout: ${timeoutSeconds}s`))
 				: undefined;
 		let warningLine: string | undefined;
-		if (fullOutputPath || (truncation?.truncated && !showingFullOutput)) {
+		if (truncation && !showingFullOutput) {
 			const warnings: string[] = [];
-			if (fullOutputPath) {
-				warnings.push(`Full output: ${fullOutputPath}`);
+			if (truncation?.artifactId) {
+				warnings.push(`Full output: artifact://${truncation.artifactId}`);
 			}
-			if (truncation?.truncated && !showingFullOutput) {
-				if (truncation.truncatedBy === "lines") {
-					warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
-				} else {
-					warnings.push(
-						`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.maxBytes)} limit)`,
-					);
-				}
+			if (truncation.truncatedBy === "lines") {
+				warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
+			} else {
+				warnings.push(
+					`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.outputBytes)} limit)`,
+				);
 			}
 			if (warnings.length > 0) {
 				warningLine = uiTheme.fg("warning", ui.wrapBrackets(warnings.join(". ")));

package/src/{core/tools → tools}/calculator.ts

@@ -3,10 +3,10 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { untilAborted } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
-import type { Theme } from "../../modes/interactive/theme/theme";
-import calculatorDescription from "../../prompts/tools/calculator.md" with { type: "text" };
-import type { RenderResultOptions } from "../custom-tools/types";
-import { renderPromptTemplate } from "../prompt-templates";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import type { Theme } from "$c/modes/theme/theme";
+import calculatorDescription from "$c/prompts/tools/calculator.md" with { type: "text" };
 import type { ToolSession } from "./index";
 import {
 	formatCount,

package/src/{core/tools → tools}/complete.ts

@@ -9,9 +9,9 @@ import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Static, TObject } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
 import Ajv, { type ErrorObject, type ValidateFunction } from "ajv";
+import { subprocessToolRegistry } from "$c/task/subprocess-tool-registry";
 import type { ToolSession } from "./index";
 import { jtdToJsonSchema } from "./jtd-to-json-schema";
-import { subprocessToolRegistry } from "./task/subprocess-tool-registry";
 
 export interface CompleteDetails {
 	data: unknown;

package/src/{core/tools → tools}/context.ts

@@ -1,6 +1,6 @@
 import type { AgentToolContext, ToolCallContext } from "@oh-my-pi/pi-agent-core";
-import type { CustomToolContext } from "../custom-tools/types";
-import type { ExtensionUIContext } from "../extensions/types";
+import type { CustomToolContext } from "$c/extensibility/custom-tools/types";
+import type { ExtensionUIContext } from "$c/extensibility/extensions/types";
 
 declare module "@oh-my-pi/pi-agent-core" {
 	interface AgentToolContext extends CustomToolContext {