@selesai/code 0.3.0 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/pi-coding-agent-dir.test.ts

@@ -0,0 +1,209 @@
+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 { discoverAgentsAll } from "../../src/agents/agents.ts";
+import { handleCreate } from "../../src/agents/agent-management.ts";
+import { clearSkillCache, discoverAvailableSkills, resolveSkillPath } from "../../src/agents/skills.ts";
+import { loadConfig } from "../../src/extension/config.ts";
+import { diagnoseIntercomBridge, resolveIntercomBridge } from "../../src/intercom/intercom-bridge.ts";
+import { loadRunsForAgent, recordRun } from "../../src/runs/shared/run-history.ts";
+import { cleanupAllArtifactDirs } from "../../src/shared/artifacts.ts";
+import { getAgentDir, getConfigDirName, getProjectConfigDir, resolveConfigDirName } from "../../src/shared/utils.ts";
+
+let tempDir = "";
+let agentDir = "";
+let tempHome = "";
+let cwd = "";
+let oldAgentDir: string | undefined;
+let oldHome: string | undefined;
+let oldUserProfile: string | undefined;
+
+function writeFile(filePath: string, content: string): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, content, "utf-8");
+}
+
+function readText(result: { content: Array<{ type: string; text?: string }> }): string {
+	const first = result.content[0];
+	assert.ok(first);
+	assert.equal(first.type, "text");
+	assert.equal(typeof first.text, "string");
+	return first.text;
+}
+
+describe("SELESAI_CODING_AGENT_DIR runtime paths", () => {
+	beforeEach(() => {
+		oldAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		oldHome = process.env.HOME;
+		oldUserProfile = process.env.USERPROFILE;
+		tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-coding-agent-dir-"));
+		tempHome = path.join(tempDir, "home");
+		agentDir = path.join(tempDir, "agent");
+		cwd = path.join(tempDir, "workspace");
+		fs.mkdirSync(cwd, { recursive: true });
+		fs.mkdirSync(tempHome, { recursive: true });
+		process.env.HOME = tempHome;
+		process.env.USERPROFILE = tempHome;
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		clearSkillCache();
+	});
+
+	afterEach(() => {
+		if (oldAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = oldAgentDir;
+		if (oldHome === undefined) delete process.env.HOME;
+		else process.env.HOME = oldHome;
+		if (oldUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = oldUserProfile;
+		clearSkillCache();
+		fs.rmSync(tempDir, { recursive: true, force: true });
+	});
+
+	it("resolves the agent dir dynamically and loads extension config from it", () => {
+		assert.equal(resolveConfigDirName({ CONFIG_DIR_NAME: ".custom-pi" }), ".custom-pi");
+		assert.equal(resolveConfigDirName({ CONFIG_DIR_NAME: "" }), ".selesai");
+		assert.equal(getConfigDirName(), ".selesai");
+		assert.equal(getProjectConfigDir(cwd), path.join(cwd, ".selesai"));
+		assert.equal(getAgentDir(), agentDir);
+
+		process.env.SELESAI_CODING_AGENT_DIR = "~";
+		assert.equal(getAgentDir(), tempHome);
+
+		process.env.SELESAI_CODING_AGENT_DIR = "~/custom-agent-dir";
+		assert.equal(getAgentDir(), path.join(tempHome, "custom-agent-dir"));
+
+		delete process.env.SELESAI_CODING_AGENT_DIR;
+		assert.equal(getAgentDir(), path.join(tempHome, ".selesai", "agent"));
+
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		writeFile(configPath, JSON.stringify({ asyncByDefault: true, maxSubagentDepth: 3 }));
+
+		const config = loadConfig();
+		assert.equal(config.asyncByDefault, true);
+		assert.equal(config.maxSubagentDepth, 3);
+	});
+
+	it("discovers user agents, chains, and settings under the configured agent dir", () => {
+		const settingsPath = path.join(agentDir, "settings.json");
+		writeFile(path.join(agentDir, "agents", "env-agent.md"), `---
+name: env-agent
+description: Env agent
+---
+
+Use env agent.
+`);
+		writeFile(path.join(agentDir, "chains", "env-chain.chain.md"), `---
+name: env-chain
+description: Env chain
+---
+
+## env-agent
+
+Inspect env.
+`);
+		writeFile(settingsPath, JSON.stringify({
+			subagents: {
+				agentOverrides: {
+					worker: { systemPrompt: "Use env-rooted settings." },
+				},
+			},
+		}, null, 2));
+
+		const discovered = discoverAgentsAll(cwd);
+		assert.equal(discovered.userDir, path.join(agentDir, "agents"));
+		assert.equal(discovered.userChainDir, path.join(agentDir, "chains"));
+		assert.equal(discovered.userSettingsPath, settingsPath);
+		assert.ok(discovered.user.find((agent) => agent.name === "env-agent" && agent.filePath === path.join(agentDir, "agents", "env-agent.md")));
+		assert.ok(discovered.chains.find((chain) => chain.name === "env-chain" && chain.filePath === path.join(agentDir, "chains", "env-chain.chain.md")));
+
+		const worker = discovered.builtin.find((agent) => agent.name === "worker");
+		assert.equal(worker?.systemPrompt, "Use env-rooted settings.");
+		assert.equal(worker?.override?.path, settingsPath);
+		assert.equal(worker?.override?.scope, "user");
+
+		const createdName = "created-env-agent";
+		const created = handleCreate(
+			{ config: { name: createdName, description: "Created in env dir", scope: "user" } },
+			{ cwd, modelRegistry: { getAvailable: () => [] } },
+		);
+		assert.equal(created.isError, false, readText(created));
+		assert.equal(fs.existsSync(path.join(agentDir, "agents", `${createdName}.md`)), true);
+	});
+
+	it("resolves user skills, settings skills, and package skills from the configured agent dir", () => {
+		writeFile(path.join(agentDir, "skills", "env-skill", "SKILL.md"), `---
+description: Env skill
+---
+Env skill content.
+`);
+		writeFile(path.join(agentDir, "settings-skill.md"), `---
+description: Settings skill
+---
+Settings skill content.
+`);
+		const packageRoot = path.join(agentDir, "packages", "env-package");
+		writeFile(path.join(packageRoot, "package.json"), JSON.stringify({ name: "env-package", pi: { skills: ["./skills/package-skill.md"] } }, null, 2));
+		writeFile(path.join(packageRoot, "skills", "package-skill.md"), `---
+description: Package skill
+---
+Package skill content.
+`);
+		writeFile(path.join(agentDir, "settings.json"), JSON.stringify({
+			skills: ["./settings-skill.md"],
+			packages: ["file:./packages/env-package"],
+		}, null, 2));
+
+		clearSkillCache();
+		assert.deepEqual(resolveSkillPath("env-skill", cwd), { path: path.join(agentDir, "skills", "env-skill", "SKILL.md"), source: "user" });
+		assert.deepEqual(resolveSkillPath("settings-skill", cwd), { path: path.join(agentDir, "settings-skill.md"), source: "user-settings" });
+		assert.deepEqual(resolveSkillPath("package-skill", cwd), { path: path.join(packageRoot, "skills", "package-skill.md"), source: "user-package" });
+
+		const available = discoverAvailableSkills(cwd);
+		assert.ok(available.find((skill) => skill.name === "env-skill" && skill.source === "user"));
+		assert.ok(available.find((skill) => skill.name === "settings-skill" && skill.source === "user-settings"));
+		assert.ok(available.find((skill) => skill.name === "package-skill" && skill.source === "user-package"));
+	});
+
+	it("records run history and cleans session artifacts under the configured agent dir", () => {
+		recordRun("env-agent", "Inspect", 0, 42);
+		const historyPath = path.join(agentDir, "run-history.jsonl");
+		assert.equal(fs.existsSync(historyPath), true);
+		const history = loadRunsForAgent("env-agent");
+		assert.equal(history.length, 1);
+		assert.equal(history[0]?.task, "Inspect");
+		assert.equal(history[0]?.status, "ok");
+
+		const artifactPath = path.join(agentDir, "sessions", "session-1", "subagent-artifacts", "old_output.md");
+		writeFile(artifactPath, "old output");
+		const oldTime = new Date(Date.now() - 60_000);
+		fs.utimesSync(artifactPath, oldTime, oldTime);
+
+		cleanupAllArtifactDirs(0);
+		assert.equal(fs.existsSync(artifactPath), false);
+	});
+
+	it("uses the configured agent dir for subagent bridge instruction files", () => {
+		const instructionPath = path.join(agentDir, "extensions", "subagent", "bridge.md");
+		writeFile(instructionPath, "Native bridge for {orchestratorTarget}");
+
+		const diagnostic = diagnoseIntercomBridge({
+			config: { mode: "always" },
+			context: "fresh",
+			orchestratorTarget: "main",
+		});
+		assert.equal(diagnostic.active, true);
+		assert.equal(diagnostic.extensionDir, "native:pi-subagents-supervisor-channel");
+
+		const bridge = resolveIntercomBridge({
+			config: { mode: "always", instructionFile: "bridge.md" },
+			context: "fresh",
+			orchestratorTarget: "main",
+		});
+		assert.equal(bridge.active, true);
+		assert.equal(bridge.extensionDir, "native:pi-subagents-supervisor-channel");
+		assert.match(bridge.instruction, /Native bridge for main/);
+	});
+});

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

@@ -0,0 +1,238 @@
+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 {
+	getSelesaiSpawnCommand,
+	resolveWindowsSelesaiCliScript,
+	type SelesaiSpawnDeps,
+} from "../../src/runs/shared/pi-spawn.ts";
+
+function makeDeps(input: {
+	platform?: NodeJS.Platform;
+	execPath?: string;
+	argv1?: string;
+	existing?: string[];
+	packageJsonPath?: string;
+	packageJsonContent?: string;
+	packageEntry?: string;
+	env?: NodeJS.ProcessEnv;
+}): SelesaiSpawnDeps {
+	const existing = new Set(input.existing ?? []);
+	const packageJsonPath = input.packageJsonPath;
+	const packageJsonContent = input.packageJsonContent;
+	return {
+		platform: input.platform,
+		execPath: input.execPath,
+		argv1: input.argv1,
+		existsSync: (filePath) => existing.has(filePath),
+		readFileSync: (_filePath, _encoding) => {
+			if (!packageJsonPath || !packageJsonContent) {
+				throw new Error("package json not configured");
+			}
+			return packageJsonContent;
+		},
+		resolvePackageJson: packageJsonPath ? () => packageJsonPath : undefined,
+		resolvePackageEntry: input.packageEntry
+			? () => input.packageEntry!
+			: undefined,
+		env: input.env ?? {},
+	};
+}
+
+describe("getSelesaiSpawnCommand", () => {
+	it("honors explicit SELESAI_SUBAGENT_PI_BINARY override on any platform", () => {
+		const args = ["--mode", "json", "Task: check output"];
+		const result = getSelesaiSpawnCommand(args, {
+			platform: "win32",
+			execPath: "/usr/local/bin/node",
+			argv1: "/tmp/pi-entry.mjs",
+			env: {
+				SELESAI_SUBAGENT_PI_BINARY: "/nix/store/pi-wrapper/bin/nhost-code-agent",
+			},
+			existsSync: () => true,
+		});
+		assert.deepEqual(result, {
+			command: "/nix/store/pi-wrapper/bin/nhost-code-agent",
+			args,
+		});
+	});
+
+	it("ignores a blank SELESAI_SUBAGENT_PI_BINARY override", () => {
+		const args = ["--mode", "json", "Task: check output"];
+		const result = getSelesaiSpawnCommand(args, {
+			platform: "darwin",
+			env: { SELESAI_SUBAGENT_PI_BINARY: "   " },
+		});
+		assert.deepEqual(result, { command: "selesai", args });
+	});
+
+	it("uses plain pi on non-Windows even when argv1 is a runnable JS file", () => {
+		const argv1 = "/tmp/pi-entry.mjs";
+		const deps = makeDeps({
+			platform: "darwin",
+			execPath: "/usr/local/bin/node",
+			argv1,
+			existing: [argv1],
+		});
+		const args = ["--mode", "json", "Task: check output"];
+		const result = getSelesaiSpawnCommand(args, deps);
+		assert.deepEqual(result, { command: "selesai", args });
+	});
+
+	it("uses plain pi on non-Windows even when the CLI script can be resolved from package bin", () => {
+		const packageJsonPath = "/opt/pi/package.json";
+		const cliPath = path.resolve(
+			path.dirname(packageJsonPath),
+			"dist/cli/index.js",
+		);
+		const deps = makeDeps({
+			platform: "darwin",
+			execPath: "/usr/local/bin/node",
+			argv1: "/opt/pi/subagent-runner.ts",
+			packageJsonPath,
+			packageJsonContent: JSON.stringify({ bin: { selesai: "dist/cli/index.js" } }),
+			existing: [packageJsonPath, cliPath],
+		});
+		const args = ["-p", "Task: hello"];
+		const result = getSelesaiSpawnCommand(args, deps);
+		assert.deepEqual(result, { command: "selesai", args });
+	});
+
+	it("falls back to plain pi command on non-Windows when CLI script cannot be resolved", () => {
+		const args = ["--mode", "json", "Task: check output"];
+		const result = getSelesaiSpawnCommand(args, { platform: "darwin", env: {} });
+		assert.deepEqual(result, { command: "selesai", args });
+	});
+
+	it("uses node + argv1 script on Windows when argv1 is runnable JS", () => {
+		const argv1 = "/tmp/pi-entry.mjs";
+		const deps = makeDeps({
+			platform: "win32",
+			execPath: "/usr/local/bin/node",
+			argv1,
+			existing: [argv1],
+		});
+		const args = [
+			"--mode",
+			"json",
+			'Task: Read C:/dev/file.md and review "quotes" & pipes | too',
+		];
+		const result = getSelesaiSpawnCommand(args, deps);
+		assert.equal(result.command, "/usr/local/bin/node");
+		assert.equal(result.args[0], argv1);
+		assert.equal(result.args[3], args[2]);
+	});
+
+	it("resolves CLI script from package bin when argv1 is not runnable JS", () => {
+		const packageJsonPath = "/opt/pi/package.json";
+		// Compute expected path the same way the production code does:
+		// path.resolve(path.dirname(packageJsonPath), binPath) — which on Windows
+		// prepends the current drive letter to POSIX absolute paths.
+		const cliPath = path.resolve(
+			path.dirname(packageJsonPath),
+			"dist/cli/index.js",
+		);
+		const deps = makeDeps({
+			platform: "win32",
+			execPath: "/usr/local/bin/node",
+			argv1: "/opt/pi/subagent-runner.ts",
+			packageJsonPath,
+			packageJsonContent: JSON.stringify({ bin: { selesai: "dist/cli/index.js" } }),
+			existing: [packageJsonPath, cliPath],
+		});
+		const result = getSelesaiSpawnCommand(["-p", "Task: hello"], deps);
+		assert.equal(result.command, "/usr/local/bin/node");
+		assert.equal(result.args[0], cliPath);
+	});
+
+	it("falls back to pi when Windows CLI script cannot be resolved", () => {
+		const deps = makeDeps({
+			platform: "win32",
+			argv1: "/opt/pi/subagent-runner.ts",
+			existing: [],
+		});
+		const args = ["-p", "Task: hello"];
+		const result = getSelesaiSpawnCommand(args, deps);
+		assert.deepEqual(result, { command: "selesai", args });
+	});
+
+	it("walks from package main entry to resolve package bin", () => {
+		const tempDir = fs.mkdtempSync(
+			path.join(os.tmpdir(), "pi-spawn-package-root-"),
+		);
+		try {
+			const packageRoot = path.join(
+				tempDir,
+				"node_modules",
+				"@selesai",
+				"code",
+			);
+			const entry = path.join(packageRoot, "dist", "index.js");
+			const cliPath = path.join(packageRoot, "dist", "cli", "index.js");
+			fs.mkdirSync(path.dirname(entry), { recursive: true });
+			fs.mkdirSync(path.dirname(cliPath), { recursive: true });
+			fs.writeFileSync(entry, "export {};\n");
+			fs.writeFileSync(cliPath, "#!/usr/bin/env node\n");
+			fs.writeFileSync(
+				path.join(packageRoot, "package.json"),
+				JSON.stringify({
+					name: "@selesai/code",
+					bin: { selesai: "dist/cli/index.js" },
+				}),
+			);
+			const result = getSelesaiSpawnCommand(["-p", "Task: hello"], {
+				platform: "win32",
+				execPath: "/usr/local/bin/node",
+				argv1: "/opt/pi/subagent-runner.ts",
+				resolvePackageEntry: () => entry,
+				env: {},
+			});
+			assert.equal(result.command, "/usr/local/bin/node");
+			assert.equal(result.args[0], cliPath);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("getSelesaiSpawnCommand with piPackageRoot", () => {
+	it("resolves CLI script via piPackageRoot when argv1 is not runnable", () => {
+		const packageJsonPath = "/opt/pi/package.json";
+		const cliPath = path.resolve(
+			path.dirname(packageJsonPath),
+			"dist/cli/index.js",
+		);
+		const deps = makeDeps({
+			platform: "win32",
+			execPath: "/usr/local/bin/node",
+			argv1: "/opt/pi/subagent-runner.ts",
+			packageJsonPath,
+			packageJsonContent: JSON.stringify({ bin: { selesai: "dist/cli/index.js" } }),
+			existing: [packageJsonPath, cliPath],
+		});
+		deps.piPackageRoot = "/opt/pi";
+		const result = getSelesaiSpawnCommand(["-p", "Task: hello"], deps);
+		assert.equal(result.command, "/usr/local/bin/node");
+		assert.equal(result.args[0], cliPath);
+	});
+});
+
+describe("resolveWindowsSelesaiCliScript", () => {
+	it("supports package bin as string", () => {
+		const packageJsonPath = "/opt/pi/package.json";
+		const cliPath = path.resolve(
+			path.dirname(packageJsonPath),
+			"dist/cli/index.mjs",
+		);
+		const deps = makeDeps({
+			platform: "win32",
+			argv1: "/opt/pi/subagent-runner.ts",
+			packageJsonPath,
+			packageJsonContent: JSON.stringify({ bin: "dist/cli/index.mjs" }),
+			existing: [packageJsonPath, cliPath],
+		});
+		assert.equal(resolveWindowsSelesaiCliScript(deps), cliPath);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/proactive-skills.test.ts

@@ -0,0 +1,118 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { AgentConfig, ChainConfig } from "../../src/agents/agents.ts";
+import {
+	buildProactiveSkillSubagentRecommendationLines,
+	formatProactiveSkillSubagentRecommendations,
+	recommendProactiveSkillSubagents,
+	resolveProactiveSkillSubagentsConfig,
+} from "../../src/agents/proactive-skills.ts";
+
+function agent(name: string, skills?: string[], disabled = false): AgentConfig {
+	return {
+		name,
+		description: `${name} agent`,
+		systemPrompt: "",
+		systemPromptMode: "replace",
+		inheritProjectContext: false,
+		inheritSkills: false,
+		source: "project",
+		filePath: `/tmp/${name}.md`,
+		...(skills ? { skills } : {}),
+		...(disabled ? { disabled } : {}),
+	};
+}
+
+function chain(name: string, skills: string[]): ChainConfig {
+	return {
+		name,
+		description: `${name} chain`,
+		source: "project",
+		filePath: `/tmp/${name}.chain.md`,
+		steps: [{ agent: "worker", skills }],
+	};
+}
+
+describe("proactive skill subagent recommendations", () => {
+	it("recommends available skills referenced by multiple enabled configs", () => {
+		const recommendations = recommendProactiveSkillSubagents({
+			agents: [
+				agent("reviewer"),
+				agent("ui-reviewer", ["accessibility"]),
+				agent("disabled-reviewer", ["accessibility"], true),
+			],
+			chains: [chain("ui-check", ["accessibility"]), chain("cleanup", ["deslop"])],
+			availableSkills: [
+				{ name: "accessibility", description: "Accessibility review." },
+				{ name: "deslop", description: "Cleanup review." },
+			],
+		});
+
+		assert.equal(recommendations.length, 1);
+		assert.equal(recommendations[0]?.skill, "accessibility");
+		assert.equal(recommendations[0]?.agent, "reviewer");
+		assert.equal(recommendations[0]?.references, 2);
+		assert.deepEqual(recommendations[0]?.sources, ["agent:ui-reviewer", "chain:ui-check"]);
+	});
+
+	it("filters unavailable orchestration skills and honors config bounds", () => {
+		const recommendations = recommendProactiveSkillSubagents({
+			agents: [
+				agent("delegate", ["pi-subagents", "alpha", "beta"]),
+				agent("one", ["alpha", "beta"]),
+				agent("two", ["gamma"]),
+				agent("three", ["gamma"]),
+			],
+			availableSkills: [{ name: "alpha" }, { name: "beta" }, { name: "gamma" }],
+			config: { preferredAgent: "delegate", maxRecommendations: 2 },
+		});
+
+		assert.deepEqual(recommendations.map((entry) => entry.skill), ["alpha", "beta"]);
+		assert.ok(recommendations.every((entry) => entry.agent === "delegate"));
+	});
+
+	it("can be disabled and formats guardrails for visible suggestions", () => {
+		assert.equal(resolveProactiveSkillSubagentsConfig(false).enabled, false);
+		assert.deepEqual(recommendProactiveSkillSubagents({
+			agents: [agent("reviewer", ["deslop"]), agent("cleanup", ["deslop"])],
+			availableSkills: [{ name: "deslop" }],
+			config: false,
+		}), []);
+
+		const lines = formatProactiveSkillSubagentRecommendations([
+			{
+				skill: "deslop",
+				agent: "reviewer",
+				references: 2,
+				sources: ["agent:a", "chain:b"],
+				reason: "referenced by 2 configured agents/chains",
+			},
+		]);
+		assert.match(lines.join("\n"), /Proactive skill subagent suggestions:/);
+		assert.match(lines.join("\n"), /fresh context/);
+	});
+
+	it("does not discover skills when disabled and treats discovery failures as no suggestions", () => {
+		let discoveryCalls = 0;
+		const disabledLines = buildProactiveSkillSubagentRecommendationLines({
+			agents: [agent("reviewer", ["deslop"]), agent("cleanup", ["deslop"])],
+			config: false,
+			discoverAvailableSkills: () => {
+				discoveryCalls++;
+				throw new Error("should not discover when disabled");
+			},
+		});
+		assert.deepEqual(disabledLines, []);
+		assert.equal(discoveryCalls, 0);
+
+		const failedDiscoveryLines = buildProactiveSkillSubagentRecommendationLines({
+			agents: [agent("reviewer", ["deslop"]), agent("cleanup", ["deslop"])],
+			discoverAvailableSkills: () => {
+				discoveryCalls++;
+				throw new Error("skill scan failed");
+			},
+		});
+		assert.deepEqual(failedDiscoveryLines, []);
+		assert.equal(discoveryCalls, 1);
+	});
+});