@agnishc/edb-claude-proxy 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## [Unreleased]
+
+### Added
+- Initial release: `claude_proxy` tool with streaming JSON output parsing
+- File context injection via `files[]` parameter
+- Configurable tool access and system prompt
+- Collapsed and expanded TUI rendering with markdown support

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Agnish Chakraborty
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @agnishc/edb-claude-proxy
+
+A Pi CLI extension that registers a `claude_proxy` tool — lets the pi agent delegate tasks to **Claude Code CLI** running in non-interactive (`--print`) mode.
+
+## Use cases
+
+- Code review and security audit
+- Diff analysis and documentation
+- Architectural second opinion
+- Any task where a second model perspective is valuable
+
+## Install
+
+```bash
+pi install npm:@agnishc/edb-claude-proxy
+```
+
+## Requirements
+
+- `claude` CLI on PATH ([Claude Code](https://docs.anthropic.com/claude/docs/claude-code))
+- Set `CLAUDE_PATH` env var to override the binary location
+
+## Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `prompt` | string | The task for Claude — be specific |
+| `systemPrompt` | string? | Expert persona (e.g. "You are a senior security engineer") |
+| `model` | string? | `sonnet` (default), `opus`, `haiku`, or full model name |
+| `allowedTools` | string[]? | Tools Claude may use. Defaults to `["Read"]` |
+| `files` | string[]? | File paths to inject into Claude's context |
+| `cwd` | string? | Working directory for the Claude process |
+
+## TUI
+
+- Collapsed: shows tool calls (read/bash/edit) and a response preview
+- Expanded (`Ctrl+O`): full markdown-rendered response with all tool calls
+
+## License
+
+[MIT](LICENSE) © Agnish Chakraborty

package/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "@agnishc/edb-claude-proxy",
+	"version": "0.1.0",
+	"description": "Pi extension: claude_proxy tool — delegate tasks to Claude Code CLI from within pi",
+	"keywords": ["pi-package", "pi-extension", "edb", "claude"],
+	"type": "module",
+	"license": "MIT",
+	"author": "Agnish Chakraborty",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/agnishcc/pi-extention-monorepo.git",
+		"directory": "packages/edb-claude-proxy"
+	},
+	"homepage": "https://github.com/agnishcc/pi-extention-monorepo/tree/main/packages/edb-claude-proxy#readme",
+	"bugs": { "url": "https://github.com/agnishcc/pi-extention-monorepo/issues" },
+	"publishConfig": { "access": "public" },
+	"scripts": { "test": "vitest run" },
+	"files": ["src", "README.md", "LICENSE", "CHANGELOG.md"],
+	"pi": {
+		"extensions": ["./src/index.ts"]
+	},
+	"peerDependencies": {
+		"@mariozechner/pi-coding-agent": "*",
+		"@mariozechner/pi-tui": "*",
+		"typebox": "*"
+	}
+}

package/src/cli.ts

@@ -0,0 +1,55 @@
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+// ── CLI discovery ──────────────────────────────────────────────────────────────
+
+/** Locate the claude CLI. Checks CLAUDE_PATH env, PATH, then common install dirs. */
+export function findClaudeCli(): string {
+	if (process.env.CLAUDE_PATH) {
+		try {
+			fs.accessSync(process.env.CLAUDE_PATH, fs.constants.X_OK);
+			return process.env.CLAUDE_PATH;
+		} catch {
+			/* fall through */
+		}
+	}
+
+	try {
+		const resolved = execSync("which claude", {
+			encoding: "utf-8",
+			stdio: ["ignore", "pipe", "ignore"],
+		}).trim();
+		if (resolved) return resolved;
+	} catch {
+		/* fall through */
+	}
+
+	for (const c of [
+		path.join(os.homedir(), ".local/bin/claude"),
+		"/usr/local/bin/claude",
+		"/opt/homebrew/bin/claude",
+	]) {
+		try {
+			fs.accessSync(c, fs.constants.X_OK);
+			return c;
+		} catch {
+			/* continue */
+		}
+	}
+
+	return "claude"; // final fallback — let the OS resolve it
+}
+
+// ── File context ───────────────────────────────────────────────────────────────
+
+/** Read a file, returning an XML-wrapped content block for Claude's context. */
+export async function readFileForContext(absPath: string): Promise<string> {
+	try {
+		const content = await fs.promises.readFile(absPath, "utf-8");
+		return `<file path="${absPath}">\n${content}\n</file>`;
+	} catch (err) {
+		return `<file path="${absPath}" error="${(err as Error).message}" />`;
+	}
+}

package/src/execute.ts

@@ -0,0 +1,182 @@
+import { spawn } from "node:child_process";
+import * as path from "node:path";
+import { readFileForContext } from "./cli";
+import type { ClaudeProxyDetails, ToolCallRecord } from "./types";
+
+// ── Execute ────────────────────────────────────────────────────────────────────
+
+export async function execute(
+	claudePath: string,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: ((update: { content: Array<{ type: "text"; text: string }>; details?: any }) => void) | undefined,
+	ctx: any,
+): Promise<{ content: Array<{ type: string; text: string }>; details: ClaudeProxyDetails; isError: boolean }> {
+	const workDir = params.cwd ?? ctx.cwd;
+
+	// ----- 1. Build context from requested files -----
+	let fullPrompt = params.prompt;
+	const filesInjected: string[] = [];
+
+	if (params.files && params.files.length > 0) {
+		const parts: string[] = [];
+		for (const filePath of params.files) {
+			const absPath = path.isAbsolute(filePath) ? filePath : path.join(workDir, filePath);
+			filesInjected.push(absPath);
+			parts.push(await readFileForContext(absPath));
+		}
+		fullPrompt = `${parts.join("\n")}\n\n${fullPrompt}`;
+	}
+
+	// ----- 2. Build CLI arguments -----
+	const args: string[] = [
+		"--print",
+		"--output-format",
+		"stream-json",
+		"--verbose",
+		"--include-partial-messages",
+		"--input-format",
+		"text",
+		"--dangerously-skip-permissions",
+		"--no-session-persistence",
+	];
+
+	if (params.model) args.push("--model", params.model);
+	if (params.systemPrompt) args.push("--system-prompt", params.systemPrompt);
+
+	const tools = params.allowedTools ?? ["Read"];
+	if (tools.length === 0) {
+		args.push("--tools", "");
+	} else {
+		args.push("--allowed-tools", ...tools);
+	}
+
+	// ----- 3. Spawn Claude -----
+	const details: ClaudeProxyDetails = {
+		streaming: true,
+		toolCalls: [],
+		prompt: params.prompt,
+		filesInjected: filesInjected.length > 0 ? filesInjected : undefined,
+	};
+
+	const pendingToolCalls = new Map<string, ToolCallRecord>();
+	let finalText = "";
+	let latestPartialText = "";
+	let spawnError = "";
+
+	const emitUpdate = () => {
+		onUpdate?.({
+			content: [{ type: "text" as const, text: latestPartialText || "(waiting for Claude…)" }],
+			details: { ...details },
+		});
+	};
+
+	const exitCode = await new Promise<number>((resolve) => {
+		const proc = spawn(claudePath, args, {
+			cwd: workDir,
+			shell: false,
+			stdio: ["pipe", "pipe", "pipe"],
+			env: { ...process.env },
+		});
+
+		proc.stdin.write(fullPrompt, "utf-8");
+		proc.stdin.end();
+
+		let buffer = "";
+
+		const processLine = (line: string) => {
+			if (!line.trim()) return;
+			let event: Record<string, unknown>;
+			try {
+				event = JSON.parse(line) as Record<string, unknown>;
+			} catch {
+				return;
+			}
+
+			switch (event.type) {
+				case "system": {
+					if ((event as any).session_id) details.sessionId = (event as any).session_id as string;
+					break;
+				}
+				case "assistant": {
+					const msg = (event as any).message as any;
+					if (!msg?.content) break;
+					for (const block of msg.content as any[]) {
+						if (block.type === "text") {
+							latestPartialText = block.text as string;
+							emitUpdate();
+						} else if (block.type === "tool_use") {
+							const record: ToolCallRecord = { id: block.id, name: block.name, input: block.input ?? {} };
+							pendingToolCalls.set(record.id, record);
+							details.toolCalls = [...details.toolCalls, record];
+							emitUpdate();
+						}
+					}
+					if (msg.model && !details.model) details.model = msg.model as string;
+					break;
+				}
+				case "tool_result": {
+					const id = (event as any).tool_use_id as string;
+					const record = pendingToolCalls.get(id);
+					if (record) {
+						const raw = (event as any).content;
+						record.result = typeof raw === "string" ? raw : JSON.stringify(raw);
+						record.isError = Boolean((event as any).is_error);
+						details.toolCalls = details.toolCalls.map((t) => (t.id === id ? { ...record } : t));
+						emitUpdate();
+					}
+					break;
+				}
+				case "result": {
+					finalText = ((event as any).result as string) ?? latestPartialText;
+					details.costUsd = (event as any).total_cost_usd as number;
+					details.streaming = false;
+					if ((event as any).subtype !== "success" || (event as any).is_error) {
+						spawnError = ((event as any).error as string) || finalText || "Claude reported an error";
+					}
+					break;
+				}
+			}
+		};
+
+		proc.stdout.on("data", (chunk) => {
+			buffer += chunk.toString("utf-8");
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) processLine(line);
+		});
+
+		proc.stderr.on("data", (chunk) => {
+			spawnError += chunk.toString("utf-8");
+		});
+
+		proc.on("close", (code) => {
+			if (buffer.trim()) processLine(buffer);
+			details.exitCode = code ?? 0;
+			resolve(code ?? 0);
+		});
+
+		proc.on("error", (err) => {
+			spawnError = `Failed to spawn claude CLI: ${err.message}\n\nMake sure 'claude' is on your PATH or set the CLAUDE_PATH environment variable.`;
+			details.exitCode = 1;
+			resolve(1);
+		});
+
+		if (signal) {
+			const kill = () => {
+				proc.kill("SIGTERM");
+				setTimeout(() => {
+					if (!proc.killed) proc.kill("SIGKILL");
+				}, 5000);
+			};
+			if (signal.aborted) kill();
+			else signal.addEventListener("abort", kill, { once: true });
+		}
+	});
+
+	// ----- 4. Return result -----
+	const isError = exitCode !== 0 || Boolean(spawnError && !finalText);
+	const responseText = isError ? spawnError || "(claude exited with no output)" : finalText || "(no output)";
+
+	return { content: [{ type: "text" as const, text: responseText }], details, isError };
+}

package/src/format.ts

@@ -0,0 +1,30 @@
+import * as os from "node:os";
+
+// ── Format helpers ─────────────────────────────────────────────────────────────
+
+/** Format a tool call for single-line display in the TUI. */
+export function formatToolCall(name: string, input: Record<string, unknown>): string {
+	const shortenPath = (p: string) => {
+		const home = os.homedir();
+		return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+	};
+	switch (name) {
+		case "Read": {
+			const p = shortenPath(String(input.file_path ?? input.path ?? "..."));
+			return `read ${p}`;
+		}
+		case "Bash": {
+			const cmd = String(input.command ?? "...");
+			return `$ ${cmd.length > 60 ? `${cmd.slice(0, 60)}…` : cmd}`;
+		}
+		case "Edit":
+		case "Write": {
+			const p = shortenPath(String(input.file_path ?? input.path ?? "..."));
+			return `${name.toLowerCase()} ${p}`;
+		}
+		default: {
+			const s = JSON.stringify(input);
+			return `${name} ${s.length > 50 ? `${s.slice(0, 50)}…` : s}`;
+		}
+	}
+}

package/src/index.ts

@@ -0,0 +1,86 @@
+/**
+ * pi-claude-proxy
+ *
+ * Registers a `claude_proxy` tool that lets the pi agent delegate tasks
+ * to Claude Code CLI running in non-interactive (--print) mode.
+ *
+ * Typical uses: code review, security audit, diff analysis, documentation,
+ * second-opinion reasoning.
+ *
+ * Requires: `claude` CLI on PATH (Claude Code ≥ 2.x)
+ * Optional: set CLAUDE_PATH env var to point to a specific claude binary.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
+import { findClaudeCli } from "./cli";
+import { execute } from "./execute";
+import { renderCall, renderResult } from "./render";
+
+// ── Extension ──────────────────────────────────────────────────────────────────
+
+export default function claudeProxyExtension(pi: ExtensionAPI): void {
+	const claudePath = findClaudeCli();
+
+	pi.registerTool({
+		name: "claude_proxy",
+		label: "Claude Proxy",
+		description: [
+			"Delegate a task to Claude Code CLI running in non-interactive mode.",
+			"Best for: code review, security audit, diff analysis, documentation, architectural second opinion.",
+			"Claude can explore the codebase autonomously via its Read tool (default).",
+			"Supply files[] to inject specific files directly into context.",
+		].join(" "),
+		promptSnippet:
+			"Delegate a task to Claude Code — triggers on 'ask claude', 'check with claude', 'have claude look at', 'get claude to', or requests for code review, security audit, second opinion",
+		promptGuidelines: [
+			"Use claude_proxy when the user says 'ask claude', 'check with claude', 'have claude look at this', 'get claude to', 'claude should', or any similar phrase that directs a task explicitly to Claude.",
+			"Use claude_proxy when the user asks for a code review, security review, architectural review, or wants a Claude second-opinion on a piece of code.",
+			"Use claude_proxy with a tailored systemPrompt to give Claude a specific expert persona (e.g. 'You are a senior security engineer').",
+			"Pass relevant file paths in the files[] parameter so Claude has precise context without needing to hunt for them.",
+		],
+
+		parameters: Type.Object({
+			prompt: Type.String({
+				description:
+					"The task or question for Claude. Be specific: include file names, what to look for, expected output format.",
+			}),
+			systemPrompt: Type.Optional(
+				Type.String({
+					description:
+						"Expert persona / role for Claude. E.g. 'You are a senior security engineer specialising in Node.js. Identify vulnerabilities and rate their severity.'",
+				}),
+			),
+			model: Type.Optional(
+				Type.String({
+					description:
+						"Claude model alias: 'sonnet' (default), 'opus' (best reasoning), 'haiku' (fast/cheap). Or a full model name.",
+				}),
+			),
+			allowedTools: Type.Optional(
+				Type.Array(Type.String(), {
+					description:
+						'Tools Claude may use during its response. Defaults to ["Read"] for safe read-only exploration. Pass [] to disable all tools.',
+				}),
+			),
+			files: Type.Optional(
+				Type.Array(Type.String(), {
+					description:
+						"File paths (relative to cwd) whose full contents are injected into Claude's context before the prompt.",
+				}),
+			),
+			cwd: Type.Optional(
+				Type.String({
+					description: "Working directory for the Claude process. Defaults to pi's current working directory.",
+				}),
+			),
+		}),
+
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			return execute(claudePath, params, signal, onUpdate as any, ctx) as any;
+		},
+
+		renderCall,
+		renderResult,
+	});
+}

package/src/render.ts

@@ -0,0 +1,96 @@
+import { getMarkdownTheme } from "@mariozechner/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
+import { formatToolCall } from "./format";
+import type { ClaudeProxyDetails } from "./types";
+
+// ── TUI rendering ──────────────────────────────────────────────────────────────
+
+export function renderCall(args: any, theme: any): any {
+	const prompt = args.prompt ?? "";
+	const preview = prompt.length > 80 ? `${prompt.slice(0, 80)}…` : prompt;
+	const model = args.model ?? "sonnet";
+	const toolsLabel = args.allowedTools
+		? (args.allowedTools as string[]).length === 0
+			? "no tools"
+			: (args.allowedTools as string[]).join(", ")
+		: "Read";
+
+	let text =
+		theme.fg("toolTitle", theme.bold("claude_proxy ")) +
+		theme.fg("accent", `[${model}]`) +
+		theme.fg("muted", ` tools: ${toolsLabel}`);
+
+	if (args.systemPrompt) {
+		const rolePreview = (args.systemPrompt as string).slice(0, 50);
+		text += `\n  ${theme.fg("muted", "role: ")}${theme.fg("dim", rolePreview)}`;
+	}
+
+	text += `\n  ${theme.fg("dim", preview)}`;
+
+	if (args.files && (args.files as string[]).length > 0) {
+		text += `\n  ${theme.fg("muted", "files: ")}${theme.fg("dim", (args.files as string[]).join(", "))}`;
+	}
+
+	return new Text(text, 0, 0);
+}
+
+export function renderResult(result: any, { expanded }: any, theme: any): any {
+	const details = result.details as ClaudeProxyDetails | undefined;
+	const text = result.content[0]?.type === "text" ? result.content[0].text : "(no output)";
+
+	const metaParts: string[] = [];
+	if (details?.model) metaParts.push(details.model);
+	if (details?.costUsd) metaParts.push(`$${details.costUsd.toFixed(4)}`);
+	const meta = metaParts.map((p) => theme.fg("dim", p)).join("  ");
+
+	if (result.isError) {
+		const errText = details?.streaming ? "(aborted)" : text;
+		return new Text(
+			theme.fg("error", "✗ ") +
+				theme.fg("toolTitle", theme.bold("Claude")) +
+				(meta ? `  ${meta}` : "") +
+				`\n${theme.fg("error", errText)}`,
+			0,
+			0,
+		);
+	}
+
+	const icon = details?.streaming ? theme.fg("warning", "⏳") : theme.fg("success", "✓");
+	const headerLine = `${icon} ${theme.fg("toolTitle", theme.bold("Claude"))}${meta ? `  ${meta}` : ""}`;
+
+	const toolCallLines = (details?.toolCalls ?? []).map(
+		(tc) =>
+			`  ${theme.fg("muted", "→ ")}${theme.fg("accent", tc.name)}${theme.fg("dim", ` ${formatToolCall(tc.name, tc.input)}`)}${tc.isError ? ` ${theme.fg("error", "[error]")}` : ""}`,
+	);
+
+	if (expanded) {
+		const mdTheme = getMarkdownTheme();
+		const container = new Container();
+		container.addChild(new Text(headerLine, 0, 0));
+		if (toolCallLines.length > 0) {
+			container.addChild(new Spacer(1));
+			container.addChild(new Text(theme.fg("muted", "─── Tool calls ───"), 0, 0));
+			for (const tl of toolCallLines) container.addChild(new Text(tl, 0, 0));
+		}
+		if (text) {
+			container.addChild(new Spacer(1));
+			container.addChild(new Text(theme.fg("muted", "─── Response ───"), 0, 0));
+			container.addChild(new Markdown(text.trim(), 0, 0, mdTheme));
+		}
+		return container;
+	}
+
+	// Collapsed view
+	const previewLines = text.split("\n").slice(0, 6);
+	const previewText = previewLines.join("\n") + (text.split("\n").length > 6 ? "\n…" : "");
+
+	let out = headerLine;
+	if (toolCallLines.length > 0) {
+		out += `\n${toolCallLines.slice(0, 3).join("\n")}`;
+		if (toolCallLines.length > 3) out += `\n  ${theme.fg("muted", `… +${toolCallLines.length - 3} more`)}`;
+	}
+	if (text) out += `\n${theme.fg("toolOutput", previewText)}`;
+	out += `\n${theme.fg("muted", "(Ctrl+O to expand)")}`;
+
+	return new Text(out, 0, 0);
+}

package/src/types.ts

@@ -0,0 +1,20 @@
+// ── Types ──────────────────────────────────────────────────────────────────────
+
+export interface ToolCallRecord {
+	id: string;
+	name: string;
+	input: Record<string, unknown>;
+	result?: string;
+	isError?: boolean;
+}
+
+export interface ClaudeProxyDetails {
+	sessionId?: string;
+	model?: string;
+	costUsd?: number;
+	streaming: boolean;
+	toolCalls: ToolCallRecord[];
+	exitCode?: number;
+	prompt?: string;
+	filesInjected?: string[];
+}