@dungle-scrubs/tallow 0.8.0

package/extensions/__integration__/tasks-runtime.test.ts

@@ -0,0 +1,224 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import type { ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { ExtensionHarness } from "../../test-utils/extension-harness.js";
+import { registerTasksExtension } from "../tasks/commands/register-tasks-extension.js";
+import { TaskListStore } from "../tasks/state/index.js";
+
+const ORIGINAL_PI_IS_SUBAGENT = process.env.PI_IS_SUBAGENT;
+const ORIGINAL_PI_TEAM_NAME = process.env.PI_TEAM_NAME;
+
+/**
+ * Build a minimal extension context for direct tool execution in tests.
+ *
+ * @returns Stub extension context
+ */
+function createContext(): ExtensionContext {
+	return {
+		ui: {
+			async select() {
+				return undefined;
+			},
+			async confirm() {
+				return false;
+			},
+			async input() {
+				return undefined;
+			},
+			notify() {},
+			setStatus() {},
+			setWorkingMessage() {},
+			setWidget() {},
+			setFooter() {},
+			setHeader() {},
+			setTitle() {},
+			async custom() {
+				return undefined as never;
+			},
+			pasteToEditor() {},
+			setEditorText() {},
+			getEditorText() {
+				return "";
+			},
+			async editor() {
+				return undefined;
+			},
+			setEditorComponent() {},
+			get theme(): never {
+				throw new Error("Theme not available in tasks runtime tests");
+			},
+			getAllThemes() {
+				return [];
+			},
+			getTheme() {
+				return undefined;
+			},
+			setTheme() {
+				return { success: false, error: "Test stub" };
+			},
+			getToolsExpanded() {
+				return false;
+			},
+			setToolsExpanded() {},
+		} as ExtensionContext["ui"],
+		hasUI: false,
+		cwd: process.cwd(),
+		sessionManager: {
+			getEntries: () => [],
+			appendEntry: () => {},
+		} as never,
+		modelRegistry: {
+			getApiKeyForProvider: async () => undefined,
+		} as never,
+		model: undefined,
+		isIdle: () => true,
+		abort: () => {},
+		hasPendingMessages: () => false,
+		shutdown: () => {},
+		getContextUsage: () => undefined,
+		compact: () => {},
+		getSystemPrompt: () => "",
+	};
+}
+
+/**
+ * Extract first text block from a tool result payload.
+ *
+ * @param result - Tool result payload
+ * @returns Text block content
+ */
+function firstText(result: { content: Array<{ type: string; text?: string }> }): string {
+	const text = result.content.find((block) => block.type === "text");
+	if (!text?.text) throw new Error("Expected text tool result");
+	return text.text;
+}
+
+/**
+ * Read a required registered tool by name.
+ *
+ * @param harness - Extension harness instance
+ * @param name - Tool name
+ * @returns Registered tool definition
+ */
+function getTool(harness: ExtensionHarness, name: string): ToolDefinition {
+	const tool = harness.tools.get(name);
+	if (!tool) throw new Error(`Expected tool "${name}" to be registered`);
+	return tool;
+}
+
+/**
+ * Execute manage_tasks with a test context.
+ *
+ * @param tool - Registered manage_tasks tool
+ * @param params - Tool parameters
+ * @returns Tool execution result
+ */
+async function execManage(
+	tool: ToolDefinition,
+	params: Record<string, unknown>
+): Promise<{ content: Array<{ type: string; text?: string }>; details: unknown }> {
+	return (await tool.execute(
+		"test-tool-call",
+		params as never,
+		undefined,
+		undefined,
+		createContext()
+	)) as { content: Array<{ type: string; text?: string }>; details: unknown };
+}
+
+beforeEach(() => {
+	process.env.PI_IS_SUBAGENT = "1";
+	delete process.env.PI_TEAM_NAME;
+});
+
+afterEach(() => {
+	if (ORIGINAL_PI_IS_SUBAGENT === undefined) delete process.env.PI_IS_SUBAGENT;
+	else process.env.PI_IS_SUBAGENT = ORIGINAL_PI_IS_SUBAGENT;
+	if (ORIGINAL_PI_TEAM_NAME === undefined) delete process.env.PI_TEAM_NAME;
+	else process.env.PI_TEAM_NAME = ORIGINAL_PI_TEAM_NAME;
+});
+
+describe("Tasks runtime wiring", () => {
+	it("registers /tasks command and shortcut in main-agent mode", () => {
+		process.env.PI_IS_SUBAGENT = "0";
+		const harness = ExtensionHarness.create();
+		registerTasksExtension(harness.api, new TaskListStore(null), null);
+
+		expect(harness.commands.has("tasks")).toBe(true);
+		expect(harness.shortcuts.length).toBeGreaterThanOrEqual(1);
+		expect(harness.tools.has("manage_tasks")).toBe(true);
+	});
+
+	it("enforces busy-check when claiming multiple in-progress tasks for one owner", async () => {
+		const harness = ExtensionHarness.create();
+		registerTasksExtension(harness.api, new TaskListStore(null), null);
+		const manage = getTool(harness, "manage_tasks");
+
+		await execManage(manage, { action: "add", task: "Investigate flaky tests" });
+		await execManage(manage, { action: "add", task: "Write regression coverage" });
+
+		const claimFirst = await execManage(manage, { action: "claim", index: 1, owner: "alice" });
+		expect(firstText(claimFirst)).toContain("Claimed #1");
+
+		const claimSecond = await execManage(manage, { action: "claim", index: 2, owner: "alice" });
+		expect(firstText(claimSecond)).toContain("alice is busy with #1");
+	});
+
+	it("blocks completion when blockedBy dependencies are unmet", async () => {
+		const harness = ExtensionHarness.create();
+		registerTasksExtension(harness.api, new TaskListStore(null), null);
+		const manage = getTool(harness, "manage_tasks");
+
+		await execManage(manage, {
+			action: "add",
+			tasks: [{ subject: "Collect logs" }, { subject: "Patch production" }],
+		});
+		await execManage(manage, { action: "update", index: 2, addBlockedBy: ["1"] });
+
+		const blocked = await execManage(manage, { action: "complete", index: 2 });
+		expect(firstText(blocked)).toContain("blocked by tasks 1");
+	});
+
+	it("auto-completes and advances active task from turn_end completion markers", async () => {
+		const harness = ExtensionHarness.create();
+		registerTasksExtension(harness.api, new TaskListStore(null), null);
+		const manage = getTool(harness, "manage_tasks");
+
+		await execManage(manage, {
+			action: "add",
+			tasks: [{ subject: "Analyze outage" }, { subject: "Deploy fix" }],
+		});
+
+		await harness.fireEvent(
+			"turn_end",
+			{
+				message: {
+					role: "assistant",
+					content: [{ type: "text", text: "[DONE: #1]" }],
+				},
+			},
+			createContext()
+		);
+
+		const list = await execManage(manage, { action: "list" });
+		const listText = firstText(list);
+		expect(listText).toContain("1. [completed] Analyze outage");
+		expect(listText).toContain("2. [in_progress] Deploy fix");
+	});
+
+	it("injects active-task context before agent start and clears orphaned in-progress tasks on agent_end", async () => {
+		const harness = ExtensionHarness.create();
+		registerTasksExtension(harness.api, new TaskListStore(null), null);
+		const manage = getTool(harness, "manage_tasks");
+
+		await execManage(manage, { action: "add", task: "Finish migration" });
+
+		const [beforeStartResult] = await harness.fireEvent("before_agent_start", {}, createContext());
+		expect(beforeStartResult).toBeDefined();
+		const beforeStart = beforeStartResult as { message?: { content?: string } };
+		expect(beforeStart.message?.content).toContain("[ACTIVE TASKS]");
+
+		await harness.fireEvent("agent_end", {}, createContext());
+		const list = await execManage(manage, { action: "list" });
+		expect(firstText(list)).toBe("No tasks.");
+	});
+});

package/extensions/__integration__/teams-runtime.test.ts

@@ -0,0 +1,291 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import type { ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { ExtensionHarness } from "../../test-utils/extension-harness.js";
+import type { Teammate } from "../teams-tool/state/types.js";
+import {
+	addTaskToBoard,
+	archiveTeam,
+	createTeamStore,
+	getArchivedTeams,
+	getTeam,
+	getTeams,
+	type Team,
+} from "../teams-tool/store.js";
+import { registerTeamsToolExtension } from "../teams-tool/tools/register-extension.js";
+
+/**
+ * Read a required tool from harness registration.
+ *
+ * @param harness - Extension harness instance
+ * @param name - Tool name
+ * @returns Registered tool definition
+ */
+function getTool(harness: ExtensionHarness, name: string): ToolDefinition {
+	const tool = harness.tools.get(name);
+	if (!tool) throw new Error(`Expected tool "${name}" to be registered`);
+	return tool;
+}
+
+/**
+ * Extract first text content block from a tool result.
+ *
+ * @param result - Tool result payload
+ * @returns Text value
+ */
+function firstText(result: { content: Array<{ type: string; text?: string }> }): string {
+	const text = result.content.find((block) => block.type === "text");
+	if (!text?.text) throw new Error("Expected text tool result");
+	return text.text;
+}
+
+/**
+ * Execute a tool with optional abort signal.
+ *
+ * @param tool - Tool definition
+ * @param params - Tool params
+ * @param signal - Optional abort signal
+ * @returns Tool result
+ */
+async function execTool(
+	tool: ToolDefinition,
+	params: Record<string, unknown>,
+	signal?: AbortSignal
+): Promise<{ content: Array<{ type: string; text?: string }>; isError?: boolean }> {
+	return (await tool.execute(
+		"test-tool-call",
+		params as never,
+		signal,
+		undefined,
+		{} as ExtensionContext
+	)) as { content: Array<{ type: string; text?: string }>; isError?: boolean };
+}
+
+/**
+ * Build a minimal command context with captured notifications.
+ *
+ * @param hasUI - Whether UI is available
+ * @returns Context + notifications collector
+ */
+function createCommandContext(hasUI: boolean): {
+	ctx: ExtensionContext;
+	notifications: string[];
+} {
+	const notifications: string[] = [];
+	const ctx = {
+		hasUI,
+		ui: {
+			notify: (message: string) => {
+				notifications.push(message);
+			},
+			setEditorComponent() {},
+			setWorkingMessage() {},
+			setStatus() {},
+			get theme(): never {
+				throw new Error("theme not available in tests");
+			},
+		} as unknown as ExtensionContext["ui"],
+		cwd: process.cwd(),
+	} as ExtensionContext;
+	return { ctx, notifications };
+}
+
+/**
+ * Create a mock teammate with observable abort/dispose calls.
+ *
+ * @param name - Teammate name
+ * @param status - Runtime status
+ * @returns Teammate plus call log
+ */
+function mockTeammate(
+	name: string,
+	status: Teammate["status"]
+): { teammate: Teammate; calls: string[] } {
+	const calls: string[] = [];
+	const teammate: Teammate = {
+		name,
+		role: "test-role",
+		model: "test-model",
+		status,
+		session: {
+			isStreaming: false,
+			prompt: async () => {},
+			followUp: async () => {},
+			abort: async () => {
+				calls.push("abort");
+			},
+			dispose: () => {
+				calls.push("dispose");
+			},
+			messages: [],
+		} as unknown as Teammate["session"],
+	};
+	return { teammate, calls };
+}
+
+beforeEach(() => {
+	getTeams().clear();
+	getArchivedTeams().clear();
+});
+
+afterEach(() => {
+	getTeams().clear();
+	getArchivedTeams().clear();
+});
+
+describe("Teams runtime wiring", () => {
+	it("registers command + core tools and supports create/add/status flows", async () => {
+		const harness = ExtensionHarness.create();
+		registerTeamsToolExtension(harness.api);
+
+		expect(harness.commands.has("team-dashboard")).toBe(true);
+		for (const toolName of [
+			"team_create",
+			"team_add_tasks",
+			"team_spawn",
+			"team_send",
+			"team_status",
+			"team_shutdown",
+			"team_resume",
+		]) {
+			expect(harness.tools.has(toolName)).toBe(true);
+		}
+
+		const create = getTool(harness, "team_create");
+		const addTasks = getTool(harness, "team_add_tasks");
+		const status = getTool(harness, "team_status");
+
+		const missingTeam = await execTool(addTasks, {
+			team: "alpha",
+			tasks: [{ title: "Should fail" }],
+		});
+		expect(missingTeam.isError).toBe(true);
+		expect(firstText(missingTeam)).toContain('Team "alpha" not found.');
+
+		const created = await execTool(create, { name: "alpha" });
+		expect(firstText(created)).toContain('Team "alpha" created');
+
+		const duplicate = await execTool(create, { name: "alpha" });
+		expect(duplicate.isError).toBe(true);
+		expect(firstText(duplicate)).toContain("already exists");
+
+		const added = await execTool(addTasks, {
+			team: "alpha",
+			tasks: [{ title: "Collect logs" }, { title: "Draft fix", blockedBy: ["1"] }],
+		});
+		expect(firstText(added)).toContain("Added 2 task(s)");
+
+		const snapshot = await execTool(status, { team: "alpha" });
+		expect(firstText(snapshot)).toContain("#1 Collect logs [pending]");
+		expect(firstText(snapshot)).toContain("#2 Draft fix [pending]");
+	});
+
+	it("team_spawn surfaces model resolution failures without crashing runtime", async () => {
+		const harness = ExtensionHarness.create();
+		registerTeamsToolExtension(harness.api);
+
+		await execTool(getTool(harness, "team_create"), { name: "alpha" });
+		const spawn = getTool(harness, "team_spawn");
+		const result = await execTool(spawn, {
+			team: "alpha",
+			name: "alice",
+			role: "Researcher",
+			model: "zzz-nonexistent-qqq-xyzzy",
+		});
+
+		expect(result.isError).toBe(true);
+		expect(firstText(result)).toContain('Failed to spawn "alice"');
+		expect(firstText(result)).toContain("Model not found");
+	});
+
+	it("team_resume lists archives and restores claimed tasks as pending", async () => {
+		const harness = ExtensionHarness.create();
+		registerTeamsToolExtension(harness.api);
+
+		const team = createTeamStore("restore-me") as Team<Teammate>;
+		const task = addTaskToBoard(team, "Resume me", "desc", []);
+		task.status = "claimed";
+		task.assignee = "alice";
+		archiveTeam(team.name);
+
+		const resume = getTool(harness, "team_resume");
+
+		const list = await execTool(resume, {});
+		expect(firstText(list)).toContain("Archived Teams");
+		expect(firstText(list)).toContain("restore-me");
+
+		const restored = await execTool(resume, { team: "restore-me" });
+		expect(restored.isError).toBeUndefined();
+		expect(firstText(restored)).toContain('Team "restore-me" restored');
+
+		const active = getTeam("restore-me") as Team<Teammate>;
+		expect(active.tasks[0]?.status).toBe("pending");
+		expect(active.tasks[0]?.assignee).toBeNull();
+	});
+
+	it("session lifecycle handlers archive idle teams and preserve active work until shutdown", async () => {
+		const harness = ExtensionHarness.create();
+		registerTeamsToolExtension(harness.api);
+
+		const idleTeam = createTeamStore("idle-team") as Team<Teammate>;
+		const busyTeam = createTeamStore("busy-team") as Team<Teammate>;
+		const idle = mockTeammate("idle", "idle");
+		const working = mockTeammate("worker", "working");
+		idleTeam.teammates.set(idle.teammate.name, idle.teammate);
+		busyTeam.teammates.set(working.teammate.name, working.teammate);
+
+		await harness.fireEvent("agent_end", {});
+
+		expect(getTeam("idle-team")).toBeUndefined();
+		expect(getArchivedTeams().has("idle-team")).toBe(true);
+		expect(getTeam("busy-team")).toBeDefined();
+
+		await harness.fireEvent("session_shutdown", {});
+
+		expect(getTeam("busy-team")).toBeUndefined();
+		expect(getArchivedTeams().has("busy-team")).toBe(true);
+		expect(idle.calls).toContain("dispose");
+		expect(working.calls).toContain("dispose");
+		expect(working.teammate.status).toBe("shutdown");
+	});
+
+	it("team_send handles already-aborted signals and missing teammates", async () => {
+		const harness = ExtensionHarness.create();
+		registerTeamsToolExtension(harness.api);
+
+		const send = getTool(harness, "team_send");
+		const aborted = new AbortController();
+		aborted.abort();
+		const cancelled = await execTool(
+			send,
+			{ team: "alpha", to: "alice", message: "hello", wait: true },
+			aborted.signal
+		);
+		expect(cancelled.isError).toBe(true);
+		expect(firstText(cancelled)).toContain("cancelled before execution");
+
+		await execTool(getTool(harness, "team_create"), { name: "alpha" });
+		const missing = await execTool(send, {
+			team: "alpha",
+			to: "ghost",
+			message: "hello",
+		});
+		expect(missing.isError).toBe(true);
+		expect(firstText(missing)).toContain("not found in team");
+	});
+
+	it("team-dashboard command honors hasUI gate and reports status", async () => {
+		const harness = ExtensionHarness.create();
+		registerTeamsToolExtension(harness.api);
+		const command = harness.commands.get("team-dashboard");
+		if (!command) throw new Error("Expected team-dashboard command to be registered");
+
+		const hidden = createCommandContext(false);
+		await command.handler("status", hidden.ctx);
+		expect(hidden.notifications).toHaveLength(0);
+
+		const visible = createCommandContext(true);
+		await command.handler("status", visible.ctx);
+		expect(visible.notifications).toHaveLength(1);
+		expect(visible.notifications[0]).toContain("dashboard");
+	});
+});

package/extensions/__integration__/tools.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Integration tests for extension tool registration and execution.
+ *
+ * Verifies that tools registered by extensions appear in sessions,
+ * can be invoked by the mock model, and produce correct tool_call/tool_result events.
+ */
+import { afterEach, describe, expect, it } from "bun:test";
+import type { ExtensionAPI, ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { ExtensionHarness } from "../../test-utils/extension-harness.js";
+import { createScriptedStreamFn } from "../../test-utils/mock-model.js";
+import { createSessionRunner, type SessionRunner } from "../../test-utils/session-runner.js";
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+let runner: SessionRunner | undefined;
+
+afterEach(() => {
+	runner?.dispose();
+	runner = undefined;
+});
+
+/** Extension that registers a simple echo tool. */
+const echoToolExtension: ExtensionFactory = (pi: ExtensionAPI): void => {
+	pi.registerTool({
+		name: "echo_test",
+		label: "Echo Test",
+		description: "Echoes back the input for testing",
+		parameters: Type.Object({ message: Type.String() }),
+		async execute(_id, params, _signal, _onUpdate, _ctx) {
+			return {
+				content: [{ type: "text", text: `Echo: ${params.message}` }],
+				details: undefined,
+			};
+		},
+	});
+};
+
+/** Extension that registers a tool that returns an error. */
+const errorToolExtension: ExtensionFactory = (pi: ExtensionAPI): void => {
+	pi.registerTool({
+		name: "failing_tool",
+		label: "Failing Tool",
+		description: "Always fails",
+		parameters: Type.Object({}),
+		async execute(_id, _params, _signal, _onUpdate, _ctx) {
+			throw new Error("Something went wrong");
+		},
+	});
+};
+
+// ════════════════════════════════════════════════════════════════
+// Tool Registration (Harness-level)
+// ════════════════════════════════════════════════════════════════
+
+describe("Tool Registration (harness)", () => {
+	it("tracks tools registered by extensions", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(echoToolExtension);
+
+		const tool = harness.tools.get("echo_test");
+		expect(tool).toBeDefined();
+		if (!tool) throw new Error("unreachable");
+		expect(tool.label).toBe("Echo Test");
+		expect(tool.description).toContain("Echoes back");
+	});
+
+	it("tracks multiple tools from different extensions", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(echoToolExtension);
+		await harness.loadExtension(errorToolExtension);
+
+		expect(harness.tools.size).toBe(2);
+		expect(harness.tools.has("echo_test")).toBe(true);
+		expect(harness.tools.has("failing_tool")).toBe(true);
+	});
+});
+
+// ════════════════════════════════════════════════════════════════
+// Tool Execution (Session-level)
+// ════════════════════════════════════════════════════════════════
+
+describe("Tool Execution (session)", () => {
+	it("executes extension-registered tools via mock model", async () => {
+		const toolResults: string[] = [];
+
+		const resultTracker: ExtensionFactory = (pi: ExtensionAPI): void => {
+			pi.on("tool_result", async (event) => {
+				if (event.toolName === "echo_test") {
+					const text = event.content.find((c) => c.type === "text");
+					if (text?.type === "text") toolResults.push(text.text);
+				}
+			});
+		};
+
+		runner = await createSessionRunner({
+			streamFn: createScriptedStreamFn([
+				// First response: call the echo tool
+				{ toolCalls: [{ name: "echo_test", arguments: { message: "hello" } }] },
+				// Second response after tool result: text response
+				{ text: "Got the echo result" },
+			]),
+			extensionFactories: [echoToolExtension, resultTracker],
+		});
+
+		await runner.run("Call echo_test");
+
+		expect(toolResults).toHaveLength(1);
+		expect(toolResults[0]).toBe("Echo: hello");
+	});
+
+	it("fires tool_call events for extension tools", async () => {
+		const toolCallNames: string[] = [];
+
+		const callTracker: ExtensionFactory = (pi: ExtensionAPI): void => {
+			pi.on("tool_call", async (event) => {
+				toolCallNames.push(event.toolName);
+			});
+		};
+
+		runner = await createSessionRunner({
+			streamFn: createScriptedStreamFn([
+				{ toolCalls: [{ name: "echo_test", arguments: { message: "test" } }] },
+				{ text: "Done" },
+			]),
+			extensionFactories: [echoToolExtension, callTracker],
+		});
+
+		await runner.run("test");
+
+		expect(toolCallNames).toContain("echo_test");
+	});
+
+	it("handles error tool results", async () => {
+		const toolResults: Array<{ name: string; content: string; isError: boolean }> = [];
+
+		const tracker: ExtensionFactory = (pi: ExtensionAPI): void => {
+			pi.on("tool_result", async (event) => {
+				if (event.toolName === "failing_tool") {
+					const text = event.content.find((c) => c.type === "text");
+					toolResults.push({
+						name: event.toolName,
+						content: text?.type === "text" ? text.text : "",
+						isError: event.isError,
+					});
+				}
+			});
+		};
+
+		runner = await createSessionRunner({
+			streamFn: createScriptedStreamFn([
+				{ toolCalls: [{ name: "failing_tool", arguments: {} }] },
+				{ text: "Handled error" },
+			]),
+			extensionFactories: [errorToolExtension, tracker],
+		});
+
+		await runner.run("test");
+
+		expect(toolResults).toHaveLength(1);
+		expect(toolResults[0].name).toBe("failing_tool");
+		expect(toolResults[0].content).toContain("Something went wrong");
+	});
+
+	it("can block tool execution via tool_call handler", async () => {
+		const blockedTools: string[] = [];
+
+		const blocker: ExtensionFactory = (pi: ExtensionAPI): void => {
+			pi.on("tool_call", async (event) => {
+				if (event.toolName === "echo_test") {
+					blockedTools.push(event.toolName);
+					return { block: true, reason: "Blocked by test" };
+				}
+			});
+		};
+
+		runner = await createSessionRunner({
+			streamFn: createScriptedStreamFn([
+				{ toolCalls: [{ name: "echo_test", arguments: { message: "blocked" } }] },
+				{ text: "After block" },
+			]),
+			extensionFactories: [echoToolExtension, blocker],
+		});
+
+		await runner.run("test");
+
+		expect(blockedTools).toHaveLength(1);
+	});
+});