@selesai/code 0.3.0 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/index-child-registration.test.ts

@@ -0,0 +1,271 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, it } from "node:test";
+import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../../src/runs/shared/pi-args.ts";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+function parentToolEnv(): NodeJS.ProcessEnv {
+	const env = { ...process.env };
+	delete env[SUBAGENT_CHILD_ENV];
+	delete env[SUBAGENT_FANOUT_CHILD_ENV];
+	return env;
+}
+
+describe("subagent extension child mode", () => {
+	it("collapses tool detail before direct subagent tool execution", () => {
+		const script = String.raw`
+			import registerSubagentExtension from "./src/extension/index.ts";
+			const events = { on() { return () => {}; }, emit() {} };
+			let registeredTool;
+			const fakePi = new Proxy({
+				events,
+				registerTool(tool) { if (tool.name === "subagent") registeredTool = tool; },
+				registerCommand() {},
+				registerShortcut() {},
+				registerMessageRenderer() {},
+				sendMessage() {},
+				getSessionName() { return undefined; },
+			}, {
+				get(target, prop) {
+					if (prop in target) return target[prop];
+					return () => undefined;
+				},
+			});
+			registerSubagentExtension(fakePi);
+			if (!registeredTool) throw new Error("tool not registered");
+			const calls = [];
+			const ctx = {
+				cwd: process.cwd(),
+				hasUI: true,
+				ui: {
+					setToolsExpanded(value) { calls.push(value); },
+					setWidget() {},
+					requestRender() {},
+					theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } },
+				},
+				sessionManager: { getSessionId() { return "session-test"; }, getSessionFile() { return null; } },
+				modelRegistry: { getAvailable() { return []; } },
+			};
+			await registeredTool.execute("collapse-check", { action: "list" }, new AbortController().signal, undefined, ctx);
+			if (calls[0] !== false) throw new Error("expected setToolsExpanded(false), got " + JSON.stringify(calls));
+		`;
+
+		execFileSync(
+			process.execPath,
+			[
+				"--experimental-transform-types",
+				"--import",
+				"./test/support/register-loader.mjs",
+				"--input-type=module",
+				"--eval",
+				script,
+			],
+			{ cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" },
+		);
+	});
+
+	it("does not show async badge for explicit foreground clarify chain calls", () => {
+		const script = String.raw`
+			import registerSubagentExtension from "./src/extension/index.ts";
+			const events = { on() { return () => {}; }, emit() {} };
+			let registeredTool;
+			const fakePi = new Proxy({
+				events,
+				registerTool(tool) { if (tool.name === "subagent") registeredTool = tool; },
+				registerCommand() {},
+				registerShortcut() {},
+				registerMessageRenderer() {},
+				sendMessage() {},
+				getSessionName() { return undefined; },
+			}, {
+				get(target, prop) {
+					if (prop in target) return target[prop];
+					return () => undefined;
+				},
+			});
+			registerSubagentExtension(fakePi);
+			if (!registeredTool) throw new Error("tool not registered");
+			const theme = { fg(_name, text) { return text; }, bold(text) { return text; } };
+			const asyncChain = registeredTool.renderCall({ chain: [{ agent: "worker" }, { agent: "reviewer" }], async: true }, theme).text;
+			const asyncParallel = registeredTool.renderCall({ tasks: [{ agent: "worker" }, { agent: "reviewer", count: 2 }], async: true }, theme).text;
+			const clarifyChain = registeredTool.renderCall({ chain: [{ agent: "worker" }, { agent: "reviewer" }], async: true, clarify: true }, theme).text;
+			if (!asyncChain.includes("[async]")) throw new Error("expected async chain badge, got " + asyncChain);
+			if (!asyncParallel.includes("parallel (3) [async]")) throw new Error("expected async parallel badge, got " + asyncParallel);
+			if (clarifyChain.includes("[async]")) throw new Error("unexpected clarify async badge: " + clarifyChain);
+		`;
+
+		execFileSync(
+			process.execPath,
+			[
+				"--experimental-transform-types",
+				"--import",
+				"./test/support/register-loader.mjs",
+				"--input-type=module",
+				"--eval",
+				script,
+			],
+			{ cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" },
+		);
+	});
+
+	it("returns before registering anything for non-fanout children", () => {
+		const script = String.raw`
+			import registerSubagentExtension from "./src/extension/index.ts";
+			import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "./src/runs/shared/pi-args.ts";
+			process.env[SUBAGENT_CHILD_ENV] = "1";
+			process.env[SUBAGENT_FANOUT_CHILD_ENV] = "0";
+			const calls = [];
+			const fakePi = new Proxy({}, {
+				get(_target, prop) {
+					return (..._args) => {
+						calls.push(String(prop));
+						return undefined;
+					};
+				},
+			});
+			registerSubagentExtension(fakePi);
+			if (calls.length > 0) {
+				throw new Error("Unexpected child-mode registrations: " + calls.join(", "));
+			}
+		`;
+
+		execFileSync(
+			process.execPath,
+			[
+				"--experimental-transform-types",
+				"--import",
+				"./test/support/register-loader.mjs",
+				"--input-type=module",
+				"--eval",
+				script,
+			],
+			{ cwd: projectRoot, stdio: "pipe" },
+		);
+	});
+
+	it("returns before registering anything for fanout children", () => {
+		const script = String.raw`
+			import registerSubagentExtension from "./src/extension/index.ts";
+			import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "./src/runs/shared/pi-args.ts";
+			process.env[SUBAGENT_CHILD_ENV] = "1";
+			process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
+			const calls = [];
+			const fakePi = new Proxy({}, {
+				get(target, prop) {
+					if (prop in target) return target[prop];
+					return (..._args) => {
+						calls.push(String(prop));
+						return undefined;
+					};
+				},
+			});
+			registerSubagentExtension(fakePi);
+			if (calls.length > 0) {
+				throw new Error("Unexpected child-mode registrations: " + calls.join(", "));
+			}
+		`;
+
+		execFileSync(
+			process.execPath,
+			[
+				"--experimental-transform-types",
+				"--import",
+				"./test/support/register-loader.mjs",
+				"--input-type=module",
+				"--eval",
+				script,
+			],
+			{ cwd: projectRoot, stdio: "pipe" },
+		);
+	});
+
+	it("does not double-register the child-safe subagent tool when index and fanout-child both load", () => {
+		const script = String.raw`
+			import registerSubagentExtension from "./src/extension/index.ts";
+			import registerFanoutChildSubagentExtension from "./src/extension/fanout-child.ts";
+			import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "./src/runs/shared/pi-args.ts";
+			process.env[SUBAGENT_CHILD_ENV] = "1";
+			process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
+
+			const registeredNames = new Set();
+			const registrations = [];
+			function makePi(source) {
+				return {
+					events: { on() { return () => {}; }, emit() {} },
+					registerTool(tool) {
+						if (registeredNames.has(tool.name)) {
+							throw new Error("Tool " + tool.name + " conflicts with " + source);
+						}
+						registeredNames.add(tool.name);
+						registrations.push({ source, name: tool.name });
+					},
+					getSessionName() { return undefined; },
+				};
+			}
+
+			registerSubagentExtension(makePi("index.ts"));
+			registerFanoutChildSubagentExtension(makePi("fanout-child.ts"));
+			if (registrations.length !== 1 || registrations[0].name !== "subagent" || registrations[0].source !== "fanout-child.ts") {
+				throw new Error("expected only fanout-child.ts to register subagent, got " + JSON.stringify(registrations));
+			}
+		`;
+
+		execFileSync(
+			process.execPath,
+			[
+				"--experimental-transform-types",
+				"--import",
+				"./test/support/register-loader.mjs",
+				"--input-type=module",
+				"--eval",
+				script,
+			],
+			{ cwd: projectRoot, stdio: "pipe" },
+		);
+	});
+
+	it("lets fanout children call read-only list but blocks mutating management actions", () => {
+		const script = String.raw`
+			import registerFanoutChildSubagentExtension from "./src/extension/fanout-child.ts";
+			import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "./src/runs/shared/pi-args.ts";
+			process.env[SUBAGENT_CHILD_ENV] = "1";
+			process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
+			let registeredTool;
+			const fakePi = {
+				events: { on() { return () => {}; }, emit() {} },
+				registerTool(tool) { registeredTool = tool; },
+				getSessionName() { return undefined; },
+			};
+			registerFanoutChildSubagentExtension(fakePi);
+			if (!registeredTool) throw new Error("tool not registered");
+			const ctx = {
+				cwd: process.cwd(),
+				hasUI: false,
+				sessionManager: { getSessionId() { return "session-test"; }, getSessionFile() { return null; } },
+				modelRegistry: { getAvailable() { return []; } },
+			};
+			const list = await registeredTool.execute("list-check", { action: "list" }, new AbortController().signal, undefined, ctx);
+			if (list.isError) throw new Error("list should be allowed: " + JSON.stringify(list.content));
+			const create = await registeredTool.execute("create-check", { action: "create", config: { name: "x" } }, new AbortController().signal, undefined, ctx);
+			if (!create.isError) throw new Error("create should be blocked");
+			const text = create.content?.[0]?.text ?? "";
+			if (!text.includes("not available from child-safe subagent fanout mode")) throw new Error("unexpected create error: " + text);
+		`;
+
+		execFileSync(
+			process.execPath,
+			[
+				"--experimental-transform-types",
+				"--import",
+				"./test/support/register-loader.mjs",
+				"--input-type=module",
+				"--eval",
+				script,
+			],
+			{ cwd: projectRoot, stdio: "pipe" },
+		);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/intercom-bridge.test.ts

@@ -0,0 +1,173 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import type { AgentConfig } from "../../src/agents/agents.ts";
+import {
+	NATIVE_INTERCOM_EXTENSION_DIR,
+	applyIntercomBridgeToAgent,
+	diagnoseIntercomBridge,
+	resolveIntercomBridge,
+	resolveIntercomSessionTarget,
+	resolveSubagentIntercomTarget,
+	resolveIntercomBridgeMode,
+	type IntercomBridgeState,
+} from "../../src/intercom/intercom-bridge.ts";
+
+function makeAgent(overrides: Partial<AgentConfig> = {}): AgentConfig {
+	return {
+		name: "worker",
+		description: "Test worker",
+		systemPrompt: "Base prompt",
+		systemPromptMode: "replace",
+		inheritProjectContext: false,
+		inheritSkills: false,
+		source: "user",
+		filePath: "/tmp/worker.md",
+		...overrides,
+	};
+}
+
+describe("resolveIntercomBridgeMode", () => {
+	it("defaults unknown values to always", () => {
+		assert.equal(resolveIntercomBridgeMode(undefined), "always");
+		assert.equal(resolveIntercomBridgeMode("nope"), "always");
+	});
+
+	it("accepts explicit modes", () => {
+		assert.equal(resolveIntercomBridgeMode("off"), "off");
+		assert.equal(resolveIntercomBridgeMode("fork-only"), "fork-only");
+		assert.equal(resolveIntercomBridgeMode("always"), "always");
+	});
+});
+
+describe("resolveIntercomSessionTarget", () => {
+	it("prefers an explicit session name", () => {
+		assert.equal(resolveIntercomSessionTarget("planner", "session-12345678"), "planner");
+	});
+
+	it("uses a runtime-only subagent chat alias when unnamed", () => {
+		assert.equal(resolveIntercomSessionTarget(undefined, "session-12345678"), "subagent-chat-12345678");
+	});
+});
+
+describe("resolveSubagentIntercomTarget", () => {
+	it("builds stable child session targets from run metadata", () => {
+		assert.equal(resolveSubagentIntercomTarget("78f659a3", "worker"), "subagent-worker-78f659a3");
+		assert.equal(resolveSubagentIntercomTarget("78f659a3", "senior executor", 1), "subagent-senior-executor-78f659a3-2");
+	});
+});
+
+describe("diagnoseIntercomBridge", () => {
+	it("reports the native supervisor channel as available without external package discovery", () => {
+		const diagnostic = diagnoseIntercomBridge({
+			config: { mode: "always" },
+			context: "fresh",
+			orchestratorTarget: "main",
+		});
+
+		assert.equal(diagnostic.active, true);
+		assert.equal(diagnostic.wantsIntercom, true);
+		assert.equal(diagnostic.supervisorChannelAvailable, true);
+		assert.equal(diagnostic.extensionDir, NATIVE_INTERCOM_EXTENSION_DIR);
+	});
+
+	it("does not read external intercom config when bridge mode is off", () => {
+		const diagnostic = diagnoseIntercomBridge({
+			config: { mode: "off" },
+			context: "fresh",
+			orchestratorTarget: "main",
+		});
+
+		assert.equal(diagnostic.active, false);
+		assert.equal(diagnostic.reason, "bridge mode is off");
+	});
+});
+
+describe("resolveIntercomBridge", () => {
+	it("activates when mode/context permit and an orchestrator target exists", () => {
+		const bridge = resolveIntercomBridge({
+			config: { mode: "fork-only" },
+			context: "fork",
+			orchestratorTarget: "main",
+		});
+
+		assert.equal(bridge.active, true);
+		assert.equal(bridge.orchestratorTarget, "main");
+		assert.equal(bridge.extensionDir, NATIVE_INTERCOM_EXTENSION_DIR);
+	});
+
+	it("stays inactive for fresh context when mode is fork-only", () => {
+		const bridge = resolveIntercomBridge({
+			config: { mode: "fork-only" },
+			context: "fresh",
+			orchestratorTarget: "main",
+		});
+		assert.equal(bridge.active, false);
+	});
+
+	it("loads custom instructions from instructionFile", () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-native-intercom-bridge-test-"));
+		const instructionFile = path.join(tempDir, "bridge.md");
+		fs.writeFileSync(instructionFile, "Custom bridge for {orchestratorTarget}\nUse ask then send.");
+		try {
+			const bridge = resolveIntercomBridge({
+				config: { mode: "always", instructionFile },
+				context: "fresh",
+				orchestratorTarget: "main",
+			});
+			assert.equal(bridge.active, true);
+			assert.match(bridge.instruction, /Custom bridge for main/);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("uses stronger default instructions for fork-aware coordination", () => {
+		const bridge = resolveIntercomBridge({
+			config: { mode: "always" },
+			context: "fork",
+			orchestratorTarget: "main",
+		});
+		assert.equal(bridge.active, true);
+		assert.match(bridge.instruction, /reference-only/i);
+		assert.match(bridge.instruction, /normal assistant text/i);
+		assert.match(bridge.instruction, /contact_supervisor/);
+		assert.match(bridge.instruction, /need_decision/);
+		assert.match(bridge.instruction, /progress_update/);
+		assert.match(bridge.instruction, /focused task result/i);
+	});
+});
+
+describe("applyIntercomBridgeToAgent", () => {
+	const activeBridge: IntercomBridgeState = {
+		active: true,
+		mode: "always",
+		orchestratorTarget: "main",
+		extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
+		instruction: "Intercom orchestration channel:\n- Need a decision or blocked: contact_supervisor({ reason: \"need_decision\", message: \"<question>\" })\n- Blocked/update: contact_supervisor({ reason: \"progress_update\", message: \"UPDATE: <summary>\" })",
+	};
+
+	it("injects intercom tool and prompt instructions", () => {
+		const updated = applyIntercomBridgeToAgent(makeAgent({ tools: ["read", "bash"] }), activeBridge);
+		assert.deepEqual(updated.tools, ["read", "bash", "intercom", "contact_supervisor"]);
+		assert.match(updated.systemPrompt, /Intercom orchestration channel:/);
+		assert.match(updated.systemPrompt, /contact_supervisor/);
+	});
+
+	it("is idempotent", () => {
+		const first = applyIntercomBridgeToAgent(makeAgent({ tools: ["read"] }), activeBridge);
+		const second = applyIntercomBridgeToAgent(first, activeBridge);
+		assert.equal(second.tools?.filter((tool) => tool === "intercom").length, 1);
+		assert.equal(second.tools?.filter((tool) => tool === "contact_supervisor").length, 1);
+		assert.equal(second.systemPrompt, first.systemPrompt);
+	});
+
+	it("does not block native supervisor tools for agents with explicit extension allowlists", () => {
+		const agent = makeAgent({ tools: ["read"], extensions: ["/tmp/other-extension/index.ts"] });
+		const updated = applyIntercomBridgeToAgent(agent, activeBridge);
+		assert.deepEqual(updated.tools, ["read", "intercom", "contact_supervisor"]);
+		assert.match(updated.systemPrompt, /contact_supervisor/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/jsonl-writer.test.ts

@@ -0,0 +1,119 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createJsonlWriter, type DrainableSource, type JsonlWriteStream } from "../../src/shared/jsonl-writer.ts";
+
+class MockSource implements DrainableSource {
+	paused = 0;
+	resumed = 0;
+	pause(): void {
+		this.paused++;
+	}
+	resume(): void {
+		this.resumed++;
+	}
+}
+
+class MockStream implements JsonlWriteStream {
+	writes: string[] = [];
+	ended = false;
+	private drainHandler?: () => void;
+	private readonly writeResults: boolean[];
+	constructor(writeResults: boolean[] = []) {
+		this.writeResults = writeResults;
+	}
+	write(chunk: string): boolean {
+		this.writes.push(chunk);
+		if (this.writeResults.length === 0) return true;
+		return this.writeResults.shift() ?? true;
+	}
+	once(event: "drain", listener: () => void): JsonlWriteStream {
+		if (event === "drain") this.drainHandler = listener;
+		return this;
+	}
+	end(callback?: () => void): void {
+		this.ended = true;
+		callback?.();
+	}
+	emitDrain(): void {
+		this.drainHandler?.();
+	}
+}
+
+describe("createJsonlWriter", () => {
+	it("writes lines with trailing newline", () => {
+		const source = new MockSource();
+		const stream = new MockStream();
+		const writer = createJsonlWriter("/tmp/out.jsonl", source, {
+			createWriteStream: () => stream,
+		});
+		writer.writeLine('{"type":"a"}');
+		writer.writeLine('{"type":"b"}');
+		assert.deepEqual(stream.writes, ['{"type":"a"}\n', '{"type":"b"}\n']);
+	});
+
+	it("pauses on backpressure and resumes on drain", () => {
+		const source = new MockSource();
+		const stream = new MockStream([false, true]);
+		const writer = createJsonlWriter("/tmp/out.jsonl", source, {
+			createWriteStream: () => stream,
+		});
+		writer.writeLine('{"type":"a"}');
+		assert.equal(source.paused, 1);
+		assert.equal(source.resumed, 0);
+		stream.emitDrain();
+		assert.equal(source.resumed, 1);
+		writer.writeLine('{"type":"b"}');
+		assert.deepEqual(stream.writes, ['{"type":"a"}\n', '{"type":"b"}\n']);
+	});
+
+	it("closes stream once", async () => {
+		const source = new MockSource();
+		const stream = new MockStream();
+		const writer = createJsonlWriter("/tmp/out.jsonl", source, {
+			createWriteStream: () => stream,
+		});
+		await writer.close();
+		assert.equal(stream.ended, true);
+		await writer.close();
+		assert.equal(stream.ended, true);
+	});
+
+	it("returns no-op writer when file path is undefined", async () => {
+		const source = new MockSource();
+		const writer = createJsonlWriter(undefined, source);
+		writer.writeLine('{"type":"a"}');
+		await writer.close();
+		assert.equal(source.paused, 0);
+		assert.equal(source.resumed, 0);
+	});
+
+	it("stops writing when maxBytes exceeded without pausing source", () => {
+		const source = new MockSource();
+		const stream = new MockStream();
+		const writer = createJsonlWriter("/tmp/out.jsonl", source, {
+			createWriteStream: () => stream,
+			maxBytes: 30,
+		});
+		writer.writeLine('{"type":"a"}');
+		writer.writeLine('{"type":"b"}');
+		writer.writeLine('{"type":"c"}');
+		assert.equal(stream.writes.length, 2);
+		assert.deepEqual(stream.writes, ['{"type":"a"}\n', '{"type":"b"}\n']);
+		assert.equal(source.paused, 0);
+	});
+
+	it("allows writes up to exactly maxBytes", () => {
+		const source = new MockSource();
+		const stream = new MockStream();
+		const line = '{"x":"a"}';
+		const lineBytes = Buffer.byteLength(`${line}\n`, "utf-8");
+		const writer = createJsonlWriter("/tmp/out.jsonl", source, {
+			createWriteStream: () => stream,
+			maxBytes: lineBytes * 2,
+		});
+		writer.writeLine(line);
+		writer.writeLine(line);
+		writer.writeLine(line);
+		assert.equal(stream.writes.length, 2);
+	});
+});