@selesai/code 0.2.1 → 0.3.1

package/dist/extensions/pi-subagents/test/support/real-session-runner.ts

@@ -0,0 +1,285 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	type AssistantMessage,
+	type Context,
+	type FauxContentBlock,
+	type FauxResponseStep,
+	fauxAssistantMessage,
+	fauxText,
+	fauxToolCall,
+	registerFauxProvider,
+	type ToolCall,
+} from "@earendil-works/pi-ai";
+import {
+	type AgentSession,
+	type AgentSessionEvent,
+	type ModelRegistry,
+	createAgentSession,
+	DefaultResourceLoader,
+	SessionManager,
+	SettingsManager,
+} from "@selesai/code";
+
+const EXTENSION_PATH = fileURLToPath(new URL("../../src/extension/index.ts", import.meta.url));
+const CHILD_CLI_PATH = fileURLToPath(new URL("./real-session-child-cli.mjs", import.meta.url));
+
+export type FauxReply = string | FauxContentBlock | FauxContentBlock[] | AssistantMessage;
+export type FauxResponder = (context: Context, state: { callCount: number }) => FauxReply | Promise<FauxReply>;
+
+export interface RealSessionRunOptions {
+	prompt: string;
+	childText: string;
+	respond: FauxResponder;
+	timeoutMs?: number;
+}
+
+export interface RealSessionRun {
+	responseText: string;
+	parentSession: AgentSession;
+	modelCalls: number;
+	dispose: () => Promise<void>;
+}
+
+export function subagentCall(args: Record<string, unknown>, id = "call-subagent-e2e"): ToolCall {
+	return fauxToolCall("subagent", args, { id });
+}
+
+export function routeParentThroughSubagent(input: {
+	childMarker: string;
+	subagentArgs: Record<string, unknown>;
+}): FauxResponder {
+	return (context) => {
+		const isParent = (context.tools ?? []).some((tool) => tool.name === "subagent");
+		if (!isParent) return "Unexpected non-parent model call.";
+		const resultText = latestSubagentToolResultText(context.messages as Array<{ role?: string; toolName?: string; content?: unknown }>);
+		if (resultText !== undefined) {
+			return `Parent relays: ${resultText.includes(input.childMarker) ? input.childMarker : "CHILD_MISSING"}`;
+		}
+		return subagentCall(input.subagentArgs);
+	};
+}
+
+export function subagentToolResults(session: AgentSession): string[] {
+	const results: string[] = [];
+	for (const message of session.messages) {
+		if (message.role !== "toolResult") continue;
+		if ((message as { toolName?: string }).toolName !== "subagent") continue;
+		results.push(textFromContent((message as { content?: unknown }).content));
+	}
+	return results;
+}
+
+function latestSubagentToolResultText(messages: Array<{ role?: string; toolName?: string; content?: unknown }>): string | undefined {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i]!;
+		if (message.role === "toolResult" && message.toolName === "subagent") {
+			return textFromContent(message.content);
+		}
+	}
+	return undefined;
+}
+
+function textFromContent(content: unknown): string {
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((part) => part && typeof part === "object" && (part as { type?: unknown }).type === "text"
+			? String((part as { text?: unknown }).text ?? "")
+			: "")
+		.join("");
+}
+
+function toAssistantMessage(reply: FauxReply): AssistantMessage {
+	if (reply && typeof reply === "object" && "role" in reply) return reply as AssistantMessage;
+	const content: FauxContentBlock[] = typeof reply === "string" ? [fauxText(reply)] : Array.isArray(reply) ? reply : [reply];
+	const hasToolCall = content.some((block) => (block as { type?: string }).type === "toolCall");
+	return fauxAssistantMessage(content, { stopReason: hasToolCall ? "toolUse" : "stop" });
+}
+
+function createModelRegistry(model: { provider: string; id: string }) {
+	return {
+		find: (provider: string, id: string) => provider === model.provider && id === model.id ? model : undefined,
+		getAll: () => [model],
+		getAvailable: () => [model],
+		hasConfiguredAuth: () => true,
+		isUsingOAuth: () => false,
+		getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "faux", headers: {} }),
+		registerProvider: () => {},
+		unregisterProvider: () => {},
+	};
+}
+
+function installChildPiShim(childText: string): () => void {
+	const rootDir = mkdtempSync(path.join(os.tmpdir(), "pi-real-session-cli-"));
+	const binDir = path.join(rootDir, "bin");
+	const previousPath = process.env.PATH;
+	const previousChildText = process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT;
+	const previousArgv1 = process.argv[1];
+
+	writeFileSync(path.join(rootDir, ".keep"), "");
+	mkdirSync(binDir, { recursive: true });
+	writeFileSync(
+		path.join(binDir, "pi"),
+		`#!/bin/sh\nexec "${process.execPath}" "${CHILD_CLI_PATH}" "$@"\n`,
+		{ mode: 0o755 },
+	);
+	writeFileSync(
+		path.join(binDir, "pi.cmd"),
+		`@echo off\r\n"${process.execPath}" "${CHILD_CLI_PATH}" %*\r\n`,
+	);
+
+	process.env.PATH = `${binDir}${path.delimiter}${previousPath ?? ""}`;
+	process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT = childText;
+	if (process.platform === "win32") process.argv[1] = CHILD_CLI_PATH;
+
+	return () => {
+		if (previousPath === undefined) delete process.env.PATH;
+		else process.env.PATH = previousPath;
+		if (previousChildText === undefined) delete process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT;
+		else process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT = previousChildText;
+		if (process.platform === "win32") {
+			if (previousArgv1 === undefined) delete process.argv[1];
+			else process.argv[1] = previousArgv1;
+		}
+		rmSync(rootDir, { recursive: true, force: true });
+	};
+}
+
+function setEnv(name: string, value: string | undefined): void {
+	if (value === undefined) delete process.env[name];
+	else process.env[name] = value;
+}
+
+function restoreEnv(snapshot: Map<string, string | undefined>): void {
+	for (const [name, value] of snapshot) setEnv(name, value);
+}
+
+export async function runRealSubagentSession(options: RealSessionRunOptions): Promise<RealSessionRun> {
+	const cwd = mkdtempSync(path.join(os.tmpdir(), "pi-real-session-cwd-"));
+	const home = mkdtempSync(path.join(os.tmpdir(), "pi-real-session-home-"));
+	const previousCwd = process.cwd();
+	const envSnapshot = new Map([
+		["HOME", process.env.HOME],
+		["USERPROFILE", process.env.USERPROFILE],
+		["SELESAI_CODING_AGENT_DIR", process.env.SELESAI_CODING_AGENT_DIR],
+		["SELESAI_SUBAGENT_EXTRA_AGENT_DIRS", process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS],
+		["SELESAI_SUBAGENT_CHILD", process.env.SELESAI_SUBAGENT_CHILD],
+		["SELESAI_SUBAGENT_FANOUT_CHILD", process.env.SELESAI_SUBAGENT_FANOUT_CHILD],
+		["SELESAI_SUBAGENT_DEPTH", process.env.SELESAI_SUBAGENT_DEPTH],
+		["SELESAI_SUBAGENT_MAX_DEPTH", process.env.SELESAI_SUBAGENT_MAX_DEPTH],
+		["SELESAI_SUBAGENT_PARENT_SESSION", process.env.SELESAI_SUBAGENT_PARENT_SESSION],
+		["SELESAI_SUBAGENT_PI_BINARY", process.env.SELESAI_SUBAGENT_PI_BINARY],
+		["SELESAI_SUBAGENTS_PI_CODING_AGENT_PACKAGE_ROOT", process.env.SELESAI_SUBAGENTS_PI_CODING_AGENT_PACKAGE_ROOT],
+	]);
+	const uninstallChildPi = installChildPiShim(options.childText);
+	let session: AgentSession | undefined;
+	let faux: ReturnType<typeof registerFauxProvider> | undefined;
+	let disposed = false;
+
+	const dispose = async () => {
+		if (disposed) return;
+		disposed = true;
+		try {
+			await session?.extensionRunner.emit({ type: "session_shutdown", reason: "quit" });
+		} catch {}
+		try {
+			session?.dispose();
+		} catch {}
+		faux?.unregister();
+		uninstallChildPi();
+		restoreEnv(envSnapshot);
+		try {
+			process.chdir(previousCwd);
+		} catch {}
+		rmSync(cwd, { recursive: true, force: true });
+		rmSync(home, { recursive: true, force: true });
+	};
+
+	try {
+		process.chdir(cwd);
+		process.env.HOME = home;
+		process.env.USERPROFILE = home;
+		process.env.SELESAI_CODING_AGENT_DIR = home;
+		delete process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
+		delete process.env.SELESAI_SUBAGENT_CHILD;
+		delete process.env.SELESAI_SUBAGENT_FANOUT_CHILD;
+		delete process.env.SELESAI_SUBAGENT_DEPTH;
+		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+		delete process.env.SELESAI_SUBAGENT_PARENT_SESSION;
+		delete process.env.SELESAI_SUBAGENT_PI_BINARY;
+		delete process.env.SELESAI_SUBAGENTS_PI_CODING_AGENT_PACKAGE_ROOT;
+
+		faux = registerFauxProvider({
+			provider: "faux-e2e-parent",
+			models: [{ id: "parent", contextWindow: 200_000 }],
+		});
+		const model = faux.getModel();
+		const respond = options.respond;
+		const responseFactory: FauxResponseStep = async (context, _streamOptions, state) => toAssistantMessage(await respond(context, state));
+		faux.setResponses(Array.from({ length: 8 }, () => responseFactory));
+
+		const settingsManager = SettingsManager.inMemory({
+			compaction: { enabled: false },
+			retry: { enabled: false },
+		});
+		const loader = new DefaultResourceLoader({
+			cwd,
+			agentDir: home,
+			settingsManager,
+			additionalExtensionPaths: [EXTENSION_PATH],
+			noSkills: true,
+			noPromptTemplates: true,
+			noThemes: true,
+			noContextFiles: true,
+			systemPrompt: "You are an E2E parent. Delegate with the subagent tool, then report the tool result.",
+		});
+		await loader.reload();
+
+		const created = await createAgentSession({
+			cwd,
+			agentDir: home,
+			model,
+			modelRegistry: createModelRegistry(model) as unknown as ModelRegistry,
+			resourceLoader: loader,
+			sessionManager: SessionManager.create(cwd, path.join(home, "sessions")),
+			settingsManager,
+		});
+		session = created.session;
+		session.setSessionName("real-session-e2e-parent");
+
+		let responseText = "";
+		const unsubscribe = session.subscribe((event: AgentSessionEvent) => {
+			if (event.type === "message_start") responseText = "";
+			if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+				responseText += event.assistantMessageEvent.delta;
+			}
+		});
+
+		await session.bindExtensions({});
+		const timeoutMs = options.timeoutMs ?? 30_000;
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		try {
+			await Promise.race([
+				session.prompt(options.prompt, { expandPromptTemplates: false }),
+				new Promise<never>((_, reject) => {
+					timer = setTimeout(() => reject(new Error(`real-session E2E timed out after ${timeoutMs}ms`)), timeoutMs);
+				}),
+			]);
+		} finally {
+			if (timer) clearTimeout(timer);
+			unsubscribe();
+		}
+
+		return {
+			responseText: responseText.trim() || session.getLastAssistantText()?.trim() || "",
+			parentSession: session,
+			modelCalls: faux.state.callCount,
+			dispose,
+		};
+	} catch (error) {
+		await dispose();
+		throw error;
+	}
+}

package/dist/extensions/pi-subagents/test/support/register-loader.mjs

@@ -0,0 +1,15 @@
+/**
+ * Register the .js → .ts loader hook for integration tests.
+ *
+ * Usage: node --experimental-transform-types --import ./test/support/register-loader.mjs --test test/integration/*.test.ts
+ *
+ * Handles two issues:
+ * 1. Source files use .js import extensions (TypeScript ESM convention) but
+ *    files on disk are .ts — the loader rewrites .js → .ts at resolve time.
+ * 2. Some source files use TypeScript parameter properties (constructor(private x: T))
+ *    which require --experimental-transform-types (not just strip-types).
+ */
+
+import { register } from "node:module";
+
+register(new URL("./ts-loader.mjs", import.meta.url));

package/dist/extensions/pi-subagents/test/support/ts-loader.mjs

@@ -0,0 +1,108 @@
+// ESM loader hook: rewrite .js imports to .ts when the .js file doesn't exist
+// but a .ts file does. This bridges the gap between source-level .js extension
+// imports and the actual .ts files on disk.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const renderPiCodingAgentShim = `
+export function getMarkdownTheme() { return {}; }
+export function keyText(keybinding) { return keybinding === "app.tools.expand" ? "configured-expand-key" : ""; }
+`;
+
+const renderPiTuiShim = `
+function wrapText(text, width) {
+  if (!width || width <= 0) return [text];
+  const lines = [];
+  for (const rawLine of String(text).split("\\n")) {
+    if (rawLine.length === 0) {
+      lines.push("");
+      continue;
+    }
+    for (let i = 0; i < rawLine.length; i += width) {
+      lines.push(rawLine.slice(i, i + width));
+    }
+  }
+  return lines;
+}
+
+export function visibleWidth(text) {
+  return String(text).length;
+}
+
+export class Text {
+  constructor(text) {
+    this.text = text;
+  }
+
+  render(width) {
+    return wrapText(this.text, width);
+  }
+}
+
+export class Spacer {
+  constructor(lines = 1) {
+    this.lines = lines;
+  }
+
+  render() {
+    return Array.from({ length: this.lines }, () => "");
+  }
+}
+
+export class Markdown {
+  constructor(text) {
+    this.text = text;
+  }
+
+  render(width) {
+    return wrapText(this.text, width);
+  }
+}
+
+export class Container {
+  constructor() {
+    this.children = [];
+  }
+
+  addChild(child) {
+    this.children.push(child);
+  }
+
+  render(width) {
+    return this.children.flatMap((child) => child.render(width));
+  }
+}
+`;
+
+function asDataModule(source) {
+  return `data:text/javascript,${encodeURIComponent(source)}`;
+}
+
+export function resolve(specifier, context, nextResolve) {
+  if (context.parentURL?.endsWith("/render.ts")) {
+    if (specifier === "@selesai/code") {
+      return { url: asDataModule(renderPiCodingAgentShim), shortCircuit: true };
+    }
+    if (specifier === "@earendil-works/pi-tui") {
+      return { url: asDataModule(renderPiTuiShim), shortCircuit: true };
+    }
+  }
+
+  if (!specifier.startsWith(".") || !specifier.endsWith(".js")) {
+    return nextResolve(specifier, context);
+  }
+
+  const parentDir = context.parentURL
+    ? path.dirname(fileURLToPath(context.parentURL))
+    : process.cwd();
+  const jsPath = path.resolve(parentDir, specifier);
+  const tsPath = jsPath.replace(/\.js$/, ".ts");
+
+  if (!fs.existsSync(jsPath) && fs.existsSync(tsPath)) {
+    return nextResolve(specifier.replace(/\.js$/, ".ts"), context);
+  }
+
+  return nextResolve(specifier, context);
+}