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

package/src/{core/tools/task → task}/executor.ts

@@ -6,17 +6,17 @@
 
 import path from "node:path";
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { AuthStorage } from "../../auth-storage";
-import type { EventBus } from "../../event-bus";
-import { callTool } from "../../mcp/client";
-import type { MCPManager } from "../../mcp/manager";
-import type { ModelRegistry } from "../../model-registry";
-import { formatModelString, parseModelPattern } from "../../model-resolver";
-import { checkPythonKernelAvailability } from "../../python-kernel";
+import type { ModelRegistry } from "$c/config/model-registry";
+import { formatModelString, parseModelPattern } from "$c/config/model-resolver";
+import { checkPythonKernelAvailability } from "$c/ipy/kernel";
+import { LspTool } from "$c/lsp/index";
+import type { LspParams } from "$c/lsp/types";
+import { callTool } from "$c/mcp/client";
+import type { MCPManager } from "$c/mcp/manager";
+import type { AuthStorage } from "$c/session/auth-storage";
+import { PythonTool, type PythonToolParams } from "$c/tools/python";
+import type { EventBus } from "$c/utils/event-bus";
 import type { ToolSession } from "..";
-import { LspTool } from "../lsp/index";
-import type { LspParams } from "../lsp/types";
-import { PythonTool, type PythonToolParams } from "../python";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import {
 	type AgentDefinition,
@@ -41,11 +41,12 @@ import type {
 /** Options for worker execution */
 export interface ExecutorOptions {
 	cwd: string;
+	worktree?: string;
 	agent: AgentDefinition;
 	task: string;
 	description?: string;
 	index: number;
-	taskId: string;
+	id: string;
 	context?: string;
 	modelOverride?: string;
 	thinkingLevel?: ThinkingLevel;
@@ -61,7 +62,7 @@ export interface ExecutorOptions {
 	authStorage?: AuthStorage;
 	modelRegistry?: ModelRegistry;
 	settingsManager?: {
-		serialize: () => import("../../settings-manager").Settings;
+		serialize: () => import("$c/config/settings-manager").Settings;
 		getPythonToolMode?: () => "ipy-only" | "bash-only" | "both";
 		getPythonKernelMode?: () => "session" | "per-call";
 		getPythonSharedGateway?: () => boolean;
@@ -162,35 +163,24 @@ function getUsageTokens(usage: unknown): number {
 	return input + output + cacheRead + cacheWrite;
 }
 
-/**
- * Parse MCP tool name to extract server and tool names.
- * Format: mcp_<serverName>_<toolName>
- * Note: Uses lastIndexOf to handle server names with underscores.
- */
-function parseMCPToolName(fullName: string): { serverName: string; toolName: string } | undefined {
-	if (!fullName.startsWith("mcp_")) return undefined;
-	const rest = fullName.slice(4);
-	const underscoreIndex = rest.lastIndexOf("_");
-	if (underscoreIndex === -1) return undefined;
-	return {
-		serverName: rest.slice(0, underscoreIndex),
-		toolName: rest.slice(underscoreIndex + 1),
-	};
-}
-
 /**
  * Extract MCP tool metadata from MCPManager for passing to worker.
+ *
+ * MCPTool and DeferredMCPTool expose mcpToolName (original MCP tool name)
+ * and mcpServerName properties. We use these directly when available,
+ * falling back to empty strings if not.
  */
 function extractMCPToolMetadata(mcpManager: MCPManager): MCPToolMetadata[] {
 	return mcpManager.getTools().map((tool) => {
-		const parsed = parseMCPToolName(tool.name);
+		// MCPTool and DeferredMCPTool have these properties
+		const mcpTool = tool as { mcpToolName?: string; mcpServerName?: string };
 		return {
 			name: tool.name,
 			label: tool.label ?? tool.name,
 			description: tool.description ?? "",
 			parameters: tool.parameters,
-			serverName: parsed?.serverName ?? "",
-			mcpToolName: parsed?.toolName ?? "",
+			serverName: mcpTool.mcpServerName ?? "",
+			mcpToolName: mcpTool.mcpToolName ?? "",
 		};
 	});
 }
@@ -204,7 +194,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		agent,
 		task,
 		index,
-		taskId,
+		id,
+		worktree,
 		context,
 		modelOverride,
 		thinkingLevel,
@@ -218,7 +209,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	// Initialize progress
 	const progress: AgentProgress = {
 		index,
-		taskId,
+		id,
 		agent: agent.name,
 		agentSource: agent.source,
 		status: "running",
@@ -236,7 +227,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	if (signal?.aborted) {
 		return {
 			index,
-			taskId,
+			id,
 			agent: agent.name,
 			agentSource: agent.source,
 			task,
@@ -258,7 +249,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	// Set up artifact paths and write input file upfront if artifacts dir provided
 	let subtaskSessionFile: string | undefined;
 	if (options.artifactsDir) {
-		subtaskSessionFile = path.join(options.artifactsDir, `${taskId}.jsonl`);
+		subtaskSessionFile = path.join(options.artifactsDir, `${id}.jsonl`);
 	}
 
 	// Add tools if specified
@@ -324,7 +315,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	} catch (err) {
 		return {
 			index,
-			taskId,
+			id,
 			agent: agent.name,
 			agentSource: agent.source,
 			task,
@@ -385,7 +376,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		return AbortSignal.timeout(timeoutMs);
 	};
 
-	const pythonSessionFile = sessionFile ?? `subtask:${taskId}`;
+	const pythonSessionFile = sessionFile ?? `subtask:${id}`;
 	const pythonToolSession: ToolSession = {
 		cwd,
 		hasUI: false,
@@ -689,6 +680,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		type: "start",
 		payload: {
 			cwd,
+			worktree,
 			task: fullTask,
 			systemPrompt: agent.systemPrompt,
 			model: resolvedModel,
@@ -743,12 +735,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				return;
 			}
 			try {
-				const parsed = parseMCPToolName(request.toolName);
-				if (!parsed) throw new Error(`Invalid MCP tool name: ${request.toolName}`);
 				const result = await withTimeout(
 					(async () => {
-						const connection = await mcpManager.waitForConnection(parsed.serverName);
-						return callTool(connection, parsed.toolName, request.params);
+						const connection = await mcpManager.waitForConnection(request.serverName);
+						return callTool(connection, request.mcpToolName, request.params);
 					})(),
 					request.timeoutMs,
 				);
@@ -1025,11 +1015,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	const { text: truncatedOutput, truncated } = truncateOutput(rawOutput);
 
 	// Write output artifact (input and jsonl already written in real-time)
-	// Compute output metadata for Output tool integration
+	// Compute output metadata for agent:// URL integration
 	let outputMeta: { lineCount: number; charCount: number } | undefined;
 	let outputPath: string | undefined;
 	if (options.artifactsDir) {
-		outputPath = path.join(options.artifactsDir, `${taskId}.md`);
+		outputPath = path.join(options.artifactsDir, `${id}.md`);
 		try {
 			await Bun.write(outputPath, rawOutput);
 			outputMeta = {
@@ -1048,7 +1038,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	return {
 		index,
-		taskId,
+		id,
 		agent: agent.name,
 		agentSource: agent.source,
 		task,

package/src/{core/tools/task → task}/index.ts

@@ -13,25 +13,25 @@
  *   - Session artifacts for debugging
  */
 
-import { mkdir, rm } from "node:fs/promises";
+import { mkdir, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
+import { $ } from "bun";
 import { nanoid } from "nanoid";
-import type { Theme } from "../../../modes/interactive/theme/theme";
-import taskDescriptionTemplate from "../../../prompts/tools/task.md" with { type: "text" };
-import { renderPromptTemplate } from "../../prompt-templates";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import type { Theme } from "$c/modes/theme/theme";
+import taskDescriptionTemplate from "$c/prompts/tools/task.md" with { type: "text" };
+import { formatDuration } from "$c/tools/render-utils";
 import type { ToolSession } from "..";
-import { formatDuration } from "../render-utils";
 import { discoverAgents, getAgent } from "./discovery";
 import { runSubprocess } from "./executor";
 import { mapWithConcurrencyLimit } from "./parallel";
 import { renderCall, renderResult } from "./render";
-import { renderTemplate, validateTaskTemplate } from "./template";
+import { renderTemplate } from "./template";
 import {
 	type AgentProgress,
-	MAX_AGENTS_IN_DESCRIPTION,
 	MAX_CONCURRENCY,
 	MAX_PARALLEL_TASKS,
 	type SingleResult,
@@ -39,9 +39,17 @@ import {
 	type TaskToolDetails,
 	taskSchema,
 } from "./types";
+import {
+	applyBaseline,
+	captureBaseline,
+	captureDeltaPatch,
+	cleanupWorktree,
+	ensureWorktree,
+	getRepoRoot,
+} from "./worktree";
 
 // Import review tools for side effects (registers subagent tool handlers)
-import "../review";
+import "../tools/review";
 
 /** Format byte count for display */
 function formatBytes(bytes: number): string {
@@ -103,8 +111,7 @@ async function buildDescription(cwd: string): Promise<string> {
 	const { agents } = await discoverAgents(cwd);
 
 	return renderPromptTemplate(taskDescriptionTemplate, {
-		agents: agents.slice(0, MAX_AGENTS_IN_DESCRIPTION),
-		moreAgents: agents.length > MAX_AGENTS_IN_DESCRIPTION ? agents.length - MAX_AGENTS_IN_DESCRIPTION : 0,
+		agents,
 		MAX_PARALLEL_TASKS,
 		MAX_CONCURRENCY,
 	});
@@ -153,7 +160,8 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 	): Promise<AgentToolResult<TaskToolDetails>> {
 		const startTime = Date.now();
 		const { agents, projectAgentsDir } = await discoverAgents(this.session.cwd);
-		const { agent: agentName, context, model, output: outputSchema } = params;
+		const { agent: agentName, context, output: outputSchema, isolated } = params;
+		const isIsolated = isolated === true;
 
 		const isDefaultModelAlias = (value: string | undefined): boolean => {
 			if (!value) return true;
@@ -180,9 +188,9 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			};
 		}
 
-		const shouldInheritSessionModel = model === undefined && isDefaultModelAlias(agent.model);
-		const sessionModel = shouldInheritSessionModel ? this.session.getActiveModelString?.() : undefined;
-		const modelOverride = model ?? sessionModel ?? this.session.getModelString?.();
+		const effectiveAgentModel = isDefaultModelAlias(agent.model) ? undefined : agent.model;
+		const modelOverride =
+			effectiveAgentModel ?? this.session.getActiveModelString?.() ?? this.session.getModelString?.();
 		const thinkingLevelOverride = agent.thinkingLevel;
 
 		// Output schema priority: agent frontmatter > params > inherited from parent session
@@ -195,7 +203,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 				content: [
 					{
 						type: "text",
-						text: `No tasks provided. Use: { agent, context, tasks: [{id, description, vars}, ...] }`,
+						text: `No tasks provided. Use: { agent, context, tasks: [{id, description, args}, ...] }`,
 					},
 				],
 				details: {
@@ -271,16 +279,28 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			};
 		}
 
-		const templateError = validateTaskTemplate(context, tasks);
-		if (templateError) {
-			return {
-				content: [{ type: "text", text: templateError }],
-				details: {
-					projectAgentsDir,
-					results: [],
-					totalDurationMs: 0,
-				},
-			};
+		let repoRoot: string | null = null;
+		let baseline = null as Awaited<ReturnType<typeof captureBaseline>> | null;
+		if (isIsolated) {
+			try {
+				repoRoot = await getRepoRoot(this.session.cwd);
+				baseline = await captureBaseline(repoRoot);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Isolated task execution requires a git repository. ${message}`,
+						},
+					],
+					details: {
+						projectAgentsDir,
+						results: [],
+						totalDurationMs: Date.now() - startTime,
+					},
+				};
+			}
 		}
 
 		// Derive artifacts directory
@@ -347,25 +367,19 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			}
 
 			// Build full prompts with context prepended
-			const contextTemplate = context ?? "";
-			const tasksWithContext = tasks.map((t) => ({
-				task: renderTemplate(contextTemplate, t.vars),
-				description: t.description,
-				taskId: t.id,
-				vars: t.vars,
-			}));
+			const tasksWithContext = tasks.map((t) => renderTemplate(context, t));
 
 			// Initialize progress for all tasks
 			for (let i = 0; i < tasksWithContext.length; i++) {
 				const t = tasksWithContext[i];
 				progressMap.set(i, {
 					index: i,
-					taskId: t.taskId,
+					id: t.id,
 					agent: agentName,
 					agentSource: agent.source,
 					status: "pending",
 					task: t.task,
-					vars: t.vars,
+					args: t.args,
 					recentTools: [],
 					recentOutput: [],
 					toolCount: 0,
@@ -377,18 +391,15 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			}
 			emitProgress();
 
-			// Execute in parallel with concurrency limit
-			const { results: partialResults, aborted } = await mapWithConcurrencyLimit(
-				tasksWithContext,
-				MAX_CONCURRENCY,
-				async (task, index) => {
+			const runTask = async (task: (typeof tasksWithContext)[number], index: number) => {
+				if (!isIsolated) {
 					return runSubprocess({
 						cwd: this.session.cwd,
 						agent,
 						task: task.task,
 						description: task.description,
 						index,
-						taskId: task.taskId,
+						id: task.id,
 						context: undefined, // Already prepended above
 						modelOverride,
 						thinkingLevel: thinkingLevelOverride,
@@ -402,7 +413,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						onProgress: (progress) => {
 							progressMap.set(index, {
 								...structuredClone(progress),
-								vars: tasksWithContext[index]?.vars,
+								args: tasksWithContext[index]?.args,
 							});
 							emitProgress();
 						},
@@ -411,7 +422,83 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						settingsManager: this.session.settingsManager,
 						mcpManager: this.session.mcpManager,
 					});
-				},
+				}
+
+				const taskStart = Date.now();
+				let worktreeDir: string | undefined;
+				try {
+					if (!repoRoot || !baseline) {
+						throw new Error("Isolated task execution not initialized.");
+					}
+					worktreeDir = await ensureWorktree(repoRoot, task.id);
+					await applyBaseline(worktreeDir, baseline);
+					const result = await runSubprocess({
+						cwd: this.session.cwd,
+						worktree: worktreeDir,
+						agent,
+						task: task.task,
+						description: task.description,
+						index,
+						id: task.id,
+						context: undefined, // Already prepended above
+						modelOverride,
+						thinkingLevel: thinkingLevelOverride,
+						outputSchema: effectiveOutputSchema,
+						sessionFile,
+						persistArtifacts: !!artifactsDir,
+						artifactsDir: effectiveArtifactsDir,
+						enableLsp: false,
+						signal,
+						eventBus: undefined,
+						onProgress: (progress) => {
+							progressMap.set(index, {
+								...structuredClone(progress),
+								args: tasksWithContext[index]?.args,
+							});
+							emitProgress();
+						},
+						authStorage: this.session.authStorage,
+						modelRegistry: this.session.modelRegistry,
+						settingsManager: this.session.settingsManager,
+						mcpManager: this.session.mcpManager,
+					});
+					const patch = await captureDeltaPatch(worktreeDir, baseline);
+					const patchPath = path.join(effectiveArtifactsDir, `${task.id}.patch`);
+					await Bun.write(patchPath, patch);
+					return {
+						...result,
+						patchPath,
+					};
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					return {
+						index,
+						id: task.id,
+						agent: agent.name,
+						agentSource: agent.source,
+						task: task.task,
+						description: task.description,
+						exitCode: 1,
+						output: "",
+						stderr: message,
+						truncated: false,
+						durationMs: Date.now() - taskStart,
+						tokens: 0,
+						modelOverride,
+						error: message,
+					};
+				} finally {
+					if (worktreeDir) {
+						await cleanupWorktree(worktreeDir);
+					}
+				}
+			};
+
+			// Execute in parallel with concurrency limit
+			const { results: partialResults, aborted } = await mapWithConcurrencyLimit(
+				tasksWithContext,
+				MAX_CONCURRENCY,
+				runTask,
 				signal,
 			);
 
@@ -420,17 +507,17 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 				if (result !== undefined) {
 					return {
 						...result,
-						vars: tasksWithContext[index]?.vars,
+						args: tasksWithContext[index]?.args,
 					};
 				}
 				const task = tasksWithContext[index];
 				return {
 					index,
-					taskId: task.taskId,
+					id: task.id,
 					agent: agentName,
 					agentSource: agent.source,
 					task: task.task,
-					vars: task.vars,
+					args: task.args,
 					description: task.description,
 					exitCode: 1,
 					output: "",
@@ -456,10 +543,75 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 
 			// Collect output paths (artifacts already written by executor in real-time)
 			const outputPaths: string[] = [];
+			const patchPaths: string[] = [];
 			for (const result of results) {
 				if (result.outputPath) {
 					outputPaths.push(result.outputPath);
 				}
+				if (result.patchPath) {
+					patchPaths.push(result.patchPath);
+				}
+			}
+
+			let patchApplySummary = "";
+			let patchesApplied: boolean | null = null;
+			if (isIsolated) {
+				const patchesInOrder = results.map((result) => result.patchPath).filter(Boolean) as string[];
+				const missingPatch = results.some((result) => !result.patchPath);
+				if (!repoRoot || missingPatch) {
+					patchesApplied = false;
+				} else {
+					const patchStats = await Promise.all(
+						patchesInOrder.map(async (patchPath) => ({
+							patchPath,
+							size: (await stat(patchPath)).size,
+						})),
+					);
+					const nonEmptyPatches = patchStats.filter((patch) => patch.size > 0).map((patch) => patch.patchPath);
+					if (nonEmptyPatches.length === 0) {
+						patchesApplied = true;
+					} else {
+						const patchTexts = await Promise.all(
+							nonEmptyPatches.map(async (patchPath) => Bun.file(patchPath).text()),
+						);
+						const combinedPatch = patchTexts.map((text) => (text.endsWith("\n") ? text : `${text}\n`)).join("");
+						if (!combinedPatch.trim()) {
+							patchesApplied = true;
+						} else {
+							const combinedPatchPath = path.join(tmpdir(), `omp-task-combined-${nanoid()}.patch`);
+							try {
+								await Bun.write(combinedPatchPath, combinedPatch);
+								const checkResult = await $`git apply --check --binary ${combinedPatchPath}`
+									.cwd(repoRoot)
+									.quiet()
+									.nothrow();
+								if (checkResult.exitCode !== 0) {
+									patchesApplied = false;
+								} else {
+									const applyResult = await $`git apply --binary ${combinedPatchPath}`
+										.cwd(repoRoot)
+										.quiet()
+										.nothrow();
+									patchesApplied = applyResult.exitCode === 0;
+								}
+							} finally {
+								await rm(combinedPatchPath, { force: true });
+							}
+						}
+					}
+				}
+
+				if (patchesApplied) {
+					patchApplySummary = "\n\nApplied patches: yes";
+				} else {
+					const notification =
+						"<system-notification>Patches were not applied and must be handled manually.</system-notification>";
+					const patchList =
+						patchPaths.length > 0
+							? `\n\nPatch artifacts:\n${patchPaths.map((patch) => `- ${patch}`).join("\n")}`
+							: "";
+					patchApplySummary = `\n\n${notification}${patchList}`;
+				}
 			}
 
 			// Build final output - match plugin format
@@ -474,22 +626,26 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 				const meta = r.outputMeta
 					? ` [${r.outputMeta.lineCount} lines, ${formatBytes(r.outputMeta.charCount)}]`
 					: "";
-				return `[${r.agent}] ${status}${meta} ${r.taskId}\n${preview}`;
+				return `[${r.agent}] ${status}${meta} ${r.id}\n${preview}`;
 			});
 
-			const outputIds = results.filter((r) => !r.aborted || r.output.trim()).map((r) => r.taskId);
+			const outputIds = results.filter((r) => !r.aborted || r.output.trim()).map((r) => r.id);
 			const outputHint =
-				outputIds.length > 0 ? `\n\nUse output tool for full logs: output ids ${outputIds.join(", ")}` : "";
+				outputIds.length > 0
+					? `\n\nUse read with agent:// for full logs: ${outputIds.map((id) => `agent://${id}`).join(", ")}`
+					: "";
 			const schemaNote = schemaOverridden
 				? `\n\nNote: Agent '${agentName}' has a fixed output schema; your 'output' parameter was ignored.\nRequired schema: ${JSON.stringify(agent.output)}`
 				: "";
 			const cancelledNote = aborted && cancelledCount > 0 ? ` (${cancelledCount} cancelled)` : "";
 			const summary = `${successCount}/${results.length} succeeded${cancelledNote} [${formatDuration(
 				totalDuration,
-			)}]\n\n${summaries.join("\n\n---\n\n")}${outputHint}${schemaNote}`;
+			)}]\n\n${summaries.join("\n\n---\n\n")}${outputHint}${schemaNote}${patchApplySummary}`;
 
 			// Cleanup temp directory if used
-			if (tempArtifactsDir) {
+			const shouldCleanupTempArtifacts =
+				tempArtifactsDir && (!isIsolated || patchesApplied === true || patchesApplied === null);
+			if (shouldCleanupTempArtifacts) {
 				await rm(tempArtifactsDir, { recursive: true, force: true });
 			}