pi-mono-all 1.0.0

package/node_modules/pi-mono-team-mode/runtime/pi-stream-parser.ts

@@ -0,0 +1,194 @@
+// Pi Team-Mode — Parse pi JSON stdout into typed progress events
+
+const MAX_PREVIEW_CHARS = 200;
+
+export type PiUsage = {
+	inputTokens?: number;
+	outputTokens?: number;
+	totalTokens?: number;
+	cacheReadTokens?: number;
+	cacheWriteTokens?: number;
+};
+
+export type PiStreamEvent =
+	| { type: "assistant_message"; text: string; usage?: PiUsage; stopReason?: string }
+	| { type: "assistant_delta"; text: string }
+	| { type: "tool_start"; toolName: string; argsPreview?: string }
+	| { type: "tool_end"; toolName?: string; isError?: boolean; resultPreview?: string }
+	| { type: "turn_end" };
+
+export class PiStreamParser {
+	private buffer = "";
+
+	push(chunk: string): PiStreamEvent[] {
+		this.buffer += chunk;
+		const lines = this.buffer.split("\n");
+		this.buffer = lines.pop() ?? "";
+		return this.parseLines(lines);
+	}
+
+	flush(): PiStreamEvent[] {
+		const tail = this.buffer.trim();
+		this.buffer = "";
+		if (!tail) return [];
+		return this.parseLines([tail]);
+	}
+
+	private parseLines(lines: string[]): PiStreamEvent[] {
+		const out: PiStreamEvent[] = [];
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			let event: Record<string, unknown>;
+			try {
+				event = JSON.parse(trimmed) as Record<string, unknown>;
+			} catch {
+				continue;
+			}
+			const mapped = mapEvent(event);
+			if (mapped) out.push(mapped);
+		}
+		return out;
+	}
+}
+
+function mapEvent(event: Record<string, unknown>): PiStreamEvent | undefined {
+	const eventType = str(event.type);
+	if (!eventType) return undefined;
+
+	if (eventType === "message_update") {
+		const delta = textDelta(event);
+		if (delta) return { type: "assistant_delta", text: delta };
+		return undefined;
+	}
+
+	if (eventType === "message_end") {
+		const assistant = assistantMessage(event);
+		if (!assistant) return undefined;
+		return {
+			type: "assistant_message",
+			text: assistant.text,
+			usage: assistant.usage,
+			stopReason: str(event.stopReason),
+		};
+	}
+
+	if (eventType === "tool_execution_start") {
+		const toolName = str(event.toolName);
+		if (!toolName) return undefined;
+		return {
+			type: "tool_start",
+			toolName,
+			argsPreview: preview(event.args),
+		};
+	}
+
+	if (eventType === "tool_execution_end") {
+		return {
+			type: "tool_end",
+			toolName: str(event.toolName),
+			isError: bool(event.isError),
+			resultPreview: preview(event.result),
+		};
+	}
+
+	if (eventType === "turn_end") return { type: "turn_end" };
+	return undefined;
+}
+
+function assistantMessage(event: Record<string, unknown>): { text: string; usage?: PiUsage } | undefined {
+	const message = obj(event.message);
+	if (!message) return undefined;
+	if (str(message.role) !== "assistant") return undefined;
+	const text = extractText(message);
+	return { text, usage: parseUsage(message.usage) };
+}
+
+function textDelta(event: Record<string, unknown>): string | undefined {
+	const message = obj(event.message);
+	if (message && str(message.role) && str(message.role) !== "assistant") return undefined;
+	const assistantEvent = obj(event.assistantMessageEvent);
+	if (!assistantEvent) return undefined;
+	if (str(assistantEvent.type) !== "text_delta") return undefined;
+	return str(assistantEvent.text) ?? str(assistantEvent.delta) ?? undefined;
+}
+
+function extractText(message: Record<string, unknown>): string {
+	const content = message.content;
+	if (!Array.isArray(content)) return "";
+	const parts: string[] = [];
+	for (const block of content) {
+		const rec = obj(block);
+		if (!rec) continue;
+		const text = str(rec.text);
+		if (text) parts.push(text);
+	}
+	return parts.join("\n").trim();
+}
+
+function parseUsage(value: unknown): PiUsage | undefined {
+	const usage = obj(value);
+	if (!usage) return undefined;
+	const mapped: PiUsage = {
+		inputTokens: num(usage.inputTokens) ?? num(usage.input_tokens) ?? num(usage.input),
+		outputTokens: num(usage.outputTokens) ?? num(usage.output_tokens) ?? num(usage.output),
+		totalTokens: num(usage.totalTokens) ?? num(usage.total_tokens),
+		cacheReadTokens: num(usage.cacheReadTokens) ?? num(usage.cache_read_tokens) ?? num(usage.cacheRead),
+		cacheWriteTokens: num(usage.cacheWriteTokens) ?? num(usage.cache_write_tokens) ?? num(usage.cacheWrite),
+	};
+	if (
+		mapped.totalTokens === undefined &&
+		(mapped.inputTokens !== undefined ||
+			mapped.outputTokens !== undefined ||
+			mapped.cacheReadTokens !== undefined ||
+			mapped.cacheWriteTokens !== undefined)
+	) {
+		mapped.totalTokens =
+			(mapped.inputTokens ?? 0) +
+			(mapped.outputTokens ?? 0) +
+			(mapped.cacheReadTokens ?? 0) +
+			(mapped.cacheWriteTokens ?? 0);
+	}
+	if (
+		mapped.inputTokens === undefined &&
+		mapped.outputTokens === undefined &&
+		mapped.totalTokens === undefined &&
+		mapped.cacheReadTokens === undefined &&
+		mapped.cacheWriteTokens === undefined
+	) {
+		return undefined;
+	}
+	return mapped;
+}
+
+function preview(value: unknown): string | undefined {
+	if (value === undefined) return undefined;
+	const raw =
+		typeof value === "string"
+			? value
+			: (() => {
+				try {
+					return JSON.stringify(value);
+				} catch {
+					return String(value);
+				}
+			})();
+	if (!raw) return undefined;
+	return raw.length <= MAX_PREVIEW_CHARS ? raw : `${raw.slice(0, MAX_PREVIEW_CHARS)}…`;
+}
+
+function obj(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : undefined;
+}
+
+function str(value: unknown): string | undefined {
+	return typeof value === "string" ? value : undefined;
+}
+
+function num(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function bool(value: unknown): boolean | undefined {
+	return typeof value === "boolean" ? value : undefined;
+}

package/node_modules/pi-mono-team-mode/runtime/subprocess.ts

@@ -0,0 +1,183 @@
+// Pi Team-Mode — Pi Subprocess Runner
+
+import { spawn, type ChildProcess } from "node:child_process";
+import { createHash } from "node:crypto";
+import { writeFile, mkdir } from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { PiStreamParser, type PiStreamEvent } from "./pi-stream-parser.js";
+import type { ThinkingLevel } from "../core/types.js";
+
+const STDERR_BUDGET = 8 * 1024;
+const KILL_GRACE_MS = 3_000;
+
+export type PiRunOptions = {
+	message: string;
+	cwd: string;
+	/** Absolute path to the pi session file. Pi creates it if missing, resumes if present. */
+	sessionPath: string;
+	/** Provider — maps to `--provider`. */
+	provider?: string;
+	/** Bare model id — maps to `--model`. */
+	model?: string;
+	/** Thinking level — maps to `--thinking`. */
+	thinkingLevel?: ThinkingLevel;
+	tools?: string[];
+	/** Raw markdown to append to the system prompt. Written to a content-hashed temp file. */
+	systemPromptBody?: string;
+	/** Propagated to the subprocess so it can scope its task board to this session. */
+	parentSessionId?: string;
+	/** Propagated to the subprocess as its task-owner identity. */
+	teammateName?: string;
+	onEvent?: (event: PiStreamEvent) => void;
+	signal?: AbortSignal;
+};
+
+export type PiRunResult = {
+	finalMessage: string;
+	exitCode: number | null;
+	exitSignal: NodeJS.Signals | null;
+	stderr: string;
+};
+
+export type PiRun = {
+	pid?: number;
+	promise: Promise<PiRunResult>;
+	abort: () => void;
+};
+
+export function runPi(opts: PiRunOptions): PiRun {
+	const controller = new AbortController();
+	if (opts.signal) {
+		if (opts.signal.aborted) controller.abort();
+		else opts.signal.addEventListener("abort", () => controller.abort(), { once: true });
+	}
+
+	const run: PiRun = {
+		promise: Promise.resolve({
+			finalMessage: "",
+			exitCode: null,
+			exitSignal: null,
+			stderr: "",
+		}),
+		abort: () => controller.abort(),
+	};
+
+	run.promise = (async (): Promise<PiRunResult> => {
+		const args = await buildArgs(opts);
+		const env: NodeJS.ProcessEnv = {
+			...process.env,
+			PI_TEAM_MATE_SUBPROCESS: "1",
+		};
+		if (opts.parentSessionId) env.PI_TEAM_MATE_PARENT_SESSION_ID = opts.parentSessionId;
+		if (opts.teammateName) env.PI_TEAM_MATE_TEAMMATE_NAME = opts.teammateName;
+
+		const proc = spawn("pi", args, {
+			cwd: opts.cwd,
+			shell: false,
+			stdio: ["ignore", "pipe", "pipe"],
+			env,
+		});
+		run.pid = proc.pid;
+
+		const onAbort = () => terminate(proc);
+		controller.signal.addEventListener("abort", onAbort, { once: true });
+
+		try {
+			return await collect(proc, opts.onEvent);
+		} finally {
+			controller.signal.removeEventListener("abort", onAbort);
+		}
+	})();
+
+	return run;
+}
+
+// Separate `--provider` + `--model` flags avoid pi's `--model provider/id`
+// resolver silently routing hyphenated provider names through amazon-bedrock.
+async function buildArgs(opts: PiRunOptions): Promise<string[]> {
+	const args = ["--mode", "json", "-p", "--session", opts.sessionPath];
+	if (opts.provider) args.push("--provider", opts.provider);
+	if (opts.model) args.push("--model", opts.model);
+	if (opts.thinkingLevel) args.push("--thinking", opts.thinkingLevel);
+	if (opts.tools && opts.tools.length > 0) args.push("--tools", opts.tools.join(","));
+
+	if (opts.systemPromptBody && opts.systemPromptBody.trim().length > 0) {
+		const promptPath = await writeSystemPrompt(opts.systemPromptBody);
+		args.push("--append-system-prompt", promptPath);
+	}
+
+	args.push(opts.message);
+	return args;
+}
+
+// Content-hashed filename so identical specs reuse the same file and stale
+// entries are bounded by distinct spec content rather than call count.
+async function writeSystemPrompt(body: string): Promise<string> {
+	const dir = path.join(os.tmpdir(), "pi-team-mode");
+	await mkdir(dir, { recursive: true });
+	const hash = createHash("sha1").update(body).digest("hex").slice(0, 16);
+	const file = path.join(dir, `prompt-${hash}.md`);
+	await writeFile(file, body, "utf8");
+	return file;
+}
+
+function collect(proc: ChildProcess, onEvent?: (event: PiStreamEvent) => void): Promise<PiRunResult> {
+	const parser = new PiStreamParser();
+	let stderr = "";
+	let finalMessage = "";
+	const deltaBuffer: string[] = [];
+
+	const emit = (events: PiStreamEvent[]) => {
+		for (const event of events) {
+			onEvent?.(event);
+			if (event.type === "assistant_delta") {
+				deltaBuffer.push(event.text);
+			}
+			if (event.type === "assistant_message" && event.text) {
+				finalMessage = event.text;
+			}
+		}
+	};
+
+	proc.stdout?.on("data", (chunk: Buffer) => {
+		emit(parser.push(chunk.toString("utf8")));
+	});
+
+	proc.stderr?.on("data", (chunk: Buffer) => {
+		if (stderr.length >= STDERR_BUDGET) return;
+		stderr += chunk.toString("utf8").slice(0, STDERR_BUDGET - stderr.length);
+	});
+
+	return new Promise((resolve) => {
+		proc.on("close", (code, signal) => {
+			emit(parser.flush());
+			if (!finalMessage && deltaBuffer.length > 0) {
+				finalMessage = deltaBuffer.join("");
+			}
+			resolve({ finalMessage, exitCode: code, exitSignal: signal, stderr });
+		});
+		proc.on("error", (err) => {
+			stderr += `\n[spawn error] ${err.message}`;
+			resolve({ finalMessage, exitCode: null, exitSignal: null, stderr });
+		});
+	});
+}
+
+function terminate(proc: ChildProcess): void {
+	if (proc.exitCode !== null || proc.signalCode !== null) return;
+	try {
+		proc.kill("SIGTERM");
+	} catch {
+		/* ignore */
+	}
+	setTimeout(() => {
+		if (proc.exitCode === null && proc.signalCode === null) {
+			try {
+				proc.kill("SIGKILL");
+			} catch {
+				/* ignore */
+			}
+		}
+	}, KILL_GRACE_MS).unref();
+}

package/node_modules/pi-mono-team-mode/runtime/transient-session.ts

@@ -0,0 +1,196 @@
+// Pi Team-Mode — In-process transient AgentSession runner
+
+import {
+	AuthStorage,
+	createAgentSession,
+	createBashTool,
+	createEditTool,
+	createFindTool,
+	createGrepTool,
+	createLsTool,
+	createReadTool,
+	createWriteTool,
+	DefaultResourceLoader,
+	getAgentDir,
+	ModelRegistry,
+	SessionManager,
+	type AgentSessionEvent,
+} from "@mariozechner/pi-coding-agent";
+
+import type {
+	LiveTeammateMetrics,
+	TeammateRunResult,
+	TeammateSpec,
+	ThinkingLevel,
+} from "../core/types.js";
+
+export type TransientSessionOpts = {
+	id: string;
+	name: string;
+	description: string;
+	message: string;
+	cwd: string;
+	provider?: string;
+	model?: string;
+	thinkingLevel?: ThinkingLevel;
+	modelRationale?: string;
+	spec?: TeammateSpec;
+};
+
+export async function runTransientSession(opts: TransientSessionOpts): Promise<TeammateRunResult> {
+	const startedAt = Date.now();
+	const metrics: LiveTeammateMetrics = {
+		turns: 0,
+		toolUses: 0,
+		tokens: 0,
+		startedAt,
+	};
+	let finalMessage = "";
+	const deltaBuffer: string[] = [];
+
+	try {
+		const agentDir = getAgentDir();
+		const authStorage = AuthStorage.create();
+		const modelRegistry = ModelRegistry.create(authStorage);
+		const selectedModel = opts.provider && opts.model
+			? modelRegistry.find(opts.provider, opts.model)
+			: undefined;
+		if (opts.provider && opts.model && !selectedModel) {
+			throw new Error(`model not found in registry: ${opts.provider}/${opts.model}`);
+		}
+
+		const loader = new DefaultResourceLoader({
+			cwd: opts.cwd,
+			agentDir,
+			noContextFiles: true,
+			appendSystemPromptOverride: (base: string[]) => {
+				const specBody = opts.spec?.systemPrompt?.trim();
+				return specBody ? [...base, specBody] : base;
+			},
+		} as ConstructorParameters<typeof DefaultResourceLoader>[0] & { noContextFiles?: boolean });
+		await loader.reload();
+
+		const { session } = await createAgentSession({
+			cwd: opts.cwd,
+			authStorage,
+			modelRegistry,
+			model: selectedModel,
+			thinkingLevel: opts.thinkingLevel,
+			resourceLoader: loader,
+			sessionManager: SessionManager.inMemory(opts.cwd),
+			tools: opts.spec?.tools ? createAllowedTools(opts.cwd, opts.spec.tools) : undefined,
+			sessionStartEvent: { type: "session_start", reason: "startup" },
+		});
+
+		const unsubscribe = session.subscribe((event) => {
+			applySessionEvent(metrics, event);
+			if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+				deltaBuffer.push(event.assistantMessageEvent.delta);
+			}
+			if (event.type === "message_end" && event.message.role === "assistant") {
+				finalMessage = extractText(event.message.content);
+			}
+		});
+
+		try {
+			await session.prompt(opts.message);
+		} finally {
+			unsubscribe();
+			session.dispose();
+		}
+
+		if (!finalMessage && deltaBuffer.length > 0) finalMessage = deltaBuffer.join("");
+		metrics.finishedAt = Date.now();
+		metrics.exitReason = "completed";
+		return {
+			teammateId: opts.id,
+			name: opts.name,
+			description: opts.description,
+			status: "completed",
+			result: finalMessage,
+			exitCode: 0,
+			metrics,
+			provider: opts.provider,
+			model: opts.model,
+			thinkingLevel: opts.thinkingLevel,
+			modelRationale: opts.modelRationale,
+			durationMs: Date.now() - startedAt,
+			runtime: "transient",
+		};
+	} catch (err) {
+		metrics.finishedAt = Date.now();
+		metrics.exitReason = "failed";
+		return {
+			teammateId: opts.id,
+			name: opts.name,
+			description: opts.description,
+			status: "failed",
+			result: `[transient error] ${err instanceof Error ? err.message : String(err)}`,
+			exitCode: null,
+			metrics,
+			provider: opts.provider,
+			model: opts.model,
+			thinkingLevel: opts.thinkingLevel,
+			modelRationale: opts.modelRationale,
+			durationMs: Date.now() - startedAt,
+			runtime: "transient",
+		};
+	}
+}
+
+function createAllowedTools(cwd: string, names: string[]): any[] {
+	const all: Record<string, any> = {
+		read: createReadTool(cwd),
+		bash: createBashTool(cwd),
+		edit: createEditTool(cwd),
+		write: createWriteTool(cwd),
+		grep: createGrepTool(cwd),
+		find: createFindTool(cwd),
+		ls: createLsTool(cwd),
+	};
+	return names.map((name) => all[name]).filter(Boolean);
+}
+
+function applySessionEvent(metrics: LiveTeammateMetrics, event: AgentSessionEvent): void {
+	switch (event.type) {
+		case "message_update":
+			if (!metrics.activityHint) metrics.activityHint = "thinking…";
+			break;
+		case "message_end":
+			if (event.message.role === "assistant") {
+				metrics.turns += 1;
+				metrics.currentTool = undefined;
+				metrics.currentToolStartedAt = undefined;
+				metrics.activityHint = "responding…";
+			}
+			break;
+		case "tool_execution_start":
+			metrics.toolUses += 1;
+			metrics.currentTool = event.toolName;
+			metrics.currentToolStartedAt = Date.now();
+			metrics.activityHint = `${event.toolName}…`;
+			break;
+		case "tool_execution_end":
+			metrics.activityHint = event.isError ? "tool error…" : "processing result…";
+			if (metrics.currentTool === event.toolName) {
+				metrics.currentTool = undefined;
+				metrics.currentToolStartedAt = undefined;
+			}
+			break;
+		case "turn_end":
+			metrics.activityHint = "waiting…";
+			break;
+	}
+}
+
+function extractText(content: unknown): string {
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((part) => {
+			if (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part) {
+				return typeof part.text === "string" ? part.text : "";
+			}
+			return "";
+		})
+		.join("");
+}

package/node_modules/pi-mono-team-mode/runtime/worktree.ts

@@ -0,0 +1,90 @@
+/**
+ * Pi Team-Mode — Worktree Isolation
+ *
+ * Wraps `git worktree add/remove` with a no-diff auto-cleanup heuristic
+ * matching Claude Code's semantics:
+ *
+ *   - If the teammate's worktree is clean on cleanup, the worktree and its
+ *     branch are removed silently.
+ *   - If the worktree has uncommitted changes, the path and branch are
+ *     returned to the caller (so they can inspect or merge the work).
+ */
+
+import { spawn } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { randomUUID } from "node:crypto";
+
+export type WorktreeHandle = {
+	path: string;
+	branch: string;
+	repoRoot: string;
+	/** Commit SHA the worktree was branched off of — used to detect new commits. */
+	baseSha: string;
+};
+
+export type WorktreeCleanupResult =
+	| { removed: true }
+	| { removed: false; path: string; branch: string };
+
+/**
+ * Create a git worktree off HEAD in a temp dir (or `base` if supplied).
+ * Throws if the caller's cwd isn't inside a git repo.
+ */
+export async function createWorktree(cwd: string, base?: string): Promise<WorktreeHandle> {
+	const repoRoot = await getRepoRoot(cwd);
+	const worktreeBase = base ?? path.join(os.tmpdir(), "pi-team-mode-worktrees");
+	await mkdir(worktreeBase, { recursive: true });
+	const suffix = randomUUID().slice(0, 8);
+	const worktreePath = path.join(worktreeBase, `teammate-${suffix}`);
+	const branch = `team-mode/teammate-${suffix}`;
+	const head = await git(repoRoot, ["rev-parse", "HEAD"]);
+	const baseSha = head.stdout.trim();
+	await git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+	return { path: worktreePath, branch, repoRoot, baseSha };
+}
+
+/**
+ * Clean up a worktree. If the worktree has no uncommitted changes and no
+ * commits beyond the branch point, remove both the worktree and the branch
+ * and return `{ removed: true }`. Otherwise leave them in place and return
+ * the path and branch so the caller can surface them in the tool result.
+ */
+export async function cleanupWorktree(handle: WorktreeHandle): Promise<WorktreeCleanupResult> {
+	const hasChanges = await worktreeHasChanges(handle);
+	if (hasChanges) {
+		return { removed: false, path: handle.path, branch: handle.branch };
+	}
+	await git(handle.repoRoot, ["worktree", "remove", "--force", handle.path]).catch(() => {});
+	await git(handle.repoRoot, ["branch", "-D", handle.branch]).catch(() => {});
+	return { removed: true };
+}
+
+/** Returns true if the worktree has uncommitted changes OR commits beyond baseSha. */
+async function worktreeHasChanges(handle: WorktreeHandle): Promise<boolean> {
+	const dirty = await git(handle.path, ["status", "--porcelain"]);
+	if (dirty.stdout.trim().length > 0) return true;
+	const head = await git(handle.path, ["rev-parse", "HEAD"]);
+	return head.stdout.trim() !== handle.baseSha;
+}
+
+async function getRepoRoot(cwd: string): Promise<string> {
+	const { stdout, code } = await git(cwd, ["rev-parse", "--show-toplevel"]);
+	if (code !== 0) throw new Error(`not a git repo: ${cwd}`);
+	return stdout.trim();
+}
+
+type GitResult = { stdout: string; stderr: string; code: number };
+
+function git(cwd: string, args: string[]): Promise<GitResult> {
+	return new Promise((resolve) => {
+		const proc = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+		let stdout = "";
+		let stderr = "";
+		proc.stdout.on("data", (c: Buffer) => (stdout += c.toString("utf8")));
+		proc.stderr.on("data", (c: Buffer) => (stderr += c.toString("utf8")));
+		proc.on("close", (code) => resolve({ stdout, stderr, code: code ?? 1 }));
+		proc.on("error", (err) => resolve({ stdout, stderr: err.message, code: 1 }));
+	});
+}