@selesai/code 0.2.1 → 0.3.1

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

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { registerSlashSubagentBridge } from "../../src/slash/slash-bridge.ts";
+
+const REQUEST = "subagent:slash:request";
+const RESPONSE = "subagent:slash:response";
+
+function eventBus() {
+  const handlers = new Map<string, Array<(data: unknown) => void>>();
+  return {
+    on(event: string, handler: (data: unknown) => void) {
+      const list = handlers.get(event) ?? [];
+      list.push(handler);
+      handlers.set(event, list);
+      return () => handlers.set(event, (handlers.get(event) ?? []).filter((h) => h !== handler));
+    },
+    emit(event: string, data: unknown) {
+      for (const handler of handlers.get(event) ?? []) handler(data);
+    },
+  };
+}
+
+describe("slash subagent bridge requester context", () => {
+  it("uses request ctx instead of stale fallback context when provided", async () => {
+    const events = eventBus();
+    const fallbackCtx = { cwd: "/fallback" } as any;
+    const requestCtx = { cwd: "/request" } as any;
+    let executedCtx: any;
+
+    registerSlashSubagentBridge({
+      events,
+      getContext: () => fallbackCtx,
+      execute: async (_id, _params, _signal, _onUpdate, ctx) => {
+        executedCtx = ctx;
+        return { content: [{ type: "text", text: "ok" }], details: { mode: "single", results: [] } } as any;
+      },
+    });
+
+    const done = new Promise<void>((resolve, reject) => {
+      events.on(RESPONSE, (data: any) => {
+        try {
+          assert.equal(data.isError, false);
+          assert.equal(executedCtx, requestCtx);
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+
+    events.emit(REQUEST, { requestId: "ctx-test", params: { action: "list" }, ctx: requestCtx });
+    await done;
+  });
+});

package/dist/extensions/pi-subagents/test/unit/slash-chain-groups.test.ts

@@ -0,0 +1,464 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+	buildChainExpressionSteps,
+	hasGroupSyntax,
+	PARALLEL_GROUP_USAGE,
+	parseChainExpression,
+	parseGroupSegment,
+	parseSingleTaskToken,
+	SlashParseError,
+} from "../../src/slash/slash-commands.ts";
+
+function makeCtx(notifications: string[]): {
+	ui: { notify: (message: string, level?: string) => void };
+} {
+	return {
+		ui: {
+			notify: (message: string) => {
+				notifications.push(message);
+			},
+		},
+	};
+}
+
+function makeState(cwd: string) {
+	return {
+		baseCwd: cwd,
+	};
+}
+
+let tempRoot: string;
+
+before(() => {
+	tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-slash-chain-test-"));
+	fs.mkdirSync(path.join(tempRoot, ".selesai", "agents"), { recursive: true });
+	const agentsDir = path.join(tempRoot, ".selesai", "agents");
+	const writeAgent = (name: string) => {
+		fs.writeFileSync(
+			path.join(agentsDir, `${name}.md`),
+			`---\nname: ${name}\ndescription: ${name}\n---\nBody\n`,
+			"utf-8",
+		);
+	};
+	for (const name of ["scout", "reviewer", "writer", "unknown"]) {
+		writeAgent(name);
+	}
+});
+
+after(() => {
+	fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+describe("parseSingleTaskToken", () => {
+	it("parses a quoted task", () => {
+		const parsed = parseSingleTaskToken('reviewer "review auth module"');
+		assert.equal(parsed.kind, "step");
+		assert.equal(parsed.name, "reviewer");
+		assert.equal(parsed.task, "review auth module");
+	});
+
+	it("parses an agent with inline config and no task", () => {
+		const parsed = parseSingleTaskToken(
+			"scout[output=ctx.md,outputMode=file-only]",
+		);
+		assert.equal(parsed.kind, "step");
+		assert.equal(parsed.name, "scout");
+		assert.equal(parsed.config.output, "ctx.md");
+		assert.equal(parsed.config.outputMode, "file-only");
+		assert.equal(parsed.task, undefined);
+	});
+
+	it("parses a task via -- delimiter", () => {
+		const parsed = parseSingleTaskToken("reviewer -- Review {previous}");
+		assert.equal(parsed.kind, "step");
+		assert.equal(parsed.name, "reviewer");
+		assert.equal(parsed.task, "Review {previous}");
+	});
+
+	it("parses extended metadata in inline config", () => {
+		const parsed = parseSingleTaskToken(
+			'reviewer[as=rev,label=Review,phase=p1,cwd=sub,count=3,acceptance=checked] "task"',
+		);
+		assert.equal(parsed.config.as, "rev");
+		assert.equal(parsed.config.label, "Review");
+		assert.equal(parsed.config.phase, "p1");
+		assert.equal(parsed.config.cwd, "sub");
+		assert.equal(parsed.config.count, 3);
+		assert.equal(parsed.config.acceptance, "checked");
+		assert.equal(parsed.task, "task");
+	});
+
+	it("ignores a non-positive count", () => {
+		assert.equal(parseSingleTaskToken("scout[count=0]").config.count, undefined);
+		assert.equal(parseSingleTaskToken("scout[count=x]").config.count, undefined);
+	});
+});
+
+describe("parseGroupSegment", () => {
+	it("parses a static parallel group with two quoted tasks", () => {
+		const parsed = parseGroupSegment('(reviewer "A" | reviewer "B")');
+		assert.equal(parsed.kind, "group");
+		assert.equal(parsed.tasks.length, 2);
+		assert.equal(parsed.tasks[0]?.name, "reviewer");
+		assert.equal(parsed.tasks[0]?.task, "A");
+		assert.equal(parsed.tasks[1]?.task, "B");
+	});
+
+	it("rejects groups with a single task", () => {
+		assert.throws(
+			() => parseGroupSegment('(reviewer "A")'),
+			(error: unknown) => error instanceof SlashParseError,
+		);
+	});
+
+	it("rejects groups with unbalanced parentheses", () => {
+		assert.throws(
+			() => parseGroupSegment('(reviewer "A"'),
+			(error: unknown) => error instanceof SlashParseError,
+		);
+	});
+
+	it("parses a trailing group-options suffix", () => {
+		const parsed = parseGroupSegment('(reviewer "A" | reviewer "B")[concurrency=2,failFast,worktree]');
+		assert.equal(parsed.tasks.length, 2);
+		assert.equal(parsed.config.concurrency, 2);
+		assert.equal(parsed.config.failFast, true);
+		assert.equal(parsed.config.worktree, true);
+	});
+
+	it("defaults to an empty group config without a suffix", () => {
+		assert.deepEqual(parseGroupSegment('(a "x" | b "y")').config, {});
+	});
+
+	it("rejects a non-bracketed group suffix", () => {
+		assert.throws(
+			() => parseGroupSegment('(a "x" | b "y") concurrency=2'),
+			(error: unknown) => error instanceof SlashParseError,
+		);
+	});
+});
+
+describe("hasGroupSyntax", () => {
+	it("detects parentheses", () => {
+		assert.equal(hasGroupSyntax("a -> (b | c)"), true);
+	});
+
+	it("does not treat a bare pipe as group syntax", () => {
+		assert.equal(hasGroupSyntax("a -> b | c"), false);
+	});
+
+	it("ignores parens inside quotes", () => {
+		assert.equal(hasGroupSyntax('a -> b "with (paren) inside"'), false);
+	});
+
+	it("returns false for plain chain input", () => {
+		assert.equal(hasGroupSyntax("scout -> reviewer"), false);
+	});
+
+	it("does not treat unquoted parens inside a -- task as group syntax", () => {
+		// Regression: a shared-task command must stay on the legacy path even when the
+		// task text contains bare parentheses. A group is a *step* that opens with `(`.
+		assert.equal(hasGroupSyntax("scout -- inspect auth (backend)"), false);
+		assert.equal(hasGroupSyntax("scout -- inspect (auth) -> writer"), false);
+	});
+
+	it("still detects a group that opens a step", () => {
+		assert.equal(hasGroupSyntax('scout "x" -> (a "y" | b "z")'), true);
+		assert.equal(hasGroupSyntax('(a "y" | b "z") -> writer'), true);
+	});
+});
+
+describe("parseChainExpression", () => {
+	it("parses sequential + group + sequential", () => {
+		const expression = parseChainExpression(
+			'scout "scan" -> (reviewer "A" | reviewer "B") -> writer "fix"',
+		);
+		assert.equal(expression.steps.length, 3);
+		const group = expression.steps[1];
+		assert.ok(group);
+		assert.equal(group.kind, "group");
+		if (group.kind === "group") {
+			assert.equal(group.tasks.length, 2);
+		}
+		assert.equal(expression.steps[0]?.kind, "step");
+		assert.equal((expression.steps[0] as { name: string }).name, "scout");
+		assert.equal((expression.steps[2] as { name: string }).name, "writer");
+	});
+
+	it("rejects expression without arrows", () => {
+		assert.throws(
+			() => parseChainExpression('(reviewer "A" | reviewer "B")'),
+			(error: unknown) =>
+				error instanceof SlashParseError && error.message.includes("->"),
+		);
+	});
+
+	it("rejects groups with one task", () => {
+		assert.throws(
+			() => parseChainExpression('scout "scan" -> (reviewer "A")'),
+			(error: unknown) => error instanceof SlashParseError,
+		);
+	});
+
+	it("respects quotes when splitting on arrows", () => {
+		const expression = parseChainExpression(
+			'scout "scan -> quick" -> reviewer "Review"',
+		);
+		assert.equal(expression.steps.length, 2);
+		assert.equal(
+			(expression.steps[0] as { task: string }).task,
+			"scan -> quick",
+		);
+	});
+
+	it("allows balanced parens in a -- task after a group", () => {
+		const expression = parseChainExpression(
+			'scout "scan" -> (reviewer "A" | reviewer "B") -> writer -- fix (backend)',
+		);
+		assert.equal(expression.steps.length, 3);
+	});
+
+	it("still rejects truly unmatched parens in a non-group segment", () => {
+		assert.throws(
+			() => parseChainExpression('scout "scan" -> (reviewer "A" | reviewer "B") -> writer -- fix (backend'),
+			(error: unknown) =>
+				error instanceof SlashParseError && error.message.includes("Unmatched parentheses"),
+		);
+	});
+});
+
+describe("buildChainExpressionSteps", () => {
+	it("emits a chain with a { parallel: [...] } step for groups", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout "scan" -> (reviewer "A" | reviewer "B") -> writer "fix"',
+			makeCtx(notifications) as never,
+		);
+		assert.ok(built, "should build a chain");
+		if (!built) return;
+		assert.deepEqual(notifications, []);
+		assert.equal(built.chain.length, 3);
+		assert.equal(
+			built.chain[0] && "agent" in built.chain[0]
+				? built.chain[0].agent
+				: undefined,
+			"scout",
+		);
+		assert.equal(
+			built.chain[1] && "parallel" in built.chain[1]
+				? built.chain[1].parallel.length
+				: undefined,
+			2,
+		);
+		assert.equal(
+			built.chain[2] && "agent" in built.chain[2]
+				? built.chain[2].agent
+				: undefined,
+			"writer",
+		);
+		assert.equal(built.task, "scan");
+	});
+
+	it("preserves backward-compatible linear chain behavior", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout "scan" -> reviewer "review"',
+			makeCtx(notifications) as never,
+		);
+		assert.ok(built);
+		if (!built) return;
+		assert.equal(built.chain.length, 2);
+		assert.equal(built.task, "scan");
+	});
+
+	it("falls back to shared task when first step has no task", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			"scout -> reviewer",
+			makeCtx(notifications) as never,
+		);
+		assert.equal(built, null);
+		assert.ok(
+			notifications.some((message) => /task/i.test(message)),
+			`notifications: ${notifications.join(" | ")}`,
+		);
+	});
+
+	it("reports parallel group errors as notifications", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout "scan" -> (reviewer "A")',
+			makeCtx(notifications) as never,
+		);
+		assert.equal(built, null);
+		assert.equal(notifications.length, 1);
+		assert.match(notifications[0] ?? "", /at least two/i);
+	});
+
+	it("propagates inline metadata onto chain steps", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout[as=ctx,label=Scan,phase=recon] "scan" -> reviewer "review"',
+			makeCtx(notifications) as never,
+		);
+		assert.ok(built);
+		if (!built) return;
+		assert.deepEqual(notifications, []);
+		const first = built.chain[0] as Record<string, unknown>;
+		assert.equal(first.as, "ctx");
+		assert.equal(first.label, "Scan");
+		assert.equal(first.phase, "recon");
+	});
+
+	it("applies count only inside a parallel group", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout[count=2] "scan" -> (reviewer[count=3] "A" | writer "B")',
+			makeCtx(notifications) as never,
+		);
+		assert.ok(built);
+		if (!built) return;
+		assert.deepEqual(notifications, []);
+		// sequential first step: count ignored
+		assert.equal((built.chain[0] as Record<string, unknown>).count, undefined);
+		const parallel = (built.chain[1] as { parallel: Array<Record<string, unknown>> }).parallel;
+		assert.equal(parallel[0]?.count, 3);
+		assert.equal(parallel[1]?.count, undefined);
+	});
+
+	it("propagates group-level options onto the parallel step", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout "scan" -> (reviewer "A" | writer "B")[concurrency=2,failFast]',
+			makeCtx(notifications) as never,
+		);
+		assert.ok(built);
+		if (!built) return;
+		assert.deepEqual(notifications, []);
+		const group = built.chain[1] as Record<string, unknown>;
+		assert.equal(group.concurrency, 2);
+		assert.equal(group.failFast, true);
+		assert.equal(group.worktree, undefined);
+	});
+
+	it("rejects an invalid acceptance level", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout[acceptance=bogus] "scan" -> reviewer "review"',
+			makeCtx(notifications) as never,
+		);
+		assert.equal(built, null);
+		assert.equal(notifications.length, 1);
+		assert.match(notifications[0] ?? "", /acceptance/i);
+	});
+
+	it("rejects inline acceptance levels that require object contracts", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout[acceptance=verified] "scan" -> reviewer "review"',
+			makeCtx(notifications) as never,
+		);
+		assert.equal(built, null);
+		assert.equal(notifications.length, 1);
+		assert.match(notifications[0] ?? "", /supports auto, attested, or checked/);
+	});
+
+	it("loads an inline outputSchema path and rejects a missing one", () => {
+		fs.writeFileSync(
+			path.join(tempRoot, "schema.json"),
+			JSON.stringify({ type: "object" }),
+			"utf-8",
+		);
+		const ok: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout[outputSchema=schema.json] "scan" -> reviewer "review"',
+			makeCtx(ok) as never,
+		);
+		assert.ok(built);
+		if (built) {
+			assert.deepEqual((built.chain[0] as Record<string, unknown>).outputSchema, { type: "object" });
+		}
+
+		const missing: string[] = [];
+		const bad = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout[outputSchema=nope.json] "scan" -> reviewer "review"',
+			makeCtx(missing) as never,
+		);
+		assert.equal(bad, null);
+		assert.equal(missing.length, 1);
+		assert.match(missing[0] ?? "", /outputSchema/i);
+	});
+
+	it("keeps a bare pipe in a -- task on the legacy single-agent path", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			"scout -- do x | y",
+			makeCtx(notifications) as never,
+		);
+		assert.ok(built);
+		if (!built) return;
+		assert.deepEqual(notifications, []);
+		assert.equal(built.chain.length, 1);
+		assert.equal(built.task, "do x | y");
+		assert.equal(
+			built.chain[0] && "task" in built.chain[0] ? built.chain[0].task : undefined,
+			"do x | y",
+		);
+	});
+
+	it("keeps unquoted parens in a -- task on the legacy single-agent path", () => {
+		// Regression: `/chain scout -- inspect auth (backend)` was wrongly rejected as a
+		// malformed group. Bare parens in the shared task must parse as plain task text.
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			"scout -- inspect auth (backend)",
+			makeCtx(notifications) as never,
+		);
+		assert.ok(built);
+		if (!built) return;
+		assert.deepEqual(notifications, []);
+		assert.equal(built.chain.length, 1);
+		assert.equal(built.task, "inspect auth (backend)");
+		assert.equal(
+			built.chain[0] && "task" in built.chain[0] ? built.chain[0].task : undefined,
+			"inspect auth (backend)",
+		);
+	});
+
+	it("allows balanced parens in a -- task after a group step", () => {
+		const notifications: string[] = [];
+		const built = buildChainExpressionSteps(
+			makeState(tempRoot) as never,
+			'scout "scan" -> (reviewer "A" | reviewer "B") -> writer -- fix (backend)',
+			makeCtx(notifications) as never,
+		);
+		assert.ok(built);
+		if (!built) return;
+		assert.deepEqual(notifications, []);
+		assert.equal(built.chain.length, 3);
+		assert.equal(built.task, "scan");
+	});
+
+	it("exports a stable parallel group usage hint", () => {
+		assert.match(PARALLEL_GROUP_USAGE, /Usage: \/chain/);
+		assert.match(PARALLEL_GROUP_USAGE, /\(/);
+		assert.match(PARALLEL_GROUP_USAGE, /\|/);
+	});
+});