@selesai/code 0.2.1 → 0.3.1

package/dist/extensions/pi-subagents/test/support/mock-pi-script.mjs

@@ -0,0 +1,335 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const queueDir = process.env.MOCK_PI_QUEUE_DIR;
+
+function exitAfterFlush(code) {
+	// process.exit() can truncate buffered stdout/stderr on slow runners (e.g.
+	// GitHub Actions), dropping the final lines the parent executor needs to see
+	// the run as successful. Drain the writable streams first, then exit.
+	// A hard timeout (ref'd, not unref'd) guards against stream.end() callbacks
+	// that never fire on some platforms (notably Windows pipe-backed stdout).
+	const streams = [process.stdout, process.stderr].filter((s) => !s.destroyed && !s.writableEnded);
+	if (streams.length === 0) {
+		process.exit(code);
+		return;
+	}
+	let exited = false;
+	const forceExit = () => {
+		if (exited) return;
+		exited = true;
+		process.exit(code);
+	};
+	let pending = streams.length;
+	for (const stream of streams) {
+		stream.end(() => {
+			if (--pending === 0) forceExit();
+		});
+	}
+	setTimeout(forceExit, 500);
+}
+
+function fail(message, exitCode = 1) {
+	process.stderr.write(`${message}\n`);
+	exitAfterFlush(exitCode);
+}
+
+function listPendingFiles(dir) {
+	return fs.readdirSync(dir)
+		.filter((name) => name.startsWith("pending-") && name.endsWith(".json"))
+		.sort();
+}
+
+function readPendingResponse(filePath) {
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error) {
+			const code = error.code;
+			if (code === "ENOENT") return undefined;
+		}
+		throw error;
+	}
+}
+
+function hasArgMatcher(response) {
+	return Object.prototype.hasOwnProperty.call(response ?? {}, "matchArgIncludes");
+}
+
+function responseMatchesArgs(response, args) {
+	const matcher = response?.matchArgIncludes;
+	if (matcher === undefined) return true;
+	const needles = Array.isArray(matcher) ? matcher : [matcher];
+	if (needles.length === 0) return true;
+	const haystack = args.join("\n");
+	return needles.every((needle) => typeof needle === "string" && haystack.includes(needle));
+}
+
+function claimResponseFile(dir, fileName) {
+	const sourcePath = path.join(dir, fileName);
+	const targetPath = path.join(dir, fileName.replace(/^pending-/, "consumed-"));
+	try {
+		fs.renameSync(sourcePath, targetPath);
+		return JSON.parse(fs.readFileSync(targetPath, "utf-8"));
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error) {
+			const code = error.code;
+			if (code === "ENOENT" || code === "EEXIST" || code === "EPERM") return undefined;
+		}
+		throw error;
+	}
+}
+
+function claimNextResponse(dir, args) {
+	for (const fileName of listPendingFiles(dir)) {
+		const sourcePath = path.join(dir, fileName);
+		const response = readPendingResponse(sourcePath);
+		if (!response || !hasArgMatcher(response) || !responseMatchesArgs(response, args)) continue;
+		const claimed = claimResponseFile(dir, fileName);
+		if (claimed) return claimed;
+	}
+
+	for (const fileName of listPendingFiles(dir)) {
+		const sourcePath = path.join(dir, fileName);
+		const response = readPendingResponse(sourcePath);
+		if (!response || hasArgMatcher(response)) continue;
+		const claimed = claimResponseFile(dir, fileName);
+		if (claimed) return claimed;
+	}
+
+	const defaultPath = path.join(dir, "default-response.json");
+	if (!fs.existsSync(defaultPath)) return undefined;
+	const fallback = JSON.parse(fs.readFileSync(defaultPath, "utf-8"));
+	return responseMatchesArgs(fallback, args) ? fallback : undefined;
+}
+
+function defaultAssistantMessage(output) {
+	return {
+		type: "message_end",
+		message: {
+			role: "assistant",
+			content: [{ type: "text", text: output }],
+			model: "mock/test-model",
+			stopReason: "stop",
+			usage: {
+				input: 100,
+				output: 50,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: { total: 0.001 },
+			},
+		},
+	};
+}
+
+function taskRequestsAcceptance(args) {
+	for (const arg of args) {
+		if (typeof arg !== "string") continue;
+		if (arg.includes("## Acceptance Contract")) return true;
+		if (!arg.startsWith("@")) continue;
+		try {
+			if (fs.readFileSync(arg.slice(1), "utf-8").includes("## Acceptance Contract")) return true;
+		} catch {
+			// Ignore unreadable temp prompt references in the mock harness.
+		}
+	}
+	return false;
+}
+
+function defaultAcceptanceReport() {
+	return [
+		"```acceptance-report",
+		JSON.stringify({
+			criteriaSatisfied: [
+				{ id: "criterion-1", status: "satisfied", evidence: "mock acceptance evidence" },
+				{ id: "criterion-2", status: "satisfied", evidence: "mock acceptance evidence" },
+			],
+			changedFiles: ["mock-file.ts"],
+			testsAddedOrUpdated: ["mock-file.test.ts"],
+			commandsRun: [{ command: "mock validation", result: "passed", summary: "passed" }],
+			validationOutput: ["mock validation passed"],
+			residualRisks: [],
+			noStagedFiles: true,
+			reviewFindings: [],
+			manualNotes: "mock run completed",
+			notes: "mock run completed",
+		}),
+		"```",
+	].join("\n");
+}
+
+function withAcceptanceReport(output, args) {
+	if (!taskRequestsAcceptance(args) || output.includes("```acceptance-report")) return output;
+	return `${output}\n${defaultAcceptanceReport()}`;
+}
+
+function defaultResponse() {
+	return { output: "ok", exitCode: 0 };
+}
+
+function isJsonMode(args) {
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === "--mode") {
+			return args[i + 1] === "json";
+		}
+	}
+	return false;
+}
+
+function writeSessionFile(args) {
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] !== "--session") continue;
+		const sessionFile = args[i + 1];
+		if (!sessionFile) return;
+		fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+		fs.writeFileSync(sessionFile, "", { flag: "a" });
+		return;
+	}
+}
+
+function readSystemPromptRecords(args) {
+	const records = [];
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] !== "--system-prompt" && args[i] !== "--append-system-prompt") continue;
+		const promptPath = args[i + 1];
+		if (!promptPath) continue;
+		try {
+			records.push({
+				mode: args[i],
+				path: promptPath,
+				text: fs.readFileSync(promptPath, "utf-8"),
+			});
+		} catch (error) {
+			records.push({
+				mode: args[i],
+				path: promptPath,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+	return records;
+}
+
+async function writeStdout(text) {
+	if (process.stdout.write(text)) return;
+	await new Promise((resolve) => process.stdout.once("drain", resolve));
+}
+
+async function writeJsonlLine(entry) {
+	const line = typeof entry === "string" ? entry : JSON.stringify(entry);
+	await writeStdout(`${line}\n`);
+}
+
+function extractPlainText(entry) {
+	if (!entry || typeof entry !== "object") return "";
+	if (entry.type === "message_end") {
+		const text = entry.message?.content?.find?.((part) => part?.type === "text")?.text;
+		return typeof text === "string" ? text : "";
+	}
+	if (entry.type === "tool_result_end") {
+		const text = entry.message?.content?.find?.((part) => part?.type === "text")?.text;
+		return typeof text === "string" ? text : "";
+	}
+	return "";
+}
+
+async function writeResponseEntries(entries, jsonMode, args) {
+	let sawProviderError = false;
+	for (const entry of entries) {
+		if (entry?.type === "message_end") {
+			const textPart = entry.message?.content?.find?.((part) => part?.type === "text");
+			const isProviderError = Boolean(entry.message?.errorMessage || entry.message?.stopReason === "error");
+			if (isProviderError) sawProviderError = true;
+			if (!isProviderError && textPart && typeof textPart.text === "string" && (!sawProviderError || textPart.text.trim())) {
+				textPart.text = withAcceptanceReport(textPart.text, args);
+			}
+		}
+		if (jsonMode) {
+			await writeJsonlLine(entry);
+			continue;
+		}
+		const text = extractPlainText(entry);
+		if (text) await writeStdout(`${text}\n`);
+	}
+}
+
+async function maybeWriteStructuredOutput(response, jsonMode) {
+	if (!Object.prototype.hasOwnProperty.call(response, "structuredOutput")) return;
+	const outputPath = process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE;
+	if (!outputPath) return;
+	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+	fs.writeFileSync(outputPath, JSON.stringify(response.structuredOutput), "utf-8");
+	if (!jsonMode) return;
+	await writeJsonlLine({ type: "tool_execution_start", toolName: "structured_output", args: { value: response.structuredOutput } });
+	await writeJsonlLine({
+		type: "tool_result_end",
+		message: {
+			role: "toolResult",
+			toolName: "structured_output",
+			content: [{ type: "text", text: "Structured output captured." }],
+		},
+	});
+	await writeJsonlLine({ type: "tool_execution_end", toolName: "structured_output" });
+}
+
+async function main() {
+	if (!queueDir) fail("MOCK_PI_QUEUE_DIR is required.");
+	if (!fs.existsSync(queueDir)) fail(`Mock queue dir does not exist: ${queueDir}`);
+
+	const args = process.argv.slice(2);
+	const jsonMode = isJsonMode(args);
+	const response = claimNextResponse(queueDir, args) ?? defaultResponse();
+	if (response.ignoreSigterm === true) {
+		process.on("SIGTERM", () => {});
+	}
+	writeSessionFile(args);
+	fs.writeFileSync(
+		path.join(queueDir, `call-${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.json`),
+		JSON.stringify({ args, systemPrompts: readSystemPromptRecords(args) }),
+		"utf-8",
+	);
+
+	if (typeof response.delay === "number" && response.delay > 0) {
+		await new Promise((resolve) => setTimeout(resolve, response.delay));
+	}
+
+	if (Array.isArray(response.steps) && response.steps.length > 0) {
+		for (const step of response.steps) {
+			if (typeof step?.delay === "number" && step.delay > 0) {
+				await new Promise((resolve) => setTimeout(resolve, step.delay));
+				}
+				if (Array.isArray(step?.jsonl) && step.jsonl.length > 0) {
+						await writeResponseEntries(step.jsonl, jsonMode, args);
+				}
+				if (typeof step?.stderr === "string" && step.stderr.length > 0) {
+					process.stderr.write(step.stderr);
+				}
+			}
+		} else if (Array.isArray(response.jsonl) && response.jsonl.length > 0) {
+				await writeResponseEntries(response.jsonl, jsonMode, args);
+		} else if (Array.isArray(response.echoEnv) && response.echoEnv.length > 0) {
+			const envSnapshot = Object.fromEntries(response.echoEnv.map((key) => [key, process.env[key] ?? null]));
+				const output = withAcceptanceReport(JSON.stringify(envSnapshot), args);
+				if (jsonMode) await writeJsonlLine(defaultAssistantMessage(output));
+				else await writeStdout(`${output}\n`);
+			} else if (typeof response.output === "string") {
+				const output = withAcceptanceReport(response.output, args);
+				if (jsonMode) await writeJsonlLine(defaultAssistantMessage(output));
+				else await writeStdout(`${output}\n`);
+			}
+		await maybeWriteStructuredOutput(response, jsonMode);
+
+	if (typeof response.stderr === "string" && response.stderr.length > 0) {
+		process.stderr.write(response.stderr);
+	}
+
+	if (typeof response.keepAliveAfterFinalMessageMs === "number" && response.keepAliveAfterFinalMessageMs > 0) {
+		await new Promise((resolve) => setTimeout(resolve, response.keepAliveAfterFinalMessageMs));
+	}
+
+	exitAfterFlush(typeof response.exitCode === "number" ? response.exitCode : 0);
+}
+
+main().catch((error) => {
+	fail(error instanceof Error ? error.message : String(error));
+});

package/dist/extensions/pi-subagents/test/support/mock-pi.ts

@@ -0,0 +1,129 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+interface MockPiResponse {
+	output?: string;
+	stderr?: string;
+	exitCode?: number;
+	delay?: number;
+	keepAliveAfterFinalMessageMs?: number;
+	ignoreSigterm?: boolean;
+	jsonl?: unknown[];
+	steps?: Array<{
+		delay?: number;
+		jsonl?: unknown[];
+		stderr?: string;
+	}>;
+	echoEnv?: string[];
+	matchArgIncludes?: string | string[];
+}
+
+export interface MockPi {
+	readonly dir: string;
+	install(): void;
+	uninstall(): void;
+	onCall(response: MockPiResponse): void;
+	reset(): void;
+	callCount(): number;
+}
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPT_PATH = path.join(__dirname, "mock-pi-script.mjs");
+const CALL_PREFIX = "call-";
+const DEFAULT_RESPONSE_FILE = "default-response.json";
+const QUEUED_PREFIX = "pending-";
+
+function ensureDir(dir: string): void {
+	fs.mkdirSync(dir, { recursive: true });
+}
+
+function writeExecutable(filePath: string, content: string): void {
+	fs.writeFileSync(filePath, content, "utf-8");
+	fs.chmodSync(filePath, 0o755);
+}
+
+function listQueueFiles(queueDir: string, prefix: string): string[] {
+	try {
+		return fs.readdirSync(queueDir)
+			.filter((name) => name.startsWith(prefix))
+			.sort();
+	} catch {
+		return [];
+	}
+}
+
+export function createMockPi(): MockPi {
+	const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-mock-cli-"));
+	const queueDir = path.join(rootDir, "queue");
+	const binDir = path.join(rootDir, "bin");
+	ensureDir(queueDir);
+	ensureDir(binDir);
+
+	const shellScriptPath = path.join(binDir, "pi");
+	const cmdScriptPath = path.join(binDir, "pi.cmd");
+	writeExecutable(shellScriptPath, `#!/bin/sh\nexec "${process.execPath}" "${SCRIPT_PATH}" "$@"\n`);
+	writeExecutable(cmdScriptPath, `@echo off\r\n"${process.execPath}" "${SCRIPT_PATH}" %*\r\n`);
+
+	let installed = false;
+	let nextSequence = 0;
+	let originalPath: string | undefined;
+	let originalArgv1: string | undefined;
+	let originalQueueEnv: string | undefined;
+
+	return {
+		get dir() {
+			return queueDir;
+		},
+		install() {
+			if (installed) return;
+			installed = true;
+			originalPath = process.env.PATH;
+			originalQueueEnv = process.env.MOCK_PI_QUEUE_DIR;
+			process.env.PATH = `${binDir}${path.delimiter}${originalPath ?? ""}`;
+			process.env.MOCK_PI_QUEUE_DIR = queueDir;
+			if (process.platform === "win32") {
+				originalArgv1 = process.argv[1];
+				process.argv[1] = SCRIPT_PATH;
+			}
+		},
+		uninstall() {
+			if (!installed) return;
+			installed = false;
+			if (originalPath === undefined) delete process.env.PATH;
+			else process.env.PATH = originalPath;
+			if (originalQueueEnv === undefined) delete process.env.MOCK_PI_QUEUE_DIR;
+			else process.env.MOCK_PI_QUEUE_DIR = originalQueueEnv;
+			if (process.platform === "win32") {
+				if (originalArgv1 === undefined) delete process.argv[1];
+				else process.argv[1] = originalArgv1;
+			}
+			try {
+				fs.rmSync(rootDir, { recursive: true, force: true });
+			} catch {}
+		},
+		onCall(response) {
+			ensureDir(queueDir);
+			nextSequence += 1;
+			const fileName = `${QUEUED_PREFIX}${String(nextSequence).padStart(6, "0")}.json`;
+			const tempPath = path.join(queueDir, `${fileName}.tmp-${process.pid}-${Date.now()}`);
+			const finalPath = path.join(queueDir, fileName);
+			fs.writeFileSync(tempPath, JSON.stringify(response), "utf-8");
+			fs.renameSync(tempPath, finalPath);
+			fs.writeFileSync(path.join(queueDir, DEFAULT_RESPONSE_FILE), JSON.stringify(response), "utf-8");
+		},
+		reset() {
+			nextSequence = 0;
+			ensureDir(queueDir);
+			for (const entry of fs.readdirSync(queueDir)) {
+				try {
+					fs.rmSync(path.join(queueDir, entry), { recursive: true, force: true });
+				} catch {}
+			}
+		},
+		callCount() {
+			return listQueueFiles(queueDir, CALL_PREFIX).length;
+		},
+	};
+}

package/dist/extensions/pi-subagents/test/support/real-session-child-cli.mjs

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+import { mkdtempSync, rmSync } from "node:fs";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+	fauxAssistantMessage,
+	fauxText,
+	registerFauxProvider,
+} from "@earendil-works/pi-ai";
+import {
+	createAgentSession,
+	DefaultResourceLoader,
+	SessionManager,
+	SettingsManager,
+} from "@selesai/code";
+
+function readText(filePath) {
+	return fs.readFileSync(filePath, "utf-8");
+}
+
+function parseArgs(argv) {
+	const parsed = {
+		mode: "text",
+		extensions: [],
+		appendSystemPrompts: [],
+		noSession: false,
+		noSkills: false,
+	};
+
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--mode") {
+			parsed.mode = argv[++i] ?? "text";
+			continue;
+		}
+		if (arg === "-p" || arg === "--print") continue;
+		if (arg === "--no-session") {
+			parsed.noSession = true;
+			continue;
+		}
+		if (arg === "--session") {
+			parsed.sessionFile = argv[++i];
+			continue;
+		}
+		if (arg === "--session-dir") {
+			parsed.sessionDir = argv[++i];
+			continue;
+		}
+		if (arg === "--model") {
+			parsed.model = argv[++i];
+			continue;
+		}
+		if (arg === "--tools") {
+			parsed.tools = (argv[++i] ?? "").split(",").map((tool) => tool.trim()).filter(Boolean);
+			continue;
+		}
+		if (arg === "--extension") {
+			const extensionPath = argv[++i];
+			if (extensionPath) parsed.extensions.push(extensionPath);
+			continue;
+		}
+		if (arg === "--no-extensions") continue;
+		if (arg === "--no-skills") {
+			parsed.noSkills = true;
+			continue;
+		}
+		if (arg === "--system-prompt") {
+			const promptPath = argv[++i];
+			if (promptPath) parsed.systemPrompt = readText(promptPath);
+			continue;
+		}
+		if (arg === "--append-system-prompt") {
+			const promptPath = argv[++i];
+			if (promptPath) parsed.appendSystemPrompts.push(readText(promptPath));
+			continue;
+		}
+		if (arg?.startsWith("--")) continue;
+		parsed.prompt = arg;
+	}
+
+	if (parsed.prompt?.startsWith("@")) {
+		parsed.prompt = readText(parsed.prompt.slice(1));
+	}
+	return parsed;
+}
+
+function createModelRegistry(model) {
+	return {
+		find: (provider, id) => provider === model.provider && id === model.id ? model : undefined,
+		getAll: () => [model],
+		getAvailable: () => [model],
+		hasConfiguredAuth: () => true,
+		isUsingOAuth: () => false,
+		getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "faux", headers: {} }),
+		registerProvider: () => {},
+		unregisterProvider: () => {},
+	};
+}
+
+function createSessionManager(parsed, cwd) {
+	if (parsed.sessionFile) {
+		const sessionDir = parsed.sessionDir ?? path.dirname(parsed.sessionFile);
+		const manager = SessionManager.create(cwd, sessionDir);
+		manager.setSessionFile(parsed.sessionFile);
+		return manager;
+	}
+	if (parsed.noSession) return SessionManager.inMemory(cwd);
+	return SessionManager.create(cwd, parsed.sessionDir);
+}
+
+async function main() {
+	const parsed = parseArgs(process.argv.slice(2));
+	const responseText = process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT ?? "CHILD_REAL_SESSION_OK";
+	const cwd = process.cwd();
+	const ownedAgentDir = process.env.SELESAI_CODING_AGENT_DIR
+		? undefined
+		: mkdtempSync(path.join(os.tmpdir(), "pi-e2e-agent-dir-"));
+	const agentDir = process.env.SELESAI_CODING_AGENT_DIR ?? ownedAgentDir;
+
+	const faux = registerFauxProvider({
+		provider: "faux-e2e-child",
+		models: [{ id: "child", contextWindow: 200_000 }],
+	});
+	const model = faux.getModel();
+	faux.setResponses([
+		() => fauxAssistantMessage(fauxText(responseText), { stopReason: "stop" }),
+	]);
+
+	const settingsManager = SettingsManager.inMemory({
+		compaction: { enabled: false },
+		retry: { enabled: false },
+	});
+	const loader = new DefaultResourceLoader({
+		cwd,
+		agentDir,
+		settingsManager,
+		additionalExtensionPaths: parsed.extensions,
+		noSkills: parsed.noSkills,
+		noPromptTemplates: true,
+		noThemes: true,
+		noContextFiles: true,
+		systemPrompt: parsed.systemPrompt,
+		appendSystemPrompt: parsed.appendSystemPrompts,
+	});
+
+	try {
+		await loader.reload();
+		const { session } = await createAgentSession({
+			cwd,
+			agentDir,
+			model,
+			modelRegistry: createModelRegistry(model),
+			resourceLoader: loader,
+			sessionManager: createSessionManager(parsed, cwd),
+			settingsManager,
+			tools: parsed.tools,
+		});
+
+		session.subscribe((event) => {
+			if (
+				event.type === "message_end"
+				|| event.type === "tool_execution_start"
+				|| event.type === "tool_execution_end"
+				|| event.type === "tool_result_end"
+			) {
+				process.stdout.write(`${JSON.stringify(event)}\n`);
+			}
+		});
+
+		await session.bindExtensions({});
+		await session.prompt(parsed.prompt ?? "", { expandPromptTemplates: false });
+		await session.extensionRunner.emit({ type: "session_shutdown", reason: "quit" });
+		session.dispose();
+	} finally {
+		faux.unregister();
+		if (ownedAgentDir) rmSync(ownedAgentDir, { recursive: true, force: true });
+	}
+}
+
+main().catch((error) => {
+	process.stderr.write(`${error instanceof Error ? error.stack || error.message : String(error)}\n`);
+	process.exit(1);
+});