@selesai/code 0.2.1 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/dynamic-fanout.test.ts

@@ -0,0 +1,217 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { ChainOutputValidationError, validateChainOutputBindings, validateChainOutputBindingsWithContext } from "../../src/runs/shared/chain-outputs.ts";
+import {
+	DynamicFanoutError,
+	collectDynamicResults,
+	materializeDynamicParallelStep,
+	resolveJsonPointer,
+	validateDynamicCollection,
+	validateDynamicStepShape,
+} from "../../src/runs/shared/dynamic-fanout.ts";
+import type { ChainStep } from "../../src/shared/settings.ts";
+import type { ChainOutputMap, SingleResult } from "../../src/shared/types.ts";
+
+const outputs: ChainOutputMap = {
+	targets: {
+		text: "{\"items\":[{\"path\":\"src/a.ts\"},{\"path\":\"src/b.ts\"}]}",
+		structured: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] },
+		agent: "scout",
+		stepIndex: 0,
+	},
+};
+
+describe("dynamic fanout helpers", () => {
+	it("resolves JSON Pointers and materializes item templates", () => {
+		assert.deepEqual(resolveJsonPointer({ items: [1, 2] }, "/items/1", "path"), 2);
+		const step: ChainStep = {
+			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
+			parallel: { agent: "reviewer", task: "Review {target.path}", label: "Review {target.path}" },
+			collect: { as: "reviews" },
+		};
+		const materialized = materializeDynamicParallelStep(step, outputs, 1);
+		assert.deepEqual(materialized.items.map((item) => item.key), ["src/a.ts", "src/b.ts"]);
+		assert.deepEqual(materialized.parallel.map((task) => task.task), ["Review src/a.ts", "Review src/b.ts"]);
+		assert.deepEqual(materialized.parallel.map((task) => task.label), ["Review src/a.ts", "Review src/b.ts"]);
+	});
+
+	it("rejects missing structured sources, over-limit arrays, duplicate keys, colliding ids, and bad templates", () => {
+		const base: ChainStep = {
+			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
+			parallel: { agent: "reviewer", task: "Review {target.path}" },
+			collect: { as: "reviews" },
+		};
+		assert.throws(
+			() => materializeDynamicParallelStep({ ...base, expand: { ...base.expand, maxItems: 1 } }, outputs, 1),
+			/exceeding maxItems/,
+		);
+		assert.throws(
+			() => materializeDynamicParallelStep(base, { targets: { text: "plain", agent: "scout", stepIndex: 0 } }, 1),
+			/requires structured output/,
+		);
+		assert.throws(
+			() => materializeDynamicParallelStep(base, { targets: { ...outputs.targets, structured: { items: [{ path: "x" }, { path: "x" }] } } }, 1),
+			/duplicate item key/,
+		);
+		assert.throws(
+			() => materializeDynamicParallelStep(base, { targets: { ...outputs.targets, structured: { items: [{ path: "a/b" }, { path: "a-b" }] } } }, 1),
+			/colliding item id/,
+		);
+		assert.throws(
+			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {other.path}" } }, outputs, 1),
+			/Unsupported template reference/,
+		);
+		assert.throws(
+			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {target[path]}" } }, outputs, 1),
+			/Invalid item reference/,
+		);
+		assert.throws(
+			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {target.path" } }, outputs, 1),
+			/Invalid item reference/,
+		);
+	});
+
+	it("allows config maxItems defaults and handles empty arrays deterministically", () => {
+		const base: ChainStep = {
+			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path" },
+			parallel: { agent: "reviewer", task: "Review {target.path}" },
+			collect: { as: "reviews" },
+		};
+		const materialized = materializeDynamicParallelStep(base, outputs, 1, { maxItems: 4 });
+		assert.equal(materialized.parallel.length, 2);
+		assert.doesNotThrow(() => validateChainOutputBindings([
+			{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+			base,
+		], { maxItems: 4 }));
+		const empty = materializeDynamicParallelStep(base, { targets: { ...outputs.targets, structured: { items: [] } } }, 1, { maxItems: 4 });
+		assert.equal(empty.parallel.length, 0);
+		assert.throws(
+			() => materializeDynamicParallelStep({ ...base, expand: { ...base.expand, onEmpty: "fail" } }, { targets: { ...outputs.targets, structured: { items: [] } } }, 1, { maxItems: 4 }),
+			/source array is empty/,
+		);
+	});
+
+	it("rejects malformed dynamic-like shapes before they can run as static parallel", () => {
+		const malformed = [
+			{
+				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+				parallel: [{ agent: "reviewer", task: "Review" }],
+				collect: { as: "reviews" },
+			},
+			{
+				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+				parallel: { agent: "reviewer", task: "Review {item.path}" },
+			},
+			{
+				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+				parallel: { agent: "reviewer", task: "Review {item.path}" },
+				collect: { as: "reviews" },
+				when: "later",
+			},
+			{
+				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+				parallel: { agent: "reviewer", task: "Review {item.path}", as: "child" },
+				collect: { as: "reviews" },
+			},
+		] as ChainStep[];
+
+		for (const step of malformed) {
+			assert.throws(
+				() => validateChainOutputBindings([{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } }, step]),
+				ChainOutputValidationError,
+			);
+		}
+	});
+
+	it("accepts a runner-injected parentSessionId on the parallel template but keeps it out of user-facing validation", () => {
+		// Regression: the async runner threads parentSessionId onto the dynamic parallel
+		// template for permission-system forwarding. It must pass runner-internal validation
+		// (allowRunnerFields) without leaking into the user-facing dynamic field whitelist.
+		const runnerStep = {
+			expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+			parallel: { agent: "reviewer", task: "Review {item.path}", parentSessionId: "session-parent" },
+			collect: { as: "reviews" },
+		} as unknown as Parameters<typeof validateDynamicStepShape>[0];
+		assert.doesNotThrow(() => validateDynamicStepShape(runnerStep, 1, { allowRunnerFields: true }));
+		assert.throws(
+			() => validateDynamicStepShape(runnerStep, 1),
+			(error: unknown) => error instanceof DynamicFanoutError && /parentSessionId/.test(error.message),
+		);
+	});
+
+	it("accepts toolBudget on dynamic parallel templates", () => {
+		const step = {
+			expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+			parallel: { agent: "reviewer", task: "Review {item.path}", toolBudget: { hard: 3 } },
+			collect: { as: "reviews" },
+		} as unknown as Parameters<typeof validateDynamicStepShape>[0];
+
+		assert.doesNotThrow(() => validateDynamicStepShape(step, 1));
+	});
+
+	it("validates source ordering and collect name collisions", () => {
+		const chain: ChainStep[] = [
+			{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+			{
+				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+				parallel: { agent: "reviewer", task: "Review {item.path}" },
+				collect: { as: "targets" },
+			},
+		];
+		assert.throws(() => validateChainOutputBindings(chain), ChainOutputValidationError);
+		assert.throws(
+			() => validateChainOutputBindings([chain[1]!]),
+			/unknown output 'targets'/,
+		);
+	});
+
+	it("validates appended steps against prior and reserved output names", () => {
+		assert.doesNotThrow(() => validateChainOutputBindingsWithContext([
+			{ agent: "worker", task: "Use {outputs.targets}", as: "summary" },
+		], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }));
+		assert.throws(
+			() => validateChainOutputBindingsWithContext([
+				{ agent: "worker", task: "Use {outputs.missing}" },
+			], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }),
+			/Unknown chain output reference '\{outputs\.missing\}' at step 3/,
+		);
+		assert.throws(
+			() => validateChainOutputBindingsWithContext([
+				{ agent: "worker", task: "Use {previous}", as: "targets" },
+			], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }),
+			/Duplicate chain output name 'targets'/,
+		);
+		assert.doesNotThrow(() => validateChainOutputBindingsWithContext([
+			{
+				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+				parallel: { agent: "reviewer", task: "Review {item.path}" },
+				collect: { as: "reviews" },
+			},
+		], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }));
+	});
+
+	it("collects ordered child result records and validates aggregate schema", () => {
+		const step: ChainStep = {
+			expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
+			parallel: { agent: "reviewer", task: "Review {item.path}" },
+			collect: { as: "reviews" },
+		};
+		const materialized = materializeDynamicParallelStep(step, outputs, 1);
+		const result = (agent: string, structuredOutput: unknown): SingleResult => ({
+			agent,
+			task: "t",
+			exitCode: 0,
+			messages: [],
+			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+			finalOutput: "ok",
+			structuredOutput,
+		});
+		const timedOut = { ...result("reviewer", { ok: "b" }), exitCode: 1, error: "Subagent timed out after 300ms.", timedOut: true };
+		const collected = collectDynamicResults(step, materialized.items, [result("reviewer", { ok: "a" }), timedOut]);
+		assert.deepEqual(collected.map((item) => item.key), ["src/a.ts", "src/b.ts"]);
+		assert.deepEqual(collected.map((item) => item.structured), [{ ok: "a" }, { ok: "b" }]);
+		assert.equal(collected[1]?.timedOut, true);
+		assert.doesNotThrow(() => validateDynamicCollection({ type: "array", minItems: 2 }, collected));
+		assert.throws(() => validateDynamicCollection({ type: "object" }, collected), DynamicFanoutError);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/extra-agent-dirs.test.ts

@@ -0,0 +1,88 @@
+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 { afterEach, beforeEach, describe, it } from "node:test";
+import { discoverAgents, discoverAgentsAll, EXTRA_AGENT_DIRS_ENV } from "../../src/agents/agents.ts";
+
+let tempDir = "";
+let agentDir = "";
+let cwd = "";
+const saved: Record<string, string | undefined> = {};
+const MANAGED_ENV = ["SELESAI_CODING_AGENT_DIR", "HOME", "USERPROFILE", EXTRA_AGENT_DIRS_ENV];
+
+function writeAgent(dir: string, name: string): string {
+	const filePath = path.join(dir, `${name}.md`);
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, `---\nname: ${name}\ndescription: ${name} agent\n---\n\nDo ${name} work.\n`, "utf-8");
+	return filePath;
+}
+
+describe("SELESAI_SUBAGENT_EXTRA_AGENT_DIRS discovery", () => {
+	beforeEach(() => {
+		for (const key of MANAGED_ENV) saved[key] = process.env[key];
+		tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-extra-agent-dirs-"));
+		// Isolate from the developer's real user agent dirs so defaults are empty.
+		agentDir = path.join(tempDir, "agent");
+		const homeDir = path.join(tempDir, "home");
+		cwd = path.join(tempDir, "workspace");
+		fs.mkdirSync(cwd, { recursive: true });
+		fs.mkdirSync(homeDir, { recursive: true });
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		process.env.HOME = homeDir;
+		process.env.USERPROFILE = homeDir;
+		delete process.env[EXTRA_AGENT_DIRS_ENV];
+	});
+
+	afterEach(() => {
+		for (const key of MANAGED_ENV) {
+			if (saved[key] === undefined) delete process.env[key];
+			else process.env[key] = saved[key];
+		}
+		fs.rmSync(tempDir, { recursive: true, force: true });
+	});
+
+	it("discovers agents from the env-provided dirs as a 'user' source", () => {
+		const bundledDir = path.join(tempDir, "store", "agents");
+		const bundledAgent = writeAgent(bundledDir, "bundled-reviewer");
+		process.env[EXTRA_AGENT_DIRS_ENV] = bundledDir;
+
+		const scoped = discoverAgents(cwd, "user");
+		const found = scoped.agents.find((agent) => agent.name === "bundled-reviewer");
+		assert.ok(found, "expected bundled agent under 'user' scope");
+		assert.equal(found?.filePath, bundledAgent);
+
+		const all = discoverAgentsAll(cwd);
+		assert.ok(all.user.find((agent) => agent.name === "bundled-reviewer" && agent.filePath === bundledAgent));
+	});
+
+	it("scans every directory listed (PATH-style delimiter)", () => {
+		const dirA = path.join(tempDir, "store-a");
+		const dirB = path.join(tempDir, "store-b");
+		writeAgent(dirA, "agent-a");
+		writeAgent(dirB, "agent-b");
+		process.env[EXTRA_AGENT_DIRS_ENV] = [dirA, dirB].join(path.delimiter);
+
+		const all = discoverAgentsAll(cwd);
+		assert.ok(all.user.find((agent) => agent.name === "agent-a"));
+		assert.ok(all.user.find((agent) => agent.name === "agent-b"));
+	});
+
+	it("lets a local user agent override a bundled one of the same name", () => {
+		const bundledDir = path.join(tempDir, "store", "agents");
+		writeAgent(bundledDir, "shared");
+		const localPath = writeAgent(path.join(agentDir, "agents"), "shared");
+		process.env[EXTRA_AGENT_DIRS_ENV] = bundledDir;
+
+		const scoped = discoverAgents(cwd, "user");
+		const matches = scoped.agents.filter((agent) => agent.name === "shared");
+		assert.equal(matches.length, 1, "name collisions must dedupe");
+		assert.equal(matches[0]?.filePath, localPath, "local user agent should win over bundled");
+	});
+
+	it("ignores the env var when unset or empty", () => {
+		process.env[EXTRA_AGENT_DIRS_ENV] = "";
+		const all = discoverAgentsAll(cwd);
+		assert.deepEqual(all.user, []);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/file-coalescer.test.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createFileCoalescer } from "../../src/shared/file-coalescer.ts";
+
+type TimerTask = { id: number; cb: () => void; delay: number };
+
+function createFakeTimers() {
+	let nextId = 1;
+	const tasks = new Map<number, TimerTask>();
+	return {
+		timerApi: {
+			setTimeout(handler: () => void, delayMs: number): unknown {
+				const id = nextId++;
+				tasks.set(id, { id, cb: handler, delay: delayMs });
+				return id;
+			},
+			clearTimeout(handle: unknown): void {
+				if (typeof handle === "number") tasks.delete(handle);
+			},
+		},
+		runAll(): void {
+			const batch = Array.from(tasks.values()).sort((a, b) => a.id - b.id);
+			tasks.clear();
+			for (const task of batch) task.cb();
+		},
+		pendingCount(): number {
+			return tasks.size;
+		},
+	};
+}
+
+describe("createFileCoalescer", () => {
+	it("coalesces duplicate schedule calls per file", () => {
+		const events: string[] = [];
+		const timers = createFakeTimers();
+		const coalescer = createFileCoalescer((file) => events.push(file), 50, timers.timerApi);
+		assert.equal(coalescer.schedule("a.json"), true);
+		assert.equal(coalescer.schedule("a.json"), false);
+		assert.equal(timers.pendingCount(), 1);
+		timers.runAll();
+		assert.deepEqual(events, ["a.json"]);
+		assert.equal(coalescer.schedule("a.json"), true);
+	});
+
+	it("allows different files to schedule independently", () => {
+		const events: string[] = [];
+		const timers = createFakeTimers();
+		const coalescer = createFileCoalescer((file) => events.push(file), 50, timers.timerApi);
+		coalescer.schedule("a.json");
+		coalescer.schedule("b.json");
+		assert.equal(timers.pendingCount(), 2);
+		timers.runAll();
+		assert.deepEqual(events.sort(), ["a.json", "b.json"]);
+	});
+
+	it("clear cancels all pending handlers", () => {
+		const events: string[] = [];
+		const timers = createFakeTimers();
+		const coalescer = createFileCoalescer((file) => events.push(file), 50, timers.timerApi);
+		coalescer.schedule("a.json");
+		coalescer.schedule("b.json");
+		assert.equal(timers.pendingCount(), 2);
+		coalescer.clear();
+		assert.equal(timers.pendingCount(), 0);
+		timers.runAll();
+		assert.deepEqual(events, []);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/foreground-tool-call-compaction.test.ts

@@ -0,0 +1,78 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { compactForegroundResult, extractToolArgsPreview } from "../../src/shared/utils.ts";
+import { formatToolCall } from "../../src/shared/formatters.ts";
+
+describe("foreground tool-call compaction", () => {
+	it("stores compact tool-call summaries instead of raw message payloads", () => {
+		const result = compactForegroundResult({
+			agent: "tester",
+			task: "run checks",
+			exitCode: 0,
+			messages: [{
+				role: "assistant",
+				content: [{
+					type: "toolCall",
+					name: "write",
+					arguments: {
+						path: "/tmp/report.md",
+						content: "x".repeat(50_000),
+					},
+				}],
+			}],
+			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+		});
+
+		assert.equal(result.messages, undefined);
+		assert.deepEqual(result.toolCalls, [{
+			text: "write /tmp/report.md",
+			expandedText: "write /tmp/report.md",
+		}]);
+	});
+
+	it("keeps expanded generic tool-call previews bounded", () => {
+		const collapsed = formatToolCall("custom", { payload: "x".repeat(500) });
+		const expanded = formatToolCall("custom", { payload: "x".repeat(500) }, true);
+
+		assert.ok(expanded.length > collapsed.length);
+		assert.ok(expanded.length < 200);
+	});
+
+	it("does not keep an empty toolCalls array after compaction", () => {
+		const result = compactForegroundResult({
+			agent: "tester",
+			task: "run checks",
+			exitCode: 0,
+			messages: [],
+			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+		});
+
+		assert.equal(result.toolCalls, undefined);
+	});
+
+	it("formats array-based web search previews clearly", () => {
+		assert.equal(
+			extractToolArgsPreview({
+				queries: ["Chrome native messaging manifest path macOS", "Chromium native messaging path macOS"],
+				workflow: "none",
+			}),
+			"Chrome native messaging manifest path macOS (+1 more)",
+		);
+	});
+
+	it("formats fetch_content urls clearly", () => {
+		assert.equal(
+			extractToolArgsPreview({
+				urls: ["https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging", "https://example.com/backup"],
+			}),
+			"https://developer.chrome.com/docs/extensions/develop/conc...",
+		);
+	});
+
+	it("falls back to generic array previews", () => {
+		assert.equal(
+			extractToolArgsPreview({ ids: ["run-a", "run-b", "run-c"] }),
+			"ids=run-a (+2 more)",
+		);
+	});
+});