@oh-my-pi/pi-coding-agent 1.337.0

package/src/core/tools/task/discovery.ts

@@ -0,0 +1,208 @@
+/**
+ * Agent discovery from filesystem.
+ *
+ * Discovers agent definitions from:
+ *   - ~/.pi/agent/agents/*.md (user-level, primary)
+ *   - ~/.claude/agents/*.md (user-level, fallback)
+ *   - .pi/agents/*.md (project-level, primary)
+ *   - .claude/agents/*.md (project-level, fallback)
+ *
+ * Agent files use markdown with YAML frontmatter.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { loadBundledAgents } from "./agents.js";
+import type { AgentDefinition, AgentSource } from "./types.js";
+
+/** Result of agent discovery */
+export interface DiscoveryResult {
+	agents: AgentDefinition[];
+	projectAgentsDir: string | null;
+}
+
+/**
+ * Parse YAML frontmatter from markdown content.
+ */
+function parseFrontmatter(content: string): { frontmatter: Record<string, string>; body: string } {
+	const frontmatter: Record<string, string> = {};
+	const normalized = content.replace(/\r\n/g, "\n");
+
+	if (!normalized.startsWith("---")) {
+		return { frontmatter, body: normalized };
+	}
+
+	const endIndex = normalized.indexOf("\n---", 3);
+	if (endIndex === -1) {
+		return { frontmatter, body: normalized };
+	}
+
+	const frontmatterBlock = normalized.slice(4, endIndex);
+	const body = normalized.slice(endIndex + 4).trim();
+
+	for (const line of frontmatterBlock.split("\n")) {
+		const match = line.match(/^([\w-]+):\s*(.*)$/);
+		if (match) {
+			let value = match[2].trim();
+			// Strip quotes
+			if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+				value = value.slice(1, -1);
+			}
+			frontmatter[match[1]] = value;
+		}
+	}
+
+	return { frontmatter, body };
+}
+
+/**
+ * Load agents from a directory.
+ */
+function loadAgentsFromDir(dir: string, source: AgentSource): AgentDefinition[] {
+	const agents: AgentDefinition[] = [];
+
+	if (!fs.existsSync(dir)) {
+		return agents;
+	}
+
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return agents;
+	}
+
+	for (const entry of entries) {
+		if (!entry.name.endsWith(".md")) continue;
+
+		const filePath = path.join(dir, entry.name);
+
+		// Handle both regular files and symlinks
+		try {
+			if (!fs.statSync(filePath).isFile()) continue;
+		} catch {
+			continue;
+		}
+
+		let content: string;
+		try {
+			content = fs.readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+
+		const { frontmatter, body } = parseFrontmatter(content);
+
+		// Require name and description
+		if (!frontmatter.name || !frontmatter.description) {
+			continue;
+		}
+
+		const tools = frontmatter.tools
+			?.split(",")
+			.map((t) => t.trim())
+			.filter(Boolean);
+
+		const recursive =
+			frontmatter.recursive === undefined
+				? undefined
+				: frontmatter.recursive === "true" || frontmatter.recursive === "1";
+
+		agents.push({
+			name: frontmatter.name,
+			description: frontmatter.description,
+			tools: tools && tools.length > 0 ? tools : undefined,
+			model: frontmatter.model,
+			recursive,
+			systemPrompt: body,
+			source,
+			filePath,
+		});
+	}
+
+	return agents;
+}
+
+/**
+ * Check if path is a directory.
+ */
+function isDirectory(p: string): boolean {
+	try {
+		return fs.statSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Find nearest directory by walking up from cwd.
+ */
+function findNearestDir(cwd: string, relPath: string): string | null {
+	let currentDir = cwd;
+	while (true) {
+		const candidate = path.join(currentDir, relPath);
+		if (isDirectory(candidate)) return candidate;
+
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+
+/**
+ * Discover agents from filesystem and merge with bundled agents.
+ *
+ * Precedence (highest wins): project > user > bundled
+ * Within each level: .pi > .claude
+ *
+ * @param cwd - Current working directory for project agent discovery
+ */
+export function discoverAgents(cwd: string): DiscoveryResult {
+	// Primary directories (.pi)
+	const userPiDir = path.join(os.homedir(), ".pi", "agent", "agents");
+	const projectPiDir = findNearestDir(cwd, ".pi/agents");
+
+	// Fallback directories (.claude)
+	const userClaudeDir = path.join(os.homedir(), ".claude", "agents");
+	const projectClaudeDir = findNearestDir(cwd, ".claude/agents");
+
+	const agentMap = new Map<string, AgentDefinition>();
+
+	// 1. Bundled agents (lowest priority)
+	for (const agent of loadBundledAgents()) {
+		agentMap.set(agent.name, agent);
+	}
+
+	// 2. User agents (.claude then .pi - .pi overrides .claude)
+	for (const agent of loadAgentsFromDir(userClaudeDir, "user")) {
+		agentMap.set(agent.name, agent);
+	}
+	for (const agent of loadAgentsFromDir(userPiDir, "user")) {
+		agentMap.set(agent.name, agent);
+	}
+
+	// 3. Project agents (highest priority - .claude then .pi)
+	if (projectClaudeDir) {
+		for (const agent of loadAgentsFromDir(projectClaudeDir, "project")) {
+			agentMap.set(agent.name, agent);
+		}
+	}
+	if (projectPiDir) {
+		for (const agent of loadAgentsFromDir(projectPiDir, "project")) {
+			agentMap.set(agent.name, agent);
+		}
+	}
+
+	return {
+		agents: Array.from(agentMap.values()),
+		projectAgentsDir: projectPiDir,
+	};
+}
+
+/**
+ * Get an agent by name from discovered agents.
+ */
+export function getAgent(agents: AgentDefinition[], name: string): AgentDefinition | undefined {
+	return agents.find((a) => a.name === name);
+}

package/src/core/tools/task/executor.ts

@@ -0,0 +1,367 @@
+/**
+ * Subprocess execution for subagents.
+ *
+ * Spawns `pi` in JSON mode to execute tasks with isolated context.
+ * Parses JSON events for progress tracking.
+ */
+
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { resolveModelPattern } from "./model-resolver.js";
+import {
+	type AgentDefinition,
+	type AgentProgress,
+	MAX_OUTPUT_BYTES,
+	MAX_OUTPUT_LINES,
+	PI_NO_SUBAGENTS_ENV,
+	type SingleResult,
+} from "./types.js";
+
+/** pi command: 'pi.cmd' on Windows, 'pi' elsewhere */
+const PI_CMD = process.platform === "win32" ? "pi.cmd" : "pi";
+
+/** Windows shell option for spawn */
+const PI_SHELL_OPT = process.platform === "win32";
+
+/** Options for subprocess execution */
+export interface ExecutorOptions {
+	cwd: string;
+	agent: AgentDefinition;
+	task: string;
+	index: number;
+	context?: string;
+	modelOverride?: string;
+	signal?: AbortSignal;
+	onProgress?: (progress: AgentProgress) => void;
+	sessionFile?: string | null;
+	persistArtifacts?: boolean;
+	artifactsDir?: string;
+}
+
+/**
+ * Truncate output to byte and line limits.
+ */
+function truncateOutput(output: string): { text: string; truncated: boolean } {
+	let truncated = false;
+	let byteBudget = MAX_OUTPUT_BYTES;
+	let lineBudget = MAX_OUTPUT_LINES;
+
+	let i = 0;
+	let lastNewlineIndex = -1;
+	while (i < output.length && byteBudget > 0) {
+		const ch = output.charCodeAt(i);
+		byteBudget--;
+
+		if (ch === 10 /* \n */) {
+			lineBudget--;
+			lastNewlineIndex = i;
+			if (lineBudget <= 0) {
+				truncated = true;
+				break;
+			}
+		}
+
+		i++;
+	}
+
+	if (i < output.length) {
+		truncated = true;
+	}
+
+	if (truncated && lineBudget <= 0 && lastNewlineIndex >= 0) {
+		output = output.slice(0, lastNewlineIndex);
+	} else {
+		output = output.slice(0, i);
+	}
+
+	return { text: output, truncated };
+}
+
+/**
+ * Extract a short preview from tool args for display.
+ */
+function extractToolArgsPreview(args: Record<string, unknown>): string {
+	// Priority order for preview
+	const previewKeys = ["command", "file_path", "path", "pattern", "query", "url", "task", "prompt"];
+
+	for (const key of previewKeys) {
+		if (args[key] && typeof args[key] === "string") {
+			const value = args[key] as string;
+			return value.length > 60 ? `${value.slice(0, 57)}...` : value;
+		}
+	}
+
+	return "";
+}
+
+/**
+ * Run a single agent as a subprocess.
+ */
+export async function runSubprocess(options: ExecutorOptions): Promise<SingleResult> {
+	const { cwd, agent, task, index, context, modelOverride, signal, onProgress } = options;
+	const startTime = Date.now();
+
+	// Initialize progress
+	const progress: AgentProgress = {
+		index,
+		agent: agent.name,
+		agentSource: agent.source,
+		status: "running",
+		task,
+		recentTools: [],
+		recentOutput: [],
+		toolCount: 0,
+		tokens: 0,
+		durationMs: 0,
+		modelOverride,
+	};
+
+	// Check if already aborted
+	if (signal?.aborted) {
+		return {
+			index,
+			agent: agent.name,
+			agentSource: agent.source,
+			task,
+			exitCode: 1,
+			output: "",
+			stderr: "Aborted before start",
+			truncated: false,
+			durationMs: 0,
+			tokens: 0,
+			modelOverride,
+			error: "Aborted",
+		};
+	}
+
+	// Write system prompt to temp file
+	const tempDir = os.tmpdir();
+	const promptFile = path.join(
+		tempDir,
+		`pi-agent-${agent.name}-${Date.now()}-${Math.random().toString(36).slice(2)}.md`,
+	);
+
+	try {
+		fs.writeFileSync(promptFile, agent.systemPrompt, "utf-8");
+	} catch (err) {
+		return {
+			index,
+			agent: agent.name,
+			agentSource: agent.source,
+			task,
+			exitCode: 1,
+			output: "",
+			stderr: `Failed to write prompt file: ${err}`,
+			truncated: false,
+			durationMs: Date.now() - startTime,
+			tokens: 0,
+			modelOverride,
+			error: `Failed to write prompt file: ${err}`,
+		};
+	}
+
+	// Build full task with context
+	const fullTask = context ? `${context}\n\n${task}` : task;
+
+	// Build args
+	const args: string[] = ["--mode", "json", "--non-interactive"];
+
+	// Add system prompt
+	args.push("--append-system-prompt", promptFile);
+
+	// Add tools if specified
+	if (agent.tools && agent.tools.length > 0) {
+		args.push("--tools", agent.tools.join(","));
+	}
+
+	// Resolve and add model
+	const resolvedModel = resolveModelPattern(modelOverride || agent.model);
+	if (resolvedModel) {
+		args.push("--model", resolvedModel);
+	}
+
+	// Add session options
+	if (options.sessionFile) {
+		args.push("--session", options.sessionFile);
+	} else {
+		args.push("--no-session");
+	}
+
+	// Add task as prompt
+	args.push("--prompt", fullTask);
+
+	// Set up environment
+	const env = { ...process.env };
+	if (!agent.recursive) {
+		env[PI_NO_SUBAGENTS_ENV] = "1";
+	}
+
+	// Spawn subprocess
+	const proc = spawn(PI_CMD, args, {
+		cwd,
+		stdio: ["ignore", "pipe", "pipe"],
+		shell: PI_SHELL_OPT,
+		env,
+	});
+
+	let output = "";
+	let stderr = "";
+	let finalOutput = "";
+	let resolved = false;
+	const jsonlEvents: string[] = [];
+
+	// Handle abort signal
+	const onAbort = () => {
+		if (!resolved) {
+			proc.kill("SIGTERM");
+		}
+	};
+	if (signal) {
+		signal.addEventListener("abort", onAbort, { once: true });
+	}
+
+	// Parse JSON events from stdout
+	const rl = readline.createInterface({ input: proc.stdout! });
+
+	rl.on("line", (line) => {
+		if (resolved) return;
+
+		try {
+			const event = JSON.parse(line);
+			jsonlEvents.push(line);
+			const now = Date.now();
+
+			switch (event.type) {
+				case "tool_execution_start":
+					progress.toolCount++;
+					progress.currentTool = event.toolName;
+					progress.currentToolArgs = extractToolArgsPreview(event.toolArgs || event.args || {});
+					progress.currentToolStartMs = now;
+					break;
+
+				case "tool_execution_end":
+					if (progress.currentTool) {
+						progress.recentTools.unshift({
+							tool: progress.currentTool,
+							args: progress.currentToolArgs || "",
+							endMs: now,
+						});
+						// Keep only last 5
+						if (progress.recentTools.length > 5) {
+							progress.recentTools.pop();
+						}
+					}
+					progress.currentTool = undefined;
+					progress.currentToolArgs = undefined;
+					progress.currentToolStartMs = undefined;
+					break;
+
+				case "message_update":
+				case "message_end": {
+					// Extract text content for recent output (prefer message.content, fallback to event.content)
+					const messageContent = event.message?.content || event.content;
+					if (messageContent && Array.isArray(messageContent)) {
+						for (const block of messageContent) {
+							if (block.type === "text" && block.text) {
+								const lines = block.text.split("\n").filter((l: string) => l.trim());
+								for (const l of lines) {
+									if (!progress.recentOutput.includes(l)) {
+										progress.recentOutput.unshift(l);
+										if (progress.recentOutput.length > 8) {
+											progress.recentOutput.pop();
+										}
+									}
+								}
+								output += block.text;
+							}
+						}
+					}
+					// Extract usage (prefer message.usage, fallback to event.usage)
+					const messageUsage = event.message?.usage || event.usage;
+					if (messageUsage) {
+						progress.tokens = (messageUsage.input_tokens || 0) + (messageUsage.output_tokens || 0);
+					}
+					break;
+				}
+
+				case "agent_end":
+					// Extract final content from messages array
+					if (event.messages && Array.isArray(event.messages)) {
+						for (const msg of event.messages) {
+							if (msg.content && Array.isArray(msg.content)) {
+								for (const block of msg.content) {
+									if (block.type === "text" && block.text) {
+										finalOutput += block.text;
+									}
+								}
+							}
+						}
+					}
+					break;
+			}
+
+			progress.durationMs = now - startTime;
+			onProgress?.(progress);
+		} catch {
+			// Ignore non-JSON lines
+		}
+	});
+
+	// Capture stderr
+	const stderrDecoder = new TextDecoder();
+	proc.stderr?.on("data", (chunk: Buffer) => {
+		stderr += stderrDecoder.decode(chunk, { stream: true });
+	});
+
+	// Wait for process to exit
+	const exitCode = await new Promise<number>((resolve) => {
+		proc.on("close", (code) => {
+			resolved = true;
+			resolve(code ?? 1);
+		});
+		proc.on("error", (err) => {
+			resolved = true;
+			stderr += `\nProcess error: ${err.message}`;
+			resolve(1);
+		});
+	});
+
+	// Cleanup
+	if (signal) {
+		signal.removeEventListener("abort", onAbort);
+	}
+
+	try {
+		fs.unlinkSync(promptFile);
+	} catch {
+		// Ignore cleanup errors
+	}
+
+	// Use final output if available, otherwise accumulated output
+	const rawOutput = finalOutput || output;
+	const { text: truncatedOutput, truncated } = truncateOutput(rawOutput);
+
+	// Update final progress
+	progress.status = exitCode === 0 ? "completed" : "failed";
+	progress.durationMs = Date.now() - startTime;
+	onProgress?.(progress);
+
+	return {
+		index,
+		agent: agent.name,
+		agentSource: agent.source,
+		task,
+		exitCode,
+		output: truncatedOutput,
+		stderr,
+		truncated,
+		durationMs: Date.now() - startTime,
+		tokens: progress.tokens,
+		modelOverride,
+		error: exitCode !== 0 && stderr ? stderr : undefined,
+		jsonlEvents,
+	};
+}