@melihmucuk/pi-crew 1.0.16 → 1.0.17

package/extension/index.ts

@@ -2,7 +2,8 @@ import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { crewRuntime } from "./runtime/crew-runtime.js";
-import { registerCrewIntegration } from "./integration.js";
+import { registerCrewMessageRenderers } from "./integration/register-renderers.js";
+import { registerCrewTools } from "./integration/register-tools.js";
 import { updateWidget } from "./status-widget.js";
 
 const extensionDir = dirname(fileURLToPath(import.meta.url));
@@ -59,5 +60,6 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
-	registerCrewIntegration(pi, crewRuntime, extensionDir);
+	registerCrewTools(pi, crewRuntime, extensionDir);
+	registerCrewMessageRenderers(pi);
 }

package/extension/integration/crew-tool-actions.ts

@@ -0,0 +1,306 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type {
+	AgentConfig,
+	AgentDiscoveryResult,
+	AgentDiscoveryWarning,
+} from "../agent-discovery.js";
+import type {
+	AbortOwnedResult,
+	ActiveAgentSummary,
+	CrewRuntime,
+} from "../runtime/crew-runtime.js";
+import { STATUS_ICON } from "../subagent-messages.js";
+
+export type CrewToolResult = AgentToolResult<unknown> & {
+	isError?: boolean;
+	terminate?: boolean;
+};
+
+export type CrewToolActionSideEffect =
+	| { type: "discovery-warnings"; warnings: AgentDiscoveryWarning[] }
+	| { type: "active-list-warning" };
+
+export interface CrewToolActionResponse {
+	result: CrewToolResult;
+	sideEffects: CrewToolActionSideEffect[];
+}
+
+export interface CrewToolActionContext {
+	cwd: string;
+	callerSessionId: string;
+}
+
+export interface CrewSpawnActionContext extends CrewToolActionContext {
+	model: Model<Api> | undefined;
+	modelRegistry: ModelRegistry;
+	agentDir: string;
+	parentSessionFile?: string;
+	onWarning?: (message: string) => void;
+}
+
+interface CrewToolRuntime {
+	spawn: CrewRuntime["spawn"];
+	abortAllOwned: CrewRuntime["abortAllOwned"];
+	abortOwned: CrewRuntime["abortOwned"];
+	respond: CrewRuntime["respond"];
+	done: CrewRuntime["done"];
+	getActiveSummariesForOwner: CrewRuntime["getActiveSummariesForOwner"];
+}
+
+interface CreateCrewToolActionsDeps {
+	crew: CrewToolRuntime;
+	discoverAgents: (cwd: string) => AgentDiscoveryResult;
+	extensionDir: string;
+}
+
+function toolError(text: string): CrewToolResult {
+	return {
+		content: [{ type: "text", text }],
+		isError: true,
+		details: { error: true },
+	};
+}
+
+function toolSuccess(
+	text: string,
+	details: Record<string, unknown> = {},
+	options: { terminate?: boolean } = {},
+): CrewToolResult {
+	return {
+		content: [{ type: "text", text }],
+		details,
+		...(options.terminate ? { terminate: true } : {}),
+	};
+}
+
+function response(
+	result: CrewToolResult,
+	sideEffects: CrewToolActionSideEffect[] = [],
+): CrewToolActionResponse {
+	return { result, sideEffects };
+}
+
+function discoveryWarningSideEffect(
+	warnings: AgentDiscoveryWarning[],
+): CrewToolActionSideEffect[] {
+	return warnings.length > 0 ? [{ type: "discovery-warnings", warnings }] : [];
+}
+
+function formatAbortToolMessage(result: AbortOwnedResult): string {
+	const parts: string[] = [];
+
+	if (result.abortedIds.length > 0) {
+		parts.push(`Aborted ${result.abortedIds.length} subagent(s): ${result.abortedIds.join(", ")}`);
+	}
+	if (result.missingIds.length > 0) {
+		parts.push(`Not found or already finished: ${result.missingIds.join(", ")}`);
+	}
+	if (result.foreignIds.length > 0) {
+		parts.push(`Belong to a different session: ${result.foreignIds.join(", ")}`);
+	}
+
+	return parts.join("\n");
+}
+
+function formatAvailableAgents(agents: AgentConfig[]): string[] {
+	if (agents.length === 0) {
+		return [
+			"No valid subagent definitions found. Add `.md` files to `<cwd>/.pi/agents/` or `~/.pi/agent/agents/`.",
+		];
+	}
+
+	return agents.flatMap((agent) => [
+		"",
+		`name: ${agent.name}`,
+		`description: ${agent.description}`,
+		`interactive: ${agent.interactive ? "true" : "false"}`,
+	]);
+}
+
+function formatWarnings(warnings: AgentDiscoveryWarning[]): string[] {
+	if (warnings.length === 0) return [];
+
+	return [
+		"",
+		"## Ignored subagent definitions",
+		...warnings.map((warning) => `- ${warning.message} (${warning.filePath})`),
+	];
+}
+
+function formatActiveAgents(running: ActiveAgentSummary[]): string[] {
+	if (running.length === 0) return ["No subagents currently active."];
+
+	return running.flatMap((agent) => {
+		const icon = STATUS_ICON[agent.status] ?? "❓";
+		return [
+			"",
+			`id: ${agent.id}`,
+			`name: ${agent.agentName}`,
+			`status: ${icon} ${agent.status}`,
+		];
+	});
+}
+
+export type CrewToolActions = ReturnType<typeof createCrewToolActions>;
+
+export function createCrewToolActions({
+	crew,
+	discoverAgents,
+	extensionDir,
+}: CreateCrewToolActionsDeps) {
+	return {
+		list(ctx: CrewToolActionContext): CrewToolActionResponse {
+			const { agents, warnings } = discoverAgents(ctx.cwd);
+			const running = crew.getActiveSummariesForOwner(ctx.callerSessionId);
+			const lines = [
+				"## Available Subagents",
+				...formatAvailableAgents(agents),
+				...formatWarnings(warnings),
+				"",
+				"## Active Subagents",
+				...formatActiveAgents(running),
+			];
+
+			return response(
+				{ content: [{ type: "text", text: lines.join("\n") }], details: {} },
+				[
+					...discoveryWarningSideEffect(warnings),
+					...(running.length > 0 ? [{ type: "active-list-warning" } as const] : []),
+				],
+			);
+		},
+
+		spawn(
+			params: { subagent: string; task: string },
+			ctx: CrewSpawnActionContext,
+		): CrewToolActionResponse {
+			const { agents, warnings } = discoverAgents(ctx.cwd);
+			const sideEffects = discoveryWarningSideEffect(warnings);
+			const subagent = agents.find(
+				(candidate) => candidate.name === params.subagent,
+			);
+
+			if (!subagent) {
+				const available =
+					agents.map((candidate) => candidate.name).join(", ") || "none";
+				return response(
+					toolError(
+						`Unknown subagent: "${params.subagent}". Available: ${available}`,
+					),
+					sideEffects,
+				);
+			}
+
+			const id = crew.spawn(
+				subagent,
+				params.task,
+				ctx.cwd,
+				ctx.callerSessionId,
+				{
+					model: ctx.model,
+					modelRegistry: ctx.modelRegistry,
+					agentDir: ctx.agentDir,
+					parentSessionFile: ctx.parentSessionFile,
+					onWarning: ctx.onWarning,
+				},
+				extensionDir,
+			);
+
+			return response(
+				toolSuccess(
+					`Subagent '${subagent.name}' spawned as ${id}. Result will be delivered as a steering message when done.`,
+					{ id, agentName: subagent.name, task: params.task },
+				),
+				sideEffects,
+			);
+		},
+
+		abort(
+			params: {
+				subagent_id?: string;
+				subagent_ids?: string[];
+				all?: boolean;
+			},
+			ctx: CrewToolActionContext,
+		): CrewToolActionResponse {
+			const modeCount = Number(Boolean(params.subagent_id))
+				+ Number(Boolean(params.subagent_ids?.length))
+				+ Number(params.all === true);
+
+			if (modeCount !== 1) {
+				return response(toolError(
+					"Provide exactly one of: subagent_id, subagent_ids, or all=true.",
+				));
+			}
+
+			if (params.all) {
+				const abortedIds = crew.abortAllOwned(ctx.callerSessionId, {
+					reason: "Aborted by tool request",
+				});
+				if (abortedIds.length === 0) {
+					return response(toolError("No active subagents in the current session."));
+				}
+
+				return response(toolSuccess(
+					`Aborted ${abortedIds.length} subagent(s): ${abortedIds.join(", ")}`,
+					{ ids: abortedIds },
+					{ terminate: true },
+				));
+			}
+
+			const ids = params.subagent_id
+				? [params.subagent_id]
+				: (params.subagent_ids ?? []);
+			const result = crew.abortOwned(ids, ctx.callerSessionId, {
+				reason: "Aborted by tool request",
+			});
+			const message = formatAbortToolMessage(result);
+
+			if (result.abortedIds.length === 0) {
+				return response(toolError(message || "No subagents were aborted."));
+			}
+
+			return response(toolSuccess(
+				message,
+				{
+					ids: result.abortedIds,
+					missing_ids: result.missingIds,
+					foreign_ids: result.foreignIds,
+				},
+				{ terminate: true },
+			));
+		},
+
+		respond(
+			params: { subagent_id: string; message: string },
+			ctx: CrewToolActionContext,
+		): CrewToolActionResponse {
+			const { error } = crew.respond(
+				params.subagent_id,
+				params.message,
+				ctx.callerSessionId,
+			);
+			if (error) return response(toolError(error));
+
+			return response(toolSuccess(
+				`Message sent to subagent ${params.subagent_id}. Response will be delivered as a steering message.`,
+				{ id: params.subagent_id, message: params.message },
+			));
+		},
+
+		done(
+			params: { subagent_id: string },
+			ctx: CrewToolActionContext,
+		): CrewToolActionResponse {
+			const { error } = crew.done(params.subagent_id, ctx.callerSessionId);
+			if (error) return response(toolError(error));
+
+			return response(toolSuccess(
+				`Subagent ${params.subagent_id} closed.`,
+				{ id: params.subagent_id },
+			));
+		},
+	};
+}

package/extension/integration/crew-tool-executor.ts

@@ -0,0 +1,109 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import type { AgentDiscoveryWarning } from "../agent-discovery.js";
+import { sendCrewListActiveWarning } from "../subagent-messages.js";
+import { renderCrewResult } from "./tool-presentation.js";
+import type {
+	CrewToolActionContext,
+	CrewToolActionResponse,
+	CrewToolActionSideEffect,
+	CrewToolActions,
+	CrewToolResult,
+} from "./crew-tool-actions.js";
+
+interface CrewToolExecutorDeps {
+	pi: ExtensionAPI;
+	notifyDiscoveryWarnings: (
+		ctx: ExtensionContext,
+		warnings: AgentDiscoveryWarning[],
+	) => void;
+}
+
+export interface CrewToolDeps {
+	pi: ExtensionAPI;
+	actions: CrewToolActions;
+	executor: CrewToolExecutor;
+}
+
+function getBaseActionContext(ctx: ExtensionContext): CrewToolActionContext {
+	return {
+		cwd: ctx.cwd,
+		callerSessionId: ctx.sessionManager.getSessionId(),
+	};
+}
+
+function runSideEffects(
+	deps: CrewToolExecutorDeps,
+	ctx: ExtensionContext,
+	sideEffects: CrewToolActionSideEffect[],
+): void {
+	for (const sideEffect of sideEffects) {
+		switch (sideEffect.type) {
+			case "discovery-warnings":
+				deps.notifyDiscoveryWarnings(ctx, sideEffect.warnings);
+				break;
+			case "active-list-warning":
+				Promise.resolve().then(() => {
+					sendCrewListActiveWarning(deps.pi.sendMessage.bind(deps.pi), {
+						isIdle: ctx.isIdle(),
+						triggerTurn: true,
+					});
+				});
+				break;
+		}
+	}
+}
+
+export class CrewToolExecutor {
+	constructor(private readonly deps: CrewToolExecutorDeps) {}
+
+	execute(
+		ctx: ExtensionContext,
+		runAction: (actionCtx: CrewToolActionContext) => CrewToolActionResponse,
+	): CrewToolResult {
+		const response = runAction(getBaseActionContext(ctx));
+		runSideEffects(this.deps, ctx, response.sideEffects);
+		return response.result;
+	}
+}
+
+type RegisteredTool = Parameters<ExtensionAPI["registerTool"]>[0];
+type ToolRenderCall = Exclude<RegisteredTool["renderCall"], undefined>;
+
+export function registerCrewActionTool<Params extends object>(
+	{ pi, executor }: CrewToolDeps,
+	options: Omit<RegisteredTool, "execute" | "renderResult" | "renderCall"> & {
+		action: (
+			params: Params,
+			actionCtx: CrewToolActionContext,
+			ctx: ExtensionContext,
+		) => CrewToolActionResponse;
+		renderCall?: (
+			args: Partial<Params>,
+			theme: Parameters<ToolRenderCall>[1],
+			context: Parameters<ToolRenderCall>[2],
+		) => ReturnType<ToolRenderCall>;
+	},
+): void {
+	const { action, renderCall, ...tool } = options;
+
+	pi.registerTool({
+		...tool,
+		...(renderCall
+			? {
+				renderCall: (args, theme, context) =>
+					renderCall(args as Partial<Params>, theme, context),
+			}
+			: {}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			return executor.execute(ctx, (actionCtx) =>
+				action(params as Params, actionCtx, ctx),
+			);
+		},
+		renderResult(result, _options, theme, _context) {
+			return renderCrewResult(result, theme);
+		},
+	});
+}

package/extension/integration/register-tools.ts

@@ -2,8 +2,10 @@ import type {
 	ExtensionAPI,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { type AgentDiscoveryWarning } from "../agent-discovery.js";
+import { discoverAgents, type AgentDiscoveryWarning } from "../agent-discovery.js";
 import type { CrewRuntime } from "../runtime/crew-runtime.js";
+import { createCrewToolActions } from "./crew-tool-actions.js";
+import { CrewToolExecutor } from "./crew-tool-executor.js";
 import { registerCrewAbortTool } from "./tools/crew-abort.js";
 import { registerCrewDoneTool } from "./tools/crew-done.js";
 import { registerCrewListTool } from "./tools/crew-list.js";
@@ -30,7 +32,13 @@ export function registerCrewTools(
 		}
 	};
 
-	const deps = { pi, crew, extensionDir, notifyDiscoveryWarnings };
+	const actions = createCrewToolActions({
+		crew,
+		discoverAgents,
+		extensionDir,
+	});
+	const executor = new CrewToolExecutor({ pi, notifyDiscoveryWarnings });
+	const deps = { pi, actions, executor };
 	registerCrewListTool(deps);
 	registerCrewSpawnTool(deps);
 	registerCrewAbortTool(deps);

package/extension/integration/tool-presentation.ts

@@ -5,26 +5,6 @@ import { Box, Text } from "@earendil-works/pi-tui";
 export type ToolTheme = Parameters<Exclude<Parameters<ExtensionAPI["registerTool"]>[0]["renderCall"], undefined>>[1];
 export type ToolResult = AgentToolResult<unknown>;
 
-export function toolError(text: string) {
-	return {
-		content: [{ type: "text" as const, text }],
-		isError: true,
-		details: { error: true },
-	};
-}
-
-export function toolSuccess(
-	text: string,
-	details: Record<string, unknown> = {},
-	options: { terminate?: boolean } = {},
-) {
-	return {
-		content: [{ type: "text" as const, text }],
-		details,
-		...(options.terminate ? { terminate: true } : {}),
-	};
-}
-
 export function renderCrewCall(
 	theme: ToolTheme,
 	name: string,

package/extension/integration/tools/crew-abort.ts

@@ -1,34 +1,18 @@
 import { Type } from "typebox";
+import { renderCrewCall } from "../tool-presentation.js";
 import {
-	renderCrewCall,
-	renderCrewResult,
-	toolError,
-	toolSuccess,
-} from "../tool-presentation.js";
-import type { CrewToolDeps } from "./tool-deps.js";
-
-function formatAbortToolMessage(result: {
-	abortedIds: string[];
-	missingIds: string[];
-	foreignIds: string[];
-}): string {
-	const parts: string[] = [];
-
-	if (result.abortedIds.length > 0) {
-		parts.push(`Aborted ${result.abortedIds.length} subagent(s): ${result.abortedIds.join(", ")}`);
-	}
-	if (result.missingIds.length > 0) {
-		parts.push(`Not found or already finished: ${result.missingIds.join(", ")}`);
-	}
-	if (result.foreignIds.length > 0) {
-		parts.push(`Belong to a different session: ${result.foreignIds.join(", ")}`);
-	}
-
-	return parts.join("\n");
-}
-
-export function registerCrewAbortTool({ pi, crew }: CrewToolDeps): void {
-	pi.registerTool({
+	registerCrewActionTool,
+	type CrewToolDeps,
+} from "../crew-tool-executor.js";
+
+type CrewAbortParams = {
+	subagent_id?: string;
+	subagent_ids?: string[];
+	all?: boolean;
+};
+
+export function registerCrewAbortTool(deps: CrewToolDeps): void {
+	registerCrewActionTool<CrewAbortParams>(deps, {
 		name: "crew_abort",
 		label: "Abort Crew",
 		description:
@@ -55,57 +39,7 @@ export function registerCrewAbortTool({ pi, crew }: CrewToolDeps): void {
 			"crew_abort: Provide exactly one mode: subagent_id, subagent_ids, or all=true.",
 			"crew_abort: Use only when delegated work is obsolete, wrong, or explicitly cancelled.",
 		],
-
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			const callerSessionId = ctx.sessionManager.getSessionId();
-			const modeCount = Number(Boolean(params.subagent_id))
-				+ Number(Boolean(params.subagent_ids?.length))
-				+ Number(params.all === true);
-
-			if (modeCount !== 1) {
-				return toolError(
-					"Provide exactly one of: subagent_id, subagent_ids, or all=true.",
-				);
-			}
-
-			if (params.all) {
-				const abortedIds = crew.abortAllOwned(callerSessionId, {
-					reason: "Aborted by tool request",
-				});
-				if (abortedIds.length === 0) {
-					return toolError("No active subagents in the current session.");
-				}
-
-				return toolSuccess(
-					`Aborted ${abortedIds.length} subagent(s): ${abortedIds.join(", ")}`,
-					{ ids: abortedIds },
-					{ terminate: true },
-				);
-			}
-
-			const ids = params.subagent_id
-				? [params.subagent_id]
-				: (params.subagent_ids ?? []);
-			const result = crew.abortOwned(ids, callerSessionId, {
-				reason: "Aborted by tool request",
-			});
-			const message = formatAbortToolMessage(result);
-
-			if (result.abortedIds.length === 0) {
-				return toolError(message || "No subagents were aborted.");
-			}
-
-			return toolSuccess(
-				message,
-				{
-					ids: result.abortedIds,
-					missing_ids: result.missingIds,
-					foreign_ids: result.foreignIds,
-				},
-				{ terminate: true },
-			);
-		},
-
+		action: (params, actionCtx) => deps.actions.abort(params, actionCtx),
 		renderCall(args, theme, _context) {
 			if (args.all) {
 				return renderCrewCall(theme, "crew_abort", "all");
@@ -118,9 +52,5 @@ export function registerCrewAbortTool({ pi, crew }: CrewToolDeps): void {
 			const count = Array.isArray(args.subagent_ids) ? args.subagent_ids.length : 0;
 			return renderCrewCall(theme, "crew_abort", `${count} ids`);
 		},
-
-		renderResult(result, _options, theme, _context) {
-			return renderCrewResult(result, theme);
-		},
 	});
 }

package/extension/integration/tools/crew-done.ts

@@ -1,14 +1,12 @@
 import { Type } from "typebox";
+import { renderCrewCall } from "../tool-presentation.js";
 import {
-	renderCrewCall,
-	renderCrewResult,
-	toolError,
-	toolSuccess,
-} from "../tool-presentation.js";
-import type { CrewToolDeps } from "./tool-deps.js";
+	registerCrewActionTool,
+	type CrewToolDeps,
+} from "../crew-tool-executor.js";
 
-export function registerCrewDoneTool({ pi, crew }: CrewToolDeps): void {
-	pi.registerTool({
+export function registerCrewDoneTool(deps: CrewToolDeps): void {
+	registerCrewActionTool<{ subagent_id: string }>(deps, {
 		name: "crew_done",
 		label: "Done with Crew",
 		description:
@@ -21,26 +19,9 @@ export function registerCrewDoneTool({ pi, crew }: CrewToolDeps): void {
 			"crew_done: Close a waiting interactive subagent owned by this session.",
 			"crew_done: Use only when no further follow-up is needed; otherwise use crew_respond.",
 		],
-
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			const callerSessionId = ctx.sessionManager.getSessionId();
-			const { error } = crew.done(params.subagent_id, callerSessionId);
-			if (error) return toolError(error);
-
-			return toolSuccess(
-				`Subagent ${params.subagent_id} closed.`,
-				{
-					id: params.subagent_id,
-				},
-			);
-		},
-
+		action: (params, actionCtx) => deps.actions.done(params, actionCtx),
 		renderCall(args, theme, _context) {
 			return renderCrewCall(theme, "crew_done", args.subagent_id || "...");
 		},
-
-		renderResult(result, _options, theme, _context) {
-			return renderCrewResult(result, theme);
-		},
 	});
 }