@leing2021/super-pi 0.20.0 → 0.22.0

package/extensions/subagent/pi-args.ts

@@ -0,0 +1,138 @@
+// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
+// MIT License
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+const TASK_ARG_LIMIT = 8000;
+const PROMPT_RUNTIME_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-prompt-runtime.ts");
+
+export interface BuildPiArgsInput {
+	baseArgs: string[];
+	task: string;
+	sessionEnabled: boolean;
+	sessionDir?: string;
+	sessionFile?: string;
+	model?: string;
+	thinking?: string;
+	systemPromptMode?: "append" | "replace";
+	inheritProjectContext: boolean;
+	inheritSkills: boolean;
+	tools?: string[];
+	extensions?: string[];
+	systemPrompt?: string | null;
+	mcpDirectTools?: string[];
+	promptFileStem?: string;
+	intercomSessionName?: string;
+}
+
+export interface BuildPiArgsResult {
+	args: string[];
+	env: Record<string, string | undefined>;
+	tempDir?: string;
+}
+
+export function applyThinkingSuffix(model: string | undefined, thinking: string | undefined): string | undefined {
+	if (!model || !thinking || thinking === "off") return model;
+	const colonIdx = model.lastIndexOf(":");
+	if (colonIdx !== -1 && THINKING_LEVELS.includes(model.substring(colonIdx + 1))) return model;
+	return `${model}:${thinking}`;
+}
+
+export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
+	const args = [...input.baseArgs];
+
+	if (input.sessionFile) {
+		fs.mkdirSync(path.dirname(input.sessionFile), { recursive: true });
+		args.push("--session", input.sessionFile);
+	} else {
+		if (!input.sessionEnabled) {
+			args.push("--no-session");
+		}
+		if (input.sessionDir) {
+			fs.mkdirSync(input.sessionDir, { recursive: true });
+			args.push("--session-dir", input.sessionDir);
+		}
+	}
+
+	const modelArg = applyThinkingSuffix(input.model, input.thinking);
+	if (modelArg) {
+		args.push("--model", modelArg);
+	}
+
+	const toolExtensionPaths: string[] = [];
+	if (input.tools?.length) {
+		const builtinTools: string[] = [];
+		for (const tool of input.tools) {
+			if (tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js")) {
+				toolExtensionPaths.push(tool);
+			} else {
+				builtinTools.push(tool);
+			}
+		}
+		if (builtinTools.length > 0) {
+			args.push("--tools", builtinTools.join(","));
+		}
+	}
+
+	const runtimeExtensions = [PROMPT_RUNTIME_EXTENSION_PATH];
+	if (input.extensions !== undefined) {
+		args.push("--no-extensions");
+		for (const extPath of [...new Set([...runtimeExtensions, ...toolExtensionPaths, ...input.extensions])]) {
+			args.push("--extension", extPath);
+		}
+	} else {
+		for (const extPath of [...new Set([...runtimeExtensions, ...toolExtensionPaths])]) {
+			args.push("--extension", extPath);
+		}
+	}
+
+	if (!input.inheritSkills) {
+		args.push("--no-skills");
+	}
+
+	let tempDir: string | undefined;
+	if (input.systemPrompt !== undefined && input.systemPrompt !== null) {
+		tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
+		const stem = (input.promptFileStem ?? "prompt").replace(/[^\w.-]/g, "_");
+		const promptPath = path.join(tempDir, `${stem}.md`);
+		fs.writeFileSync(promptPath, input.systemPrompt, { mode: 0o600 });
+		args.push(input.systemPromptMode === "replace" ? "--system-prompt" : "--append-system-prompt", promptPath);
+	}
+
+	if (input.task.length > TASK_ARG_LIMIT) {
+		if (!tempDir) {
+			tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
+		}
+		const taskFilePath = path.join(tempDir, "task.md");
+		fs.writeFileSync(taskFilePath, `Task: ${input.task}`, { mode: 0o600 });
+		args.push(`@${taskFilePath}`);
+	} else {
+		args.push(`Task: ${input.task}`);
+	}
+
+	const env: Record<string, string | undefined> = {};
+	env.PI_SUBAGENT_INHERIT_PROJECT_CONTEXT = input.inheritProjectContext ? "1" : "0";
+	env.PI_SUBAGENT_INHERIT_SKILLS = input.inheritSkills ? "1" : "0";
+	if (input.intercomSessionName) {
+		env.PI_SUBAGENT_INTERCOM_SESSION_NAME = input.intercomSessionName;
+	}
+	if (input.mcpDirectTools?.length) {
+		env.MCP_DIRECT_TOOLS = input.mcpDirectTools.join(",");
+	} else {
+		env.MCP_DIRECT_TOOLS = "__none__";
+	}
+
+	return { args, env, tempDir };
+}
+
+export function cleanupTempDir(tempDir: string | null | undefined): void {
+	if (!tempDir) return;
+	try {
+		fs.rmSync(tempDir, { recursive: true, force: true });
+	} catch {
+		// Temp cleanup is best effort.
+	}
+}

package/extensions/subagent/pi-spawn.ts

@@ -0,0 +1,100 @@
+// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
+// MIT License
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+
+const require = createRequire(import.meta.url);
+
+export function resolvePiPackageRoot(): string | undefined {
+	try {
+		const entry = process.argv[1];
+		if (!entry) return undefined;
+		let dir = path.dirname(fs.realpathSync(entry));
+		while (dir !== path.dirname(dir)) {
+			try {
+				const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf-8"));
+				if (pkg.name === "@mariozechner/pi-coding-agent") return dir;
+			} catch {}
+			dir = path.dirname(dir);
+		}
+	} catch {}
+	return undefined;
+}
+
+export interface PiSpawnDeps {
+	platform?: NodeJS.Platform;
+	execPath?: string;
+	argv1?: string;
+	existsSync?: (filePath: string) => boolean;
+	readFileSync?: (filePath: string, encoding: "utf-8") => string;
+	resolvePackageJson?: () => string;
+	piPackageRoot?: string;
+}
+
+export interface PiSpawnCommand {
+	command: string;
+	args: string[];
+}
+
+function isRunnableNodeScript(filePath: string, existsSync: (filePath: string) => boolean): boolean {
+	if (!existsSync(filePath)) return false;
+	return /\.(?:mjs|cjs|js)$/i.test(filePath);
+}
+
+function normalizePath(filePath: string): string {
+	return path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
+}
+
+export function resolveWindowsPiCliScript(deps: PiSpawnDeps = {}): string | undefined {
+	const existsSync = deps.existsSync ?? fs.existsSync;
+	const readFileSync = deps.readFileSync ?? ((filePath, encoding) => fs.readFileSync(filePath, encoding));
+	const argv1 = deps.argv1 ?? process.argv[1];
+
+	if (argv1) {
+		const argvPath = normalizePath(argv1);
+		if (isRunnableNodeScript(argvPath, existsSync)) {
+			return argvPath;
+		}
+	}
+
+	try {
+		const resolvePackageJson = deps.resolvePackageJson ?? (() => {
+			const root = deps.piPackageRoot ?? resolvePiPackageRoot();
+			if (root) return path.join(root, "package.json");
+			return require.resolve("@mariozechner/pi-coding-agent/package.json");
+		});
+		const packageJsonPath = resolvePackageJson();
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as {
+			bin?: string | Record<string, string>;
+		};
+		const binField = packageJson.bin;
+		const binPath = typeof binField === "string"
+			? binField
+			: binField?.pi ?? Object.values(binField ?? {})[0];
+		if (!binPath) return undefined;
+		const candidate = normalizePath(path.resolve(path.dirname(packageJsonPath), binPath));
+		if (isRunnableNodeScript(candidate, existsSync)) {
+			return candidate;
+		}
+	} catch {
+		return undefined;
+	}
+
+	return undefined;
+}
+
+export function getPiSpawnCommand(args: string[], deps: PiSpawnDeps = {}): PiSpawnCommand {
+	const platform = deps.platform ?? process.platform;
+	if (platform === "win32") {
+		const piCliPath = resolveWindowsPiCliScript(deps);
+		if (piCliPath) {
+			return {
+				command: deps.execPath ?? process.execPath,
+				args: [piCliPath, ...args],
+			};
+		}
+	}
+
+	return { command: "pi", args };
+}

package/extensions/subagent/post-exit-stdio-guard.ts

@@ -0,0 +1,87 @@
+// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
+// MIT License
+import type { ChildProcess } from "node:child_process";
+
+interface PostExitStdioGuardOptions {
+	idleMs: number;
+	hardMs: number;
+}
+
+interface ChildWithPipedStdio {
+	stdout: ChildProcess["stdout"];
+	stderr: ChildProcess["stderr"];
+	on: ChildProcess["on"];
+}
+
+interface ChildWithKill {
+	kill(signal?: NodeJS.Signals | number): boolean;
+}
+
+export function trySignalChild(child: ChildWithKill, signal: NodeJS.Signals): boolean {
+	try {
+		return child.kill(signal);
+	} catch {
+		return false;
+	}
+}
+
+export function attachPostExitStdioGuard(
+	child: ChildWithPipedStdio,
+	options: PostExitStdioGuardOptions,
+): () => void {
+	const { idleMs, hardMs } = options;
+	let exited = false;
+	let stdoutEnded = false;
+	let stderrEnded = false;
+	let idleTimer: NodeJS.Timeout | undefined;
+	let hardTimer: NodeJS.Timeout | undefined;
+
+	const destroyUnendedStdio = () => {
+		if (!stdoutEnded) {
+			try { child.stdout?.destroy(); } catch {}
+		}
+		if (!stderrEnded) {
+			try { child.stderr?.destroy(); } catch {}
+		}
+	};
+
+	const clearTimers = () => {
+		if (idleTimer) {
+			clearTimeout(idleTimer);
+			idleTimer = undefined;
+		}
+		if (hardTimer) {
+			clearTimeout(hardTimer);
+			hardTimer = undefined;
+		}
+	};
+
+	const armIdleTimer = () => {
+		if (!exited) return;
+		if (idleTimer) clearTimeout(idleTimer);
+		idleTimer = setTimeout(destroyUnendedStdio, idleMs);
+		idleTimer.unref?.();
+	};
+
+	child.stdout?.on("data", armIdleTimer);
+	child.stderr?.on("data", armIdleTimer);
+	child.stdout?.on("end", () => {
+		stdoutEnded = true;
+		if (stdoutEnded && stderrEnded) clearTimers();
+	});
+	child.stderr?.on("end", () => {
+		stderrEnded = true;
+		if (stdoutEnded && stderrEnded) clearTimers();
+	});
+	child.on("exit", () => {
+		exited = true;
+		armIdleTimer();
+		if (hardTimer) return;
+		hardTimer = setTimeout(destroyUnendedStdio, hardMs);
+		hardTimer.unref?.();
+	});
+	child.on("close", clearTimers);
+	child.on("error", clearTimers);
+
+	return clearTimers;
+}