@selesai/code 0.3.0 → 0.3.1

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

@@ -0,0 +1,408 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import {
+	PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT,
+	PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT,
+	PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT,
+	PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT,
+	PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT,
+	registerPromptTemplateDelegationBridge,
+	type PromptTemplateBridgeEvents,
+} from "../../src/slash/prompt-template-bridge.ts";
+
+class FakeEvents implements PromptTemplateBridgeEvents {
+	private handlers = new Map<string, Array<(data: unknown) => void>>();
+
+	on(event: string, handler: (data: unknown) => void): () => void {
+		const list = this.handlers.get(event) ?? [];
+		list.push(handler);
+		this.handlers.set(event, list);
+		return () => {
+			const current = this.handlers.get(event) ?? [];
+			this.handlers.set(event, current.filter((h) => h !== handler));
+		};
+	}
+
+	emit(event: string, data: unknown): void {
+		const list = this.handlers.get(event) ?? [];
+		for (const handler of [...list]) handler(data);
+	}
+}
+
+function once(events: FakeEvents, event: string): Promise<unknown> {
+	return new Promise((resolve) => {
+		const unsubscribe = events.on(event, (payload) => {
+			unsubscribe();
+			resolve(payload);
+		});
+	});
+}
+
+describe("prompt-template delegation bridge", () => {
+	it("emits started/update/response on successful request", async () => {
+		const events = new FakeEvents();
+		let executeCalls = 0;
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async (_requestId, _request, _signal, _ctx, onUpdate) => {
+				executeCalls++;
+				onUpdate({
+					details: {
+						results: [{ agent: "worker", model: "openai/gpt-5-mini" }],
+						progress: [{
+							index: 0,
+							agent: "worker",
+							currentTool: "read",
+							currentToolArgs: "src/extension/index.ts",
+							recentOutput: ["line 1"],
+							recentTools: [{ tool: "read", args: '{"path":"src/extension/index.ts"}' }],
+							toolCount: 1,
+							durationMs: 10,
+							tokens: 42,
+						}],
+					},
+				});
+				return {
+					details: {
+						results: [{ messages: [{ role: "assistant", content: [{ type: "text", text: "ok" }] }] }],
+					},
+				};
+			},
+		});
+
+		const startedPromise = once(events, PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT);
+		const updatePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT);
+		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
+
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
+			requestId: "r1",
+			agent: "worker",
+			task: "do work",
+			context: "fresh",
+			model: "openai/gpt-5",
+			cwd: "/repo",
+		});
+
+		const started = await startedPromise as { requestId: string };
+		assert.equal(started.requestId, "r1");
+
+		const update = await updatePromise as {
+			requestId: string;
+			currentTool?: string;
+			toolCount?: number;
+			recentOutputLines?: string[];
+			recentTools?: Array<{ tool: string; args: string }>;
+			model?: string;
+			taskProgress?: Array<{ model?: string }>;
+		};
+		assert.equal(update.requestId, "r1");
+		assert.equal(update.currentTool, "read");
+		assert.equal(update.toolCount, 1);
+		assert.deepEqual(update.recentOutputLines, ["line 1"]);
+		assert.deepEqual(update.recentTools, [{ tool: "read", args: '{"path":"src/extension/index.ts"}' }]);
+		assert.equal(update.model, "openai/gpt-5-mini");
+		assert.equal(update.taskProgress?.[0]?.model, "openai/gpt-5-mini");
+
+		const response = await responsePromise as { requestId: string; isError: boolean; messages: unknown[] };
+		assert.equal(response.requestId, "r1");
+		assert.equal(response.isError, false);
+		assert.equal(Array.isArray(response.messages), true);
+		assert.equal(executeCalls, 1);
+
+		bridge.dispose();
+	});
+
+	it("rebuilds compact tool-call summaries into delegated response messages", async () => {
+		const events = new FakeEvents();
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async () => ({
+				details: {
+					results: [{
+						finalOutput: "finished",
+						toolCalls: [
+							{ text: "write src/output.md", expandedText: "write src/output.md" },
+							{ text: "edit src/output.md", expandedText: "edit src/output.md" },
+						],
+					}],
+				},
+			}),
+		});
+
+		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
+			requestId: "r-compact-tools",
+			agent: "worker",
+			task: "do work",
+			context: "fresh",
+			model: "openai/gpt-5",
+			cwd: "/repo",
+		});
+
+		const response = await responsePromise as { messages: Array<{ role?: string; content?: Array<{ type?: string; name?: string; text?: string }> }> };
+		assert.equal(response.messages.length, 1);
+		assert.equal(response.messages[0]?.role, "assistant");
+		assert.deepEqual(
+			response.messages[0]?.content?.filter((part) => part.type === "toolCall").map((part) => part.name),
+			["write", "edit"],
+		);
+		assert.equal(response.messages[0]?.content?.some((part) => part.type === "text" && part.text === "finished"), true);
+
+		bridge.dispose();
+	});
+
+	it("filters malformed recent output entries in updates", async () => {
+		const events = new FakeEvents();
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async (_requestId, _request, _signal, _ctx, onUpdate) => {
+				onUpdate({
+					details: {
+						results: [{ agent: "worker", model: "openai/gpt-5-mini" }],
+						progress: [{
+							index: 0,
+							agent: "worker",
+							recentOutput: ["line 1", 123 as unknown as string],
+						}],
+					},
+				});
+				return { details: { results: [{ messages: [] }] } };
+			},
+		});
+
+		const updatePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT);
+		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
+			requestId: "r-malformed-output",
+			agent: "worker",
+			task: "do work",
+			context: "fresh",
+			model: "openai/gpt-5",
+			cwd: "/repo",
+		});
+
+		const update = await updatePromise as {
+			recentOutput?: string;
+			recentOutputLines?: string[];
+			taskProgress?: Array<{ recentOutput?: string; recentOutputLines?: string[] }>;
+		};
+		assert.equal(update.recentOutput, undefined);
+		assert.deepEqual(update.recentOutputLines, ["line 1"]);
+		assert.equal(update.taskProgress?.[0]?.recentOutput, undefined);
+		assert.deepEqual(update.taskProgress?.[0]?.recentOutputLines, ["line 1"]);
+
+		await responsePromise;
+		bridge.dispose();
+	});
+
+	it("returns structured error when no active context", async () => {
+		const events = new FakeEvents();
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => null,
+			execute: async () => ({ details: { results: [{ messages: [] }] } }),
+		});
+
+		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
+			requestId: "r2",
+			agent: "worker",
+			task: "do work",
+			context: "fresh",
+			model: "openai/gpt-5",
+			cwd: "/repo",
+		});
+
+		const response = await responsePromise as { isError: boolean; errorText?: string };
+		assert.equal(response.isError, true);
+		assert.match(response.errorText ?? "", /No active extension context/);
+
+		bridge.dispose();
+	});
+
+	it("accepts requests when delegated cwd differs from active context", async () => {
+		const events = new FakeEvents();
+		let executeCwd: string | undefined;
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/actual" }),
+			execute: async (_requestId, request) => {
+				executeCwd = request.cwd;
+				return { details: { results: [{ messages: [] }] } };
+			},
+		});
+
+		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
+			requestId: "r3",
+			agent: "worker",
+			task: "do work",
+			context: "fresh",
+			model: "openai/gpt-5",
+			cwd: "/repo",
+		});
+
+		const response = await responsePromise as { isError: boolean; errorText?: string };
+		assert.equal(response.isError, false);
+		assert.equal(executeCwd, "/repo");
+
+		bridge.dispose();
+	});
+
+	it("applies pending cancel when cancel arrives before request", async () => {
+		const events = new FakeEvents();
+		let executeCalls = 0;
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async () => {
+				executeCalls++;
+				return { details: { results: [{ messages: [] }] } };
+			},
+		});
+
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, { requestId: "r4" });
+		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
+
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
+			requestId: "r4",
+			agent: "worker",
+			task: "do work",
+			context: "fresh",
+			model: "openai/gpt-5",
+			cwd: "/repo",
+		});
+
+		const response = await responsePromise as { isError: boolean; errorText?: string };
+		assert.equal(response.isError, true);
+		assert.equal(response.errorText, "Delegated prompt cancelled.");
+		assert.equal(executeCalls, 0);
+
+		bridge.dispose();
+	});
+
+	it("cancels in-flight delegated execution", async () => {
+		const events = new FakeEvents();
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async (_requestId, _request, signal) =>
+				await new Promise((_resolve, reject) => {
+					signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
+				}),
+		});
+
+		const startedPromise = once(events, PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT);
+		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
+
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
+			requestId: "r5",
+			agent: "worker",
+			task: "do work",
+			context: "fresh",
+			model: "openai/gpt-5",
+			cwd: "/repo",
+		});
+
+		await startedPromise;
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, { requestId: "r5" });
+
+		const response = await responsePromise as { isError: boolean; errorText?: string };
+		assert.equal(response.isError, true);
+		assert.match(response.errorText ?? "", /aborted/i);
+
+		bridge.dispose();
+	});
+
+	it("accepts tasks payloads and emits parallelResults", async () => {
+		const events = new FakeEvents();
+		let executeTasks: Array<{ agent: string; task: string; model?: string; cwd?: string }> | undefined;
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async (_requestId, request) => {
+				executeTasks = request.tasks;
+				return {
+					details: {
+						results: [
+							{ agent: "worker-a", messages: [{ role: "assistant", content: [{ type: "text", text: "a" }] }], exitCode: 0 },
+							{ agent: "worker-b", messages: [], exitCode: 1, error: "failed" },
+						],
+					},
+				};
+			},
+		});
+
+		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
+			requestId: "r6",
+			tasks: [
+				{ agent: "worker-a", task: "A", model: "openai/gpt-5", cwd: "/repo/a" },
+				{ agent: "worker-b", task: "B", model: "anthropic/claude-sonnet-4-20250514", cwd: "/repo/b" },
+			],
+			context: "fresh",
+			model: "openai/gpt-5",
+			cwd: "/repo",
+		});
+
+		const response = await responsePromise as {
+			isError: boolean;
+			parallelResults?: Array<{ agent: string; isError: boolean; errorText?: string }>;
+		};
+		assert.equal(Array.isArray(executeTasks), true);
+		assert.equal(executeTasks?.length, 2);
+		assert.equal(executeTasks?.[0]?.model, "openai/gpt-5");
+		assert.equal(executeTasks?.[1]?.model, "anthropic/claude-sonnet-4-20250514");
+		assert.equal(executeTasks?.[0]?.cwd, "/repo/a");
+		assert.equal(executeTasks?.[1]?.cwd, "/repo/b");
+		assert.equal(response.isError, false);
+		assert.equal(response.parallelResults?.[0]?.agent, "worker-a");
+		assert.equal(response.parallelResults?.[0]?.isError, false);
+		assert.equal(response.parallelResults?.[1]?.agent, "worker-b");
+		assert.equal(response.parallelResults?.[1]?.isError, true);
+		assert.equal(response.parallelResults?.[1]?.errorText, "failed");
+
+		bridge.dispose();
+	});
+
+	it("marks missing parallel task results as errors", async () => {
+		const events = new FakeEvents();
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async () => ({
+				details: {
+					results: [{ agent: "worker-a", messages: [{ role: "assistant", content: [{ type: "text", text: "ok" }] }], exitCode: 0 }],
+				},
+			}),
+		});
+
+		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
+			requestId: "r7",
+			tasks: [
+				{ agent: "worker-a", task: "A" },
+				{ agent: "worker-b", task: "B" },
+			],
+			context: "fresh",
+			model: "openai/gpt-5",
+			cwd: "/repo",
+		});
+
+		const response = await responsePromise as {
+			isError: boolean;
+			parallelResults?: Array<{ agent: string; isError: boolean; errorText?: string }>;
+		};
+		assert.equal(response.isError, false);
+		assert.equal(response.parallelResults?.[0]?.isError, false);
+		assert.equal(response.parallelResults?.[1]?.agent, "worker-b");
+		assert.equal(response.parallelResults?.[1]?.isError, true);
+		assert.match(response.parallelResults?.[1]?.errorText ?? "", /missing result/i);
+
+		bridge.dispose();
+	});
+});

package/dist/extensions/pi-subagents/test/unit/prompt-workflows.test.ts

@@ -0,0 +1,134 @@
+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 { discoverPromptWorkflows, registerPromptWorkflowCommands } from "../../src/slash/prompt-workflows.ts";
+import type { SubagentParamsLike } from "../../src/runs/foreground/subagent-executor.ts";
+
+const originalAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+
+function writePrompt(dir: string, name: string, content: string): void {
+	fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(path.join(dir, `${name}.md`), content, "utf-8");
+}
+
+function makeCtx(cwd: string) {
+	return {
+		cwd,
+		hasUI: true,
+		ui: {
+			notifications: [] as Array<{ message: string; level: string }>,
+			notify(message: string, level: string) {
+				this.notifications.push({ message, level });
+			},
+		},
+	} as never;
+}
+
+describe("prompt workflows", () => {
+	let tempDir = "";
+	let agentDir = "";
+	let cwd = "";
+
+	beforeEach(() => {
+		tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-prompt-workflows-"));
+		agentDir = path.join(tempDir, "agent");
+		cwd = path.join(tempDir, "repo");
+		fs.mkdirSync(cwd, { recursive: true });
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+	});
+
+	afterEach(() => {
+		if (originalAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = originalAgentDir;
+		fs.rmSync(tempDir, { recursive: true, force: true });
+	});
+
+	it("discovers project workflows over user workflows", () => {
+		writePrompt(path.join(agentDir, "prompts"), "native-test", `---
+description: User version
+subagent: reviewer
+---
+User body
+`);
+		writePrompt(path.join(cwd, ".selesai", "prompts"), "native-test", `---
+description: Project version
+subagent: worker
+model: openai/gpt-5-mini
+---
+Project body $1
+`);
+
+		const workflow = discoverPromptWorkflows(cwd).find((entry) => entry.name === "native-test");
+
+		assert.equal(workflow?.description, "Project version");
+		assert.equal(workflow?.agent, "worker");
+		assert.equal(workflow?.model, "openai/gpt-5-mini");
+	});
+
+	it("runs a named workflow through native subagent execution", async () => {
+		writePrompt(path.join(cwd, ".selesai", "prompts"), "native-run", `---
+description: Run native prompt
+subagent: reviewer
+model: anthropic/claude-sonnet-4
+skill: deslop,typescript-code
+---
+Review $1 with $ARGUMENTS
+`);
+		const commands = new Map<string, { handler: (args: string, ctx: never) => Promise<void> }>();
+		const sent: unknown[] = [];
+		const runs: SubagentParamsLike[] = [];
+		registerPromptWorkflowCommands({
+			pi: {
+				registerCommand: (name: string, command: { handler: (args: string, ctx: never) => Promise<void> }) => commands.set(name, command),
+				sendMessage: (message: unknown) => sent.push(message),
+			} as never,
+			run: async (params) => { runs.push(params); },
+		});
+
+		await commands.get("prompt-workflow")!.handler('native-run target --fork --worktree', makeCtx(cwd));
+
+		assert.equal(sent.length, 0);
+		assert.equal(runs.length, 1);
+		assert.equal(runs[0]?.agent, "reviewer");
+		assert.equal(runs[0]?.model, "anthropic/claude-sonnet-4");
+		assert.deepEqual(runs[0]?.skill, ["deslop", "typescript-code"]);
+		assert.equal(runs[0]?.context, "fork");
+		assert.equal(runs[0]?.worktree, true);
+		assert.equal(runs[0]?.task, "Review target with target");
+	});
+
+	it("runs prompt templates as a native chain", async () => {
+		writePrompt(path.join(cwd, ".selesai", "prompts"), "native-analyze", `---
+description: Analyze
+subagent: scout
+---
+Analyze $@
+`);
+		writePrompt(path.join(cwd, ".selesai", "prompts"), "native-fix", `---
+description: Fix
+subagent: worker
+---
+Fix from {previous}: $@
+`);
+		const commands = new Map<string, { handler: (args: string, ctx: never) => Promise<void> }>();
+		const runs: SubagentParamsLike[] = [];
+		registerPromptWorkflowCommands({
+			pi: {
+				registerCommand: (name: string, command: { handler: (args: string, ctx: never) => Promise<void> }) => commands.set(name, command),
+				sendMessage: () => {},
+			} as never,
+			run: async (params) => { runs.push(params); },
+		});
+
+		await commands.get("chain-prompts")!.handler("native-analyze -> native-fix -- bug report", makeCtx(cwd));
+
+		assert.equal(runs.length, 1);
+		assert.equal(runs[0]?.chain?.length, 2);
+		assert.equal(runs[0]?.chain?.[0]?.agent, "scout");
+		assert.equal(runs[0]?.chain?.[0]?.task, "Analyze bug report");
+		assert.equal(runs[0]?.chain?.[1]?.agent, "worker");
+		assert.equal(runs[0]?.chain?.[1]?.task, "Fix from {previous}: bug report");
+	});
+});