@selesai/code 0.3.0 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/package-manifest.test.ts

@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+const sourceImportPattern = /from\s+["'](@earendil-works\/[^"']+)["']|import\s+["'](@earendil-works\/[^"']+)["']/g;
+const oldPiScopePattern = /@mariozechner\/pi-/;
+const piPackageJsonSubpathPattern = /@earendil-works\/pi-[^"']+\/package\.json/;
+const cjsPiPackageResolutionPattern = /require(?:\.resolve)?\(\s*["']@earendil-works\/pi-/;
+const exactVersionPattern = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+
+function collectTsFiles(dir: string): string[] {
+	const files: string[] = [];
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const entryPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			collectTsFiles(entryPath).forEach((file) => files.push(file));
+		} else if (entry.name.endsWith(".ts")) {
+			files.push(entryPath);
+		}
+	}
+	return files;
+}
+
+test("direct @earendil-works runtime imports are declared for CI installs", () => {
+	const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8"));
+	const declared = new Set([
+		...Object.keys(packageJson.dependencies ?? {}),
+		...Object.keys(packageJson.devDependencies ?? {}),
+	]);
+	const imported = new Set<string>();
+
+	for (const file of [...collectTsFiles(path.join(projectRoot, "src")), ...collectTsFiles(path.join(projectRoot, "test"))]) {
+		const source = fs.readFileSync(file, "utf-8");
+		for (const match of source.matchAll(sourceImportPattern)) {
+			imported.add(match[1] ?? match[2]!);
+		}
+	}
+
+	const missing = [...imported].filter((specifier) => !declared.has(specifier)).sort();
+	assert.deepEqual(missing, []);
+});
+
+test("direct dependency declarations are exact version pins", () => {
+	const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8"));
+
+	for (const section of ["dependencies", "devDependencies"] as const) {
+		for (const [name, version] of Object.entries<string>(packageJson[section] ?? {})) {
+			assert.match(version, exactVersionPattern, `${section}.${name} should use an exact version`);
+		}
+	}
+});
+
+test("old pi package scope is not used by source or tests", () => {
+	for (const file of [...collectTsFiles(path.join(projectRoot, "src")), ...collectTsFiles(path.join(projectRoot, "test"))]) {
+		const source = fs.readFileSync(file, "utf-8");
+		assert.equal(oldPiScopePattern.test(source), false, file);
+	}
+});
+
+test("Pi package resolution stays export-map safe", () => {
+	for (const file of [...collectTsFiles(path.join(projectRoot, "src")), ...collectTsFiles(path.join(projectRoot, "test"))]) {
+		const source = fs.readFileSync(file, "utf-8");
+		assert.equal(piPackageJsonSubpathPattern.test(source), false, `${file} should not resolve unexported package.json subpaths`);
+		assert.equal(cjsPiPackageResolutionPattern.test(source), false, `${file} should not use CommonJS resolution for ESM-only Pi packages`);
+	}
+});

package/dist/extensions/pi-subagents/test/unit/parallel-utils.test.ts

@@ -0,0 +1,247 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+	isParallelGroup,
+	flattenSteps,
+	mapConcurrent,
+	aggregateParallelOutputs,
+	MAX_PARALLEL_CONCURRENCY,
+	DEFAULT_GLOBAL_CONCURRENCY_LIMIT,
+	Semaphore,
+	type RunnerSubagentStep,
+	type ParallelStepGroup,
+	type RunnerStep,
+} from "../../src/runs/shared/parallel-utils.ts";
+
+describe("isParallelGroup", () => {
+	it("returns true for a parallel step group", () => {
+		const step: ParallelStepGroup = {
+			parallel: [
+				{ agent: "a", task: "do stuff" },
+				{ agent: "b", task: "do other stuff" },
+			],
+		};
+		assert.equal(isParallelGroup(step), true);
+	});
+
+	it("returns false for a sequential step", () => {
+		const step: RunnerSubagentStep = { agent: "a", task: "do stuff" };
+		assert.equal(isParallelGroup(step), false);
+	});
+
+	it("returns false when parallel is not an array", () => {
+		const step = { parallel: "not-an-array", agent: "a", task: "x" } as unknown as RunnerStep;
+		assert.equal(isParallelGroup(step), false);
+	});
+});
+
+describe("flattenSteps", () => {
+	it("returns sequential steps unchanged", () => {
+		const steps: RunnerStep[] = [
+			{ agent: "a", task: "t1" },
+			{ agent: "b", task: "t2" },
+		];
+		const flat = flattenSteps(steps);
+		assert.equal(flat.length, 2);
+		assert.equal(flat[0].agent, "a");
+		assert.equal(flat[1].agent, "b");
+	});
+
+	it("expands parallel groups into individual steps", () => {
+		const steps: RunnerStep[] = [
+			{ agent: "scout", task: "find info" },
+			{
+				parallel: [
+					{ agent: "reviewer-a", task: "review part 1" },
+					{ agent: "reviewer-b", task: "review part 2" },
+				],
+			},
+			{ agent: "summarizer", task: "combine" },
+		];
+		const flat = flattenSteps(steps);
+		assert.equal(flat.length, 4);
+		assert.deepEqual(
+			flat.map((s) => s.agent),
+			["scout", "reviewer-a", "reviewer-b", "summarizer"],
+		);
+	});
+
+	it("handles empty steps array", () => {
+		assert.deepEqual(flattenSteps([]), []);
+	});
+
+	it("handles empty parallel group", () => {
+		const steps: RunnerStep[] = [
+			{ agent: "before", task: "x" },
+			{ parallel: [] },
+			{ agent: "after", task: "y" },
+		];
+		const flat = flattenSteps(steps);
+		assert.equal(flat.length, 2);
+		assert.deepEqual(flat.map((s) => s.agent), ["before", "after"]);
+	});
+});
+
+describe("mapConcurrent", () => {
+	it("processes all items and preserves order", async () => {
+		const items = [10, 20, 30, 40];
+		const results = await mapConcurrent(items, 2, async (item) => item * 2);
+		assert.deepEqual(results, [20, 40, 60, 80]);
+	});
+
+	it("respects concurrency limit", async () => {
+		let running = 0;
+		let maxRunning = 0;
+		const items = [1, 2, 3, 4, 5, 6];
+
+		await mapConcurrent(items, 2, async () => {
+			running++;
+			maxRunning = Math.max(maxRunning, running);
+			await new Promise((r) => setTimeout(r, 10));
+			running--;
+		});
+
+		assert.ok(maxRunning <= 2, `max concurrent was ${maxRunning}, expected <= 2`);
+	});
+
+	it("handles empty input", async () => {
+		const results = await mapConcurrent([], 4, async (item: number) => item);
+		assert.deepEqual(results, []);
+	});
+
+	it("clamps limit=0 to 1 (sequential execution)", async () => {
+		let running = 0;
+		let maxRunning = 0;
+		const items = [1, 2, 3];
+		await mapConcurrent(items, 0, async (item) => {
+			running++;
+			maxRunning = Math.max(maxRunning, running);
+			await new Promise((r) => setTimeout(r, 10));
+			running--;
+			return item * 10;
+		});
+		assert.equal(maxRunning, 1, "should run sequentially with limit=0");
+	});
+
+	it("clamps limit=-1 to 1 (sequential execution)", async () => {
+		let running = 0;
+		let maxRunning = 0;
+		const items = [1, 2, 3];
+		await mapConcurrent(items, -1, async (item) => {
+			running++;
+			maxRunning = Math.max(maxRunning, running);
+			await new Promise((r) => setTimeout(r, 10));
+			running--;
+			return item * 10;
+		});
+		assert.equal(maxRunning, 1, "should run sequentially with limit=-1");
+	});
+
+	it("does not stagger by default", async () => {
+		const startTimes: number[] = [];
+		const items = [1, 2, 3];
+
+		await mapConcurrent(items, 3, async (_item, i) => {
+			startTimes[i] = Date.now();
+			await new Promise((r) => setTimeout(r, 10));
+		});
+
+		// All workers should start nearly simultaneously
+		const d1 = startTimes[1]! - startTimes[0]!;
+		const d2 = startTimes[2]! - startTimes[0]!;
+		assert.ok(d1 < 20, `worker 1 should start immediately, got ${d1}ms delay`);
+		assert.ok(d2 < 20, `worker 2 should start immediately, got ${d2}ms delay`);
+	});
+
+	it("respects a shared global semaphore across simultaneous calls", async () => {
+		const globalSemaphore = new Semaphore(2);
+		let running = 0;
+		let maxRunning = 0;
+		const run = (items: number[]) => mapConcurrent(items, items.length, async (item) => {
+			running++;
+			maxRunning = Math.max(maxRunning, running);
+			await new Promise((r) => setTimeout(r, 10));
+			running--;
+			return item;
+		}, globalSemaphore);
+
+		const results = await Promise.all([
+			run([1, 2, 3]),
+			run([4, 5, 6]),
+		]);
+
+		assert.deepEqual(results, [[1, 2, 3], [4, 5, 6]]);
+		assert.ok(maxRunning <= 2, `max concurrent was ${maxRunning}, expected <= 2`);
+	});
+
+	it("clamps invalid global semaphore limits to 1", async () => {
+		const globalSemaphore = new Semaphore(0);
+		let running = 0;
+		let maxRunning = 0;
+
+		await mapConcurrent([1, 2, 3], 3, async (item) => {
+			running++;
+			maxRunning = Math.max(maxRunning, running);
+			await new Promise((r) => setTimeout(r, 10));
+			running--;
+			return item;
+		}, globalSemaphore);
+
+		assert.equal(maxRunning, 1);
+	});
+});
+
+describe("DEFAULT_GLOBAL_CONCURRENCY_LIMIT", () => {
+	it("is 20", () => {
+		assert.equal(DEFAULT_GLOBAL_CONCURRENCY_LIMIT, 20);
+	});
+});
+
+describe("aggregateParallelOutputs", () => {
+	it("aggregates successful outputs with headers", () => {
+		const result = aggregateParallelOutputs([
+			{ agent: "reviewer-a", output: "Looks good", exitCode: 0 },
+			{ agent: "reviewer-b", output: "Needs fixes", exitCode: 0 },
+		]);
+		assert.ok(result.includes("=== Parallel Task 1 (reviewer-a) ==="));
+		assert.ok(result.includes("Looks good"));
+		assert.ok(result.includes("=== Parallel Task 2 (reviewer-b) ==="));
+		assert.ok(result.includes("Needs fixes"));
+	});
+
+	it("marks failed tasks", () => {
+		const result = aggregateParallelOutputs([
+			{ agent: "agent-a", output: "partial output", exitCode: 1 },
+		]);
+		assert.ok(result.includes("FAILED (exit code 1)"));
+	});
+
+	it("marks empty output", () => {
+		const result = aggregateParallelOutputs([
+			{ agent: "agent-a", output: "", exitCode: 0 },
+		]);
+		assert.ok(result.includes("EMPTY OUTPUT"));
+	});
+
+	it("treats whitespace-only output as empty", () => {
+		const result = aggregateParallelOutputs([
+			{ agent: "agent-a", output: "   \n  ", exitCode: 0 },
+		]);
+		assert.ok(result.includes("EMPTY OUTPUT"));
+	});
+
+	it("marks skipped tasks (exitCode=-1) distinctly from failed", () => {
+		const result = aggregateParallelOutputs([
+			{ agent: "agent-a", output: "done", exitCode: 0 },
+			{ agent: "agent-b", output: "(skipped — fail-fast)", exitCode: -1 },
+		]);
+		assert.ok(result.includes("SKIPPED"), "skipped task should show SKIPPED");
+		assert.ok(!result.includes("FAILED"), "skipped task should not show FAILED");
+	});
+});
+
+describe("MAX_PARALLEL_CONCURRENCY", () => {
+	it("is 4", () => {
+		assert.equal(MAX_PARALLEL_CONCURRENCY, 4);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/path-handling.test.ts

@@ -0,0 +1,113 @@
+import assert from "node:assert/strict";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+
+/**
+ * Tests for cross-platform path handling patterns used throughout the codebase.
+ * These tests document the correct patterns after fixes were applied.
+ *
+ * Fixed locations:
+ * - chain-execution.ts — uses path.isAbsolute() for absolute path detection
+ * - settings.ts — uses path.join() for path construction
+ */
+
+describe("path.isAbsolute vs startsWith('/')", () => {
+	// chain-execution.ts:496 uses startsWith("/") to detect absolute paths.
+	// On Windows, absolute paths look like "C:\\..." or "C:/..." — neither starts with "/".
+
+	it("startsWith('/') misses Windows absolute paths", () => {
+		const windowsAbsolute = "C:\\dev\\pi-subagents\\output.md";
+		const windowsAbsoluteForward = "C:/dev/pi-subagents/output.md";
+
+		// This is what the current code does (chain-execution.ts:496):
+		assert.equal(windowsAbsolute.startsWith("/"), false,
+			"Windows backslash absolute path not detected by startsWith('/')");
+		assert.equal(windowsAbsoluteForward.startsWith("/"), false,
+			"Windows forward-slash absolute path not detected by startsWith('/')");
+
+		// This is what the code SHOULD do:
+		assert.equal(path.isAbsolute(windowsAbsolute), process.platform === "win32",
+			"path.isAbsolute correctly identifies Windows paths on Windows");
+		assert.equal(path.isAbsolute(windowsAbsoluteForward), process.platform === "win32",
+			"path.isAbsolute correctly identifies forward-slash Windows paths on Windows");
+
+		// POSIX paths work with both approaches
+		assert.equal("/home/user/output.md".startsWith("/"), true);
+		assert.equal(path.isAbsolute("/home/user/output.md"), true);
+	});
+
+	it("path.isAbsolute is the correct cross-platform check", () => {
+		// Relative paths — both approaches agree
+		assert.equal(path.isAbsolute("output.md"), false);
+		assert.equal(path.isAbsolute("subdir/output.md"), false);
+		assert.equal("output.md".startsWith("/"), false);
+
+		// The only platform-safe check for absolute paths is path.isAbsolute()
+		if (process.platform === "win32") {
+			// On Windows, these are absolute:
+			assert.equal(path.isAbsolute("C:\\output.md"), true);
+			assert.equal(path.isAbsolute("C:/output.md"), true);
+			assert.equal(path.isAbsolute("\\\\server\\share"), true); // UNC
+			// But startsWith("/") catches none of them
+			assert.equal("C:\\output.md".startsWith("/"), false);
+			assert.equal("C:/output.md".startsWith("/"), false);
+		}
+	});
+});
+
+describe("path.join vs template string concatenation", () => {
+	// settings.ts uses `${chainDir}/${file}` in several places.
+	// This works but produces inconsistent separators on Windows.
+
+	it("template concatenation produces forward slashes regardless of platform", () => {
+		// chain-execution.ts:496 uses startsWith("/") to detect absolute paths.
+		const chainDir = "C:\\Users\\marc\\temp\\chain-abc";
+		const file = "progress.md";
+
+		// Template string: always forward slash
+		const templateResult = `${chainDir}/${file}`;
+		assert.equal(templateResult, "C:\\Users\\marc\\temp\\chain-abc/progress.md",
+			"template string produces mixed separators");
+
+		// path.join: uses platform separator
+		const joinResult = path.join(chainDir, file);
+		if (process.platform === "win32") {
+			assert.equal(joinResult, "C:\\Users\\marc\\temp\\chain-abc\\progress.md",
+				"path.join uses consistent backslashes on Windows");
+		}
+	});
+
+	it("resolveChainPath pattern should use path.join for relative paths", () => {
+		// settings.ts:216: `${chainDir}/${filePath}` for relative paths
+		const chainDir = "C:\\temp\\chain-runs\\abc123";
+		const relative = "synthesis.md";
+
+		// Current: string concat
+		const current = `${chainDir}/${relative}`;
+		// Fixed: path.join
+		const fixed = path.join(chainDir, relative);
+
+		// On Windows these differ:
+		if (process.platform === "win32") {
+			assert.notEqual(current, fixed, "concat and path.join produce different results on Windows");
+			assert.ok(fixed.includes(path.sep), "path.join uses native separator");
+		}
+	});
+
+	it("parallel subdir naming should use path.join", () => {
+		// settings.ts:302,306 pattern: `${subdir}/${task.output}`
+		const subdir = "parallel-0/0-_code-reviewer";
+		const output = "review.md";
+
+		const templateResult = `${subdir}/${output}`;
+		const joinResult = path.join(subdir, output);
+
+		// Both produce forward slashes here (subdir itself uses /).
+		// But if subdir comes from path.join on Windows, it would have backslashes.
+		const windowsSubdir = path.join("parallel-0", "0-_code-reviewer");
+		const windowsJoin = path.join(windowsSubdir, output);
+		// Consistent: all native separators
+		assert.equal(windowsJoin, path.join("parallel-0", "0-_code-reviewer", output));
+	});
+});
+

package/dist/extensions/pi-subagents/test/unit/path-resolution.test.ts

@@ -0,0 +1,94 @@
+import { describe, test, before, after } from "node:test";
+import * as assert from "node:assert";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { discoverAgents } from "../../src/agents/agents.ts";
+import { resolveSkillPath, clearSkillCache } from "../../src/agents/skills.ts";
+
+const tmpDir = path.join(os.tmpdir(), "pi-path-resolution-test");
+const cwdDir = path.join(tmpDir, "cwd");
+
+const realHomeDir = os.homedir();
+const realUserAgentsDir = path.join(realHomeDir, ".agents");
+const userAgentsDirBackup = path.join(tmpDir, ".agents_backup");
+
+before(() => {
+	fs.mkdirSync(cwdDir, { recursive: true });
+
+	if (fs.existsSync(realUserAgentsDir)) {
+		fs.cpSync(realUserAgentsDir, userAgentsDirBackup, { recursive: true });
+	}
+});
+
+after(() => {
+	if (fs.existsSync(userAgentsDirBackup)) {
+		fs.rmSync(realUserAgentsDir, { recursive: true, force: true });
+		fs.cpSync(userAgentsDirBackup, realUserAgentsDir, { recursive: true });
+	} else {
+		fs.rmSync(realUserAgentsDir, { recursive: true, force: true });
+	}
+	fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("Path resolution for .agents and ~/.agents", () => {
+	test("should resolve skills in .agents/skills", () => {
+		const skillsDir = path.join(cwdDir, ".agents", "skills");
+		fs.mkdirSync(skillsDir, { recursive: true });
+		fs.writeFileSync(path.join(skillsDir, "test-skill-1.md"), "---\nname: test-skill-1\ndescription: test desc\n---\nSkill content");
+
+		clearSkillCache();
+		const resolved = resolveSkillPath("test-skill-1", cwdDir);
+		assert.ok(resolved);
+		assert.strictEqual(resolved?.path, path.join(skillsDir, "test-skill-1.md"));
+	});
+
+	test("should resolve skills in ~/.agents/skills", () => {
+		const userSkillsDir = path.join(realHomeDir, ".agents", "skills");
+		fs.mkdirSync(userSkillsDir, { recursive: true });
+		fs.writeFileSync(path.join(userSkillsDir, "test-skill-2.md"), "---\nname: test-skill-2\ndescription: test desc\n---\nSkill content");
+
+		clearSkillCache();
+		const resolved = resolveSkillPath("test-skill-2", cwdDir);
+		assert.ok(resolved);
+		assert.strictEqual(resolved?.path, path.join(userSkillsDir, "test-skill-2.md"));
+	});
+
+	test("should resolve project agents from both .agents and .pi/agents", () => {
+		const legacyDir = path.join(cwdDir, ".agents");
+		const agentsDir = path.join(cwdDir, ".selesai", "agents");
+		fs.mkdirSync(path.join(cwdDir, ".agents", "skills"), { recursive: true });
+		fs.mkdirSync(legacyDir, { recursive: true });
+		fs.mkdirSync(agentsDir, { recursive: true });
+		fs.writeFileSync(
+			path.join(legacyDir, "test-agent-legacy.md"),
+			"---\nname: test-agent-legacy\ndescription: Legacy agent\n---\nLegacy content"
+		);
+		fs.writeFileSync(
+			path.join(agentsDir, "test-agent-1.md"),
+			"---\nname: test-agent-1\ndescription: Test agent\n---\nAgent content"
+		);
+
+		const result = discoverAgents(cwdDir, "project");
+		const legacyAgent = result.agents.find((a) => a.name === "test-agent-legacy");
+		const agent = result.agents.find((a) => a.name === "test-agent-1");
+		assert.ok(legacyAgent);
+		assert.strictEqual(legacyAgent?.filePath, path.join(legacyDir, "test-agent-legacy.md"));
+		assert.ok(agent);
+		assert.strictEqual(agent?.filePath, path.join(agentsDir, "test-agent-1.md"));
+	});
+
+	test("should resolve agents in ~/.agents", () => {
+		const userAgentsDir = path.join(realHomeDir, ".agents");
+		fs.mkdirSync(userAgentsDir, { recursive: true });
+		fs.writeFileSync(
+			path.join(userAgentsDir, "test-agent-2.md"),
+			"---\nname: test-agent-2\ndescription: Test agent\n---\nAgent content"
+		);
+
+		const result = discoverAgents(cwdDir, "user");
+		const agent = result.agents.find((a) => a.name === "test-agent-2");
+		assert.ok(agent);
+		assert.strictEqual(agent?.filePath, path.join(userAgentsDir, "test-agent-2.md"));
+	});
+});