@oh-my-pi/pi-coding-agent 3.24.0 → 3.30.0

package/src/prompts/task.md

@@ -1,50 +1,14 @@
-You are a worker agent for delegated tasks. You operate in an isolated context window to handle work without polluting the main conversation.
-
-Do what has been asked; nothing more, nothing less. Work autonomously using all available tools.
-
-Your strengths:
-
-- Searching for code, configurations, and patterns across large codebases
-- Analyzing multiple files to understand system architecture
-- Investigating complex questions that require exploring many files
-- Performing multi-step research and implementation tasks
-
-Guidelines:
-
-- Persist until the task is fully resolved end-to-end when feasible.
-- Verify with tools; ask for clarification when required.
-- For file searches: Use grep/glob when you need to search broadly. Use read when you know the specific file path.
-- For analysis: Start broad and narrow down. Use multiple search strategies if the first doesn't yield results.
-- Be thorough: Check multiple locations, consider different naming conventions, look for related files.
-- When spawning subagents with the Task tool, include a short, user-facing `description` for each task (5-8 words) that summarizes the approach.
-- NEVER create files unless absolutely necessary. ALWAYS prefer editing existing files.
-- NEVER proactively create documentation files (\*.md) or README files unless explicitly requested.
-- Any file paths in your response MUST be absolute. Do NOT use relative paths.
-- Include relevant code snippets in your final response.
-
-Output format when finished:
-
-## Completed
-
-What was done.
-
-## Files Changed
-
-- `/absolute/path/to/file.ts` - what changed
-
-## Key Code
-
-Relevant snippets or signatures touched:
-
-```language
-// actual code
-```
-
-## Notes (if any)
-
-Anything the main agent should know.
-
-If handing off to another agent (e.g. reviewer), include:
-
-- Exact file paths changed
-- Key functions/types touched (short list)
+You are a worker agent for delegated tasks in an isolated context. Finish only the assigned work and return the minimum useful result.
+
+Principles:
+
+- Be concise. No filler, repetition, or tool transcripts.
+- If blocked, ask a single focused question; otherwise proceed autonomously.
+- Prefer narrow search (grep/glob) then read only needed ranges.
+- Avoid full-file reads unless necessary.
+- NEVER create files unless absolutely required. Prefer edits to existing files.
+- NEVER create documentation files (\*.md) unless explicitly requested.
+- Any file paths in your response MUST be absolute.
+- When spawning subagents with the Task tool, include a 5-8 word user-facing description.
+- Include the smallest relevant code snippet when discussing code or config.
+- Follow the main agent's instructions.

package/src/prompts/tools/output.md

@@ -21,7 +21,8 @@ Do NOT use when:
   - `"raw"` (default): Full output with ANSI codes preserved
   - `"json"`: Structured object with metadata
   - `"stripped"`: Plain text with ANSI codes removed for parsing
+- `query` (optional): jq-like query for JSON outputs (e.g., `.result.items[0].name`)
 - `offset` (optional): Line number to start reading from (1-indexed)
 - `limit` (optional): Maximum number of lines to read
 
-Use offset/limit for line ranges to reduce context usage on large outputs.
+Use offset/limit for line ranges to reduce context usage on large outputs. Use `query` for JSON outputs (for example, subagent `complete` results).

package/src/prompts/tools/task.md

@@ -16,8 +16,9 @@ The Task tool launches specialized agents (workers) that autonomously handle com
 ## Usage Notes
 
 - Always include a short description of the task in the task parameter
-- **Plan-then-execute**: Put shared constraints in `context`, keep each task focused, specify output format and acceptance criteria
+- **Plan-then-execute**: Put shared constraints in `context`, keep each task focused, specify acceptance criteria; use `output_schema` when you need structured output
 - **Minimize tool chatter**: Avoid repeating large context; use Output tool with output ids for full logs
+- **Structured completion**: If `output_schema` is provided, subagents must call `complete` to finish
 - **Parallelize**: Launch multiple agents concurrently whenever possible
 - **Results are intermediate data**: Agent findings provide context for YOU to perform actual work. Do not treat agent reports as "task complete" signals.
 - **Stateless invocations**: Each agent runs autonomously and returns a single final message. Include all necessary context and specify exactly what information to return.
@@ -30,6 +31,7 @@ The Task tool launches specialized agents (workers) that autonomously handle com
 - `tasks`: Array of `{agent, task, description?, model?}` - tasks to run in parallel (max {{MAX_PARALLEL_TASKS}}, {{MAX_CONCURRENCY}} concurrent)
   - `model`: (optional) Override the agent's default model with fuzzy matching (e.g., "sonnet", "codex", "5.2"). Supports comma-separated fallbacks: "gpt, opus" tries gpt first, then opus. Use "default" for omp's default model
 - `context`: (optional) Shared context string prepended to all task prompts - use this to avoid repeating instructions
+- `output_schema`: (optional) JSON schema for structured subagent output (used by the complete tool)
 
 ## Examples
 

package/src/utils/tools-manager.ts

@@ -11,6 +11,7 @@ interface ToolConfig {
 	repo: string; // GitHub repo (e.g., "sharkdp/fd")
 	binaryName: string; // Name of the binary inside the archive
 	tagPrefix: string; // Prefix for tags (e.g., "v" for v1.0.0, "" for 1.0.0)
+	isDirectBinary?: boolean; // If true, asset is a direct binary (not an archive)
 	getAssetName: (version: string, plat: string, architecture: string) => string | null;
 }
 
@@ -93,6 +94,43 @@ const TOOLS: Record<string, ToolConfig> = {
 			return null;
 		},
 	},
+	"yt-dlp": {
+		name: "yt-dlp",
+		repo: "yt-dlp/yt-dlp",
+		binaryName: "yt-dlp",
+		tagPrefix: "",
+		isDirectBinary: true,
+		getAssetName: (_version, plat, architecture) => {
+			if (plat === "darwin") {
+				return "yt-dlp_macos"; // Universal binary
+			} else if (plat === "linux") {
+				return architecture === "arm64" ? "yt-dlp_linux_aarch64" : "yt-dlp_linux";
+			} else if (plat === "win32") {
+				return architecture === "arm64" ? "yt-dlp_arm64.exe" : "yt-dlp.exe";
+			}
+			return null;
+		},
+	},
+};
+
+// Python packages installed via uv/pip
+interface PythonToolConfig {
+	name: string;
+	package: string; // PyPI package name
+	binaryName: string; // CLI command name after install
+}
+
+const PYTHON_TOOLS: Record<string, PythonToolConfig> = {
+	markitdown: {
+		name: "markitdown",
+		package: "markitdown",
+		binaryName: "markitdown",
+	},
+	html2text: {
+		name: "html2text",
+		package: "html2text",
+		binaryName: "html2text",
+	},
 };
 
 // Check if a command exists in PATH
@@ -100,8 +138,16 @@ function commandExists(cmd: string): string | null {
 	return Bun.which(cmd);
 }
 
+export type ToolName = "fd" | "rg" | "sd" | "sg" | "yt-dlp" | "markitdown" | "html2text";
+
 // Get the path to a tool (system-wide or in our tools dir)
-export function getToolPath(tool: "fd" | "rg" | "sd" | "sg"): string | null {
+export function getToolPath(tool: ToolName): string | null {
+	// Check Python tools first
+	const pythonConfig = PYTHON_TOOLS[tool];
+	if (pythonConfig) {
+		return commandExists(pythonConfig.binaryName);
+	}
+
 	const config = TOOLS[tool];
 	if (!config) return null;
 
@@ -156,7 +202,7 @@ async function downloadFile(url: string, dest: string): Promise<void> {
 }
 
 // Download and install a tool
-async function downloadTool(tool: "fd" | "rg" | "sd" | "sg"): Promise<string> {
+async function downloadTool(tool: ToolName): Promise<string> {
 	const config = TOOLS[tool];
 	if (!config) throw new Error(`Unknown tool: ${tool}`);
 
@@ -176,11 +222,20 @@ async function downloadTool(tool: "fd" | "rg" | "sd" | "sg"): Promise<string> {
 	mkdirSync(TOOLS_DIR, { recursive: true });
 
 	const downloadUrl = `https://github.com/${config.repo}/releases/download/${config.tagPrefix}${version}/${assetName}`;
-	const archivePath = join(TOOLS_DIR, assetName);
 	const binaryExt = plat === "win32" ? ".exe" : "";
 	const binaryPath = join(TOOLS_DIR, config.binaryName + binaryExt);
 
-	// Download
+	// Handle direct binary downloads (no archive extraction needed)
+	if (config.isDirectBinary) {
+		await downloadFile(downloadUrl, binaryPath);
+		if (plat !== "win32") {
+			chmodSync(binaryPath, 0o755);
+		}
+		return binaryPath;
+	}
+
+	// Download archive
+	const archivePath = join(TOOLS_DIR, assetName);
 	await downloadFile(downloadUrl, archivePath);
 
 	// Extract
@@ -231,17 +286,64 @@ async function downloadTool(tool: "fd" | "rg" | "sd" | "sg"): Promise<string> {
 	return binaryPath;
 }
 
+// Install a Python package via uv (preferred) or pip
+function installPythonPackage(pkg: string): boolean {
+	// Try uv first (faster, better isolation)
+	const uv = commandExists("uv");
+	if (uv) {
+		const result = Bun.spawnSync([uv, "tool", "install", pkg], {
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		if (result.exitCode === 0) return true;
+	}
+
+	// Fall back to pip
+	const pip = commandExists("pip3") || commandExists("pip");
+	if (pip) {
+		const result = Bun.spawnSync([pip, "install", "--user", pkg], {
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		return result.exitCode === 0;
+	}
+
+	return false;
+}
+
 // Ensure a tool is available, downloading if necessary
 // Returns the path to the tool, or null if unavailable
-export async function ensureTool(
-	tool: "fd" | "rg" | "sd" | "sg",
-	silent: boolean = false,
-): Promise<string | undefined> {
+export async function ensureTool(tool: ToolName, silent: boolean = false): Promise<string | undefined> {
 	const existingPath = getToolPath(tool);
 	if (existingPath) {
 		return existingPath;
 	}
 
+	// Handle Python tools
+	const pythonConfig = PYTHON_TOOLS[tool];
+	if (pythonConfig) {
+		if (!silent) {
+			console.log(chalk.dim(`${pythonConfig.name} not found. Installing via uv/pip...`));
+		}
+		const success = installPythonPackage(pythonConfig.package);
+		if (success) {
+			// Re-check for the command after installation
+			const path = commandExists(pythonConfig.binaryName);
+			if (path) {
+				if (!silent) {
+					console.log(chalk.dim(`${pythonConfig.name} installed successfully`));
+				}
+				return path;
+			}
+		}
+		if (!silent) {
+			console.log(chalk.yellow(`Failed to install ${pythonConfig.name}`));
+		}
+		return undefined;
+	}
+
 	const config = TOOLS[tool];
 	if (!config) return undefined;