@melihmucuk/pi-crew 1.0.13 → 1.0.15

package/extension/bootstrap-session.ts

@@ -0,0 +1,131 @@
+import {
+  type AgentSession,
+  createAgentSession,
+  DefaultResourceLoader,
+  type ModelRegistry,
+  SessionManager,
+  SettingsManager,
+} from "@mariozechner/pi-coding-agent";
+import type { Api, Model } from "@mariozechner/pi-ai";
+import type { AgentConfig } from "./agent-discovery.js";
+import { SUPPORTED_TOOL_NAMES, type SupportedToolName } from "./tool-registry.js";
+
+function resolveTools(agentConfig: AgentConfig): SupportedToolName[] {
+  return [...(agentConfig.tools ?? SUPPORTED_TOOL_NAMES)];
+}
+
+function resolveModel(agentConfig: AgentConfig, ctx: BootstrapContext): { model: Model<Api> | undefined; warnings: string[] } {
+  const warnings: string[] = [];
+  const model = ctx.model;
+  if (!agentConfig.parsedModel) return { model, warnings };
+
+  const found = ctx.modelRegistry.find(
+    agentConfig.parsedModel.provider,
+    agentConfig.parsedModel.modelId,
+  );
+  if (found) return { model: found, warnings };
+
+  warnings.push(
+    `Model "${agentConfig.model}" not found, using current session model`,
+  );
+  return { model, warnings };
+}
+
+function getSkillWarnings(
+  agentConfig: AgentConfig,
+  resourceLoader: DefaultResourceLoader,
+): string[] {
+  const warnings: string[] = [];
+  if (!agentConfig.skills) return warnings;
+
+  const availableSkillNames = new Set(
+    resourceLoader.getSkills().skills.map((skill) => skill.name),
+  );
+  for (const skillName of agentConfig.skills) {
+    if (!availableSkillNames.has(skillName)) {
+      warnings.push(
+        `Unknown skill "${skillName}" in subagent config, skipping`,
+      );
+    }
+  }
+  return warnings;
+}
+
+export interface BootstrapContext {
+  model: Model<Api> | undefined;
+  modelRegistry: ModelRegistry;
+  agentDir: string;
+  parentSessionFile?: string;
+}
+
+interface BootstrapOptions {
+  agentConfig: AgentConfig;
+  cwd: string;
+  ctx: BootstrapContext;
+  extensionResolvedPath: string;
+}
+
+export interface BootstrapResult {
+  session: AgentSession;
+  warnings: string[];
+}
+
+export async function bootstrapSession(
+  opts: BootstrapOptions,
+): Promise<BootstrapResult> {
+  const warnings: string[] = [];
+  const { agentConfig, cwd, ctx, extensionResolvedPath } = opts;
+
+  const authStorage = ctx.modelRegistry.authStorage;
+  const modelRegistry = ctx.modelRegistry;
+  const { model, warnings: modelWarnings } = resolveModel(agentConfig, ctx);
+  warnings.push(...modelWarnings);
+  const tools = resolveTools(agentConfig);
+
+  const resourceLoader = new DefaultResourceLoader({
+    cwd,
+    agentDir: ctx.agentDir,
+    extensionsOverride: (base) => ({
+      ...base,
+      extensions: base.extensions.filter(
+        (ext) => !ext.resolvedPath.startsWith(extensionResolvedPath),
+      ),
+    }),
+    skillsOverride: agentConfig.skills
+      ? (base) => ({
+          skills: base.skills.filter((skill) =>
+            agentConfig.skills!.includes(skill.name),
+          ),
+          diagnostics: base.diagnostics,
+        })
+      : undefined,
+    appendSystemPromptOverride: (base) =>
+      agentConfig.systemPrompt.trim()
+        ? [...base, agentConfig.systemPrompt]
+        : base,
+  });
+  await resourceLoader.reload();
+  warnings.push(...getSkillWarnings(agentConfig, resourceLoader));
+
+  const settingsManager = SettingsManager.inMemory({
+    compaction: { enabled: agentConfig.compaction ?? true },
+  });
+
+  const sessionManager = SessionManager.create(cwd);
+  sessionManager.newSession({ parentSession: ctx.parentSessionFile });
+
+  const result = await createAgentSession({
+    cwd,
+    agentDir: ctx.agentDir,
+    model,
+    thinkingLevel: agentConfig.thinking,
+    tools,
+    resourceLoader,
+    sessionManager,
+    settingsManager,
+    authStorage,
+    modelRegistry,
+  });
+
+  return { session: result.session, warnings };
+}

package/extension/index.ts

@@ -0,0 +1,63 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { crewRuntime } from "./runtime/crew-runtime.js";
+import { registerCrewIntegration } from "./integration.js";
+import { updateWidget } from "./status-widget.js";
+
+const extensionDir = dirname(fileURLToPath(import.meta.url));
+
+// Process-level cleanup for subagents on exit
+const processHooksSetupKey = Symbol.for("pi-crew.processHooksSetup");
+const globalWithProcessHooks = globalThis as typeof globalThis & Record<
+	symbol,
+	boolean | undefined
+>;
+
+function setupProcessHooks() {
+	if (globalWithProcessHooks[processHooksSetupKey]) return;
+	globalWithProcessHooks[processHooksSetupKey] = true;
+
+	process.once('SIGINT', () => {
+		crewRuntime.abortAll();
+		process.exit(130);
+	});
+	process.on('beforeExit', () => crewRuntime.abortAll());
+}
+
+export default function (pi: ExtensionAPI) {
+	let currentCtx: ExtensionContext | undefined;
+
+	setupProcessHooks();
+
+	const refreshWidget = () => {
+		if (currentCtx) updateWidget(currentCtx, crewRuntime);
+	};
+
+	const activateSession = (ctx: ExtensionContext) => {
+		currentCtx = ctx;
+		crewRuntime.activateSession(
+			{
+				sessionId: ctx.sessionManager.getSessionId(),
+				isIdle: () => ctx.isIdle(),
+				sendMessage: pi.sendMessage.bind(pi),
+			},
+			refreshWidget,
+		);
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		activateSession(ctx);
+	});
+
+	pi.on("session_shutdown", (event, ctx) => {
+		const sessionId = ctx.sessionManager.getSessionId();
+		crewRuntime.deactivateSession(sessionId);
+
+		if (event.reason === "quit") {
+			crewRuntime.abortAll();
+		}
+	});
+
+	registerCrewIntegration(pi, crewRuntime, extensionDir);
+}

package/extension/integration/register-renderers.ts

@@ -0,0 +1,77 @@
+import {
+	type ExtensionAPI,
+	getMarkdownTheme,
+} from "@mariozechner/pi-coding-agent";
+import { Box, Markdown, Text } from "@mariozechner/pi-tui";
+import {
+	type CrewResultMessageDetails,
+	STATUS_ICON,
+	getCrewResultTitle,
+} from "../subagent-messages.js";
+
+type MessageRenderer = Parameters<ExtensionAPI["registerMessageRenderer"]>[1];
+type MessageRendererTheme = Parameters<MessageRenderer>[2];
+
+function getStatusColor(status: CrewResultMessageDetails["status"]): "success" | "error" | "warning" | "muted" {
+	switch (status) {
+		case "done":
+			return "success";
+		case "error":
+		case "aborted":
+			return "error";
+		case "running":
+		case "waiting":
+			return "warning";
+		default:
+			return "muted";
+	}
+}
+
+function renderWarningMessage(content: unknown, theme: MessageRendererTheme): Box {
+	const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+	box.addChild(new Text(theme.fg("warning", String(content ?? "")), 0, 0));
+	return box;
+}
+
+export function registerCrewMessageRenderers(pi: ExtensionAPI): void {
+	pi.registerMessageRenderer("crew-result", (message, { expanded }, theme) => {
+		const details = message.details as CrewResultMessageDetails | undefined;
+		const title = details ? getCrewResultTitle(details) : "Subagent update";
+		const icon = details
+			? theme.fg(getStatusColor(details.status), STATUS_ICON[details.status])
+			: theme.fg("muted", "ℹ");
+		const header = `${icon} ${theme.fg("toolTitle", theme.bold(title))}`;
+		const body = details?.body ?? (!details && message.content ? String(message.content) : undefined);
+
+		const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+		box.addChild(new Text(header, 0, 0));
+
+		if (details?.sessionFile) {
+			box.addChild(new Text(theme.fg("muted", `📁 ${details.sessionFile}`), 0, 0));
+		}
+
+		if (body) {
+			if (expanded) {
+				box.addChild(new Text("", 0, 0));
+				box.addChild(new Markdown(body, 0, 0, getMarkdownTheme()));
+			} else {
+				const lines = body.split("\n");
+				const preview = lines.slice(0, 5).join("\n");
+				box.addChild(new Text(theme.fg("dim", preview), 0, 0));
+				if (lines.length > 5) {
+					box.addChild(new Text(theme.fg("muted", "(Ctrl+O to expand)"), 0, 0));
+				}
+			}
+		}
+
+		return box;
+	});
+
+	pi.registerMessageRenderer("crew-remaining", (message, _options, theme) => {
+		return renderWarningMessage(message.content, theme);
+	});
+
+	pi.registerMessageRenderer("crew-list-warning", (message, _options, theme) => {
+		return renderWarningMessage(message.content, theme);
+	});
+}

package/extension/integration/register-tools.ts

@@ -0,0 +1,39 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import { type AgentDiscoveryWarning } from "../agent-discovery.js";
+import type { CrewRuntime } from "../runtime/crew-runtime.js";
+import { registerCrewAbortTool } from "./tools/crew-abort.js";
+import { registerCrewDoneTool } from "./tools/crew-done.js";
+import { registerCrewListTool } from "./tools/crew-list.js";
+import { registerCrewRespondTool } from "./tools/crew-respond.js";
+import { registerCrewSpawnTool } from "./tools/crew-spawn.js";
+
+export function registerCrewTools(
+	pi: ExtensionAPI,
+	crew: CrewRuntime,
+	extensionDir: string,
+): void {
+	const shownDiscoveryWarnings = new Set<string>();
+
+	const notifyDiscoveryWarnings = (
+		ctx: ExtensionContext,
+		warnings: AgentDiscoveryWarning[],
+	) => {
+		if (!ctx.hasUI) return;
+		for (const warning of warnings) {
+			const key = `${warning.filePath}:${warning.message}`;
+			if (shownDiscoveryWarnings.has(key)) continue;
+			shownDiscoveryWarnings.add(key);
+			ctx.ui.notify(`${warning.message} (${warning.filePath})`, "error");
+		}
+	};
+
+	const deps = { pi, crew, extensionDir, notifyDiscoveryWarnings };
+	registerCrewListTool(deps);
+	registerCrewSpawnTool(deps);
+	registerCrewAbortTool(deps);
+	registerCrewRespondTool(deps);
+	registerCrewDoneTool(deps);
+}

package/extension/integration/tool-presentation.ts

@@ -0,0 +1,50 @@
+import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Box, Text } from "@mariozechner/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,
+	id: string,
+	preview?: string,
+): Box {
+	const box = new Box(1, 1);
+	box.addChild(new Text(theme.fg("toolTitle", theme.bold(`${name} `)) + theme.fg("accent", id), 0, 0));
+	if (preview) {
+		box.addChild(new Text(theme.fg("dim", preview), 0, 0));
+	}
+	return box;
+}
+
+export function renderCrewResult(
+	result: ToolResult,
+	theme: ToolTheme,
+): Text {
+	const text = result.content[0];
+	const details = result.details as { error?: boolean } | undefined;
+	const content = text?.type === "text" && text.text ? text.text : "(no output)";
+	return new Text(details?.error ? theme.fg("error", content) : theme.fg("success", content), 0, 0);
+}

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

@@ -0,0 +1,126 @@
+import { Type } from "typebox";
+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({
+		name: "crew_abort",
+		label: "Abort Crew",
+		description:
+			"Abort one, many, or all active subagents owned by the current session.",
+		parameters: Type.Object({
+			subagent_id: Type.Optional(
+				Type.String({ description: "Single subagent ID to abort" }),
+			),
+			subagent_ids: Type.Optional(
+				Type.Array(Type.String(), {
+					minItems: 1,
+					description: "Multiple subagent IDs to abort",
+				}),
+			),
+			all: Type.Optional(
+				Type.Boolean({
+					description: "Abort all active subagents owned by the current session",
+				}),
+			),
+		}),
+		promptSnippet: "Abort one, many, or all active subagents from this session.",
+		promptGuidelines: [
+			"crew_abort: Abort one, many, or all active subagents owned by this session.",
+			"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 },
+			);
+		},
+
+		renderCall(args, theme, _context) {
+			if (args.all) {
+				return renderCrewCall(theme, "crew_abort", "all");
+			}
+
+			if (args.subagent_id) {
+				return renderCrewCall(theme, "crew_abort", args.subagent_id);
+			}
+
+			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

@@ -0,0 +1,46 @@
+import { Type } from "typebox";
+import {
+	renderCrewCall,
+	renderCrewResult,
+	toolError,
+	toolSuccess,
+} from "../tool-presentation.js";
+import type { CrewToolDeps } from "./tool-deps.js";
+
+export function registerCrewDoneTool({ pi, crew }: CrewToolDeps): void {
+	pi.registerTool({
+		name: "crew_done",
+		label: "Done with Crew",
+		description:
+			"Close an interactive subagent session. Use when you no longer need to interact with the subagent.",
+		parameters: Type.Object({
+			subagent_id: Type.String({ description: "ID of the subagent to close" }),
+		}),
+		promptSnippet: "Close an interactive subagent session when done.",
+		promptGuidelines: [
+			"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,
+				},
+			);
+		},
+
+		renderCall(args, theme, _context) {
+			return renderCrewCall(theme, "crew_done", args.subagent_id || "...");
+		},
+
+		renderResult(result, _options, theme, _context) {
+			return renderCrewResult(result, theme);
+		},
+	});
+}

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

@@ -0,0 +1,92 @@
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "typebox";
+import { discoverAgents } from "../../agent-discovery.js";
+import { STATUS_ICON, sendCrewListActiveWarning } from "../../subagent-messages.js";
+import type { CrewToolDeps } from "./tool-deps.js";
+
+export function registerCrewListTool({
+	pi,
+	crew,
+	notifyDiscoveryWarnings,
+}: CrewToolDeps): void {
+	pi.registerTool({
+		name: "crew_list",
+		label: "List Crew",
+		description:
+			"List available subagent definitions and currently running subagents with their status. Use only to discover which subagents exist or to get a one-time status snapshot. Do NOT call this repeatedly to check if a subagent has finished — results are delivered automatically as steering messages.",
+		parameters: Type.Object({}),
+		promptSnippet: "List subagent definitions and active subagents",
+		promptGuidelines: [
+			"crew_list: List available subagents and active subagents owned by this session.",
+			"crew_list: Use before crew_spawn to discover names, descriptions, and interactive status.",
+			"crew_list: Use only for discovery or a requested status snapshot; do not poll for completion.",
+		],
+
+		async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+			const { agents, warnings } = discoverAgents(ctx.cwd);
+			notifyDiscoveryWarnings(ctx, warnings);
+			const callerSessionId = ctx.sessionManager.getSessionId();
+			const running = crew.getActiveSummariesForOwner(callerSessionId);
+
+			const lines: string[] = [];
+
+			lines.push("## Available Subagents");
+			if (agents.length === 0) {
+				lines.push(
+					"No valid subagent definitions found. Add `.md` files to `<cwd>/.pi/agents/` or `~/.pi/agent/agents/`.",
+				);
+			} else {
+				for (const agent of agents) {
+					lines.push("");
+					lines.push(`name: ${agent.name}`);
+					lines.push(`description: ${agent.description}`);
+					lines.push(`interactive: ${agent.interactive ? "true" : "false"}`);
+				}
+			}
+
+			if (warnings.length > 0) {
+				lines.push("");
+				lines.push("## Ignored subagent definitions");
+				for (const warning of warnings) {
+					lines.push(`- ${warning.message} (${warning.filePath})`);
+				}
+			}
+
+			lines.push("");
+			lines.push("## Active Subagents");
+			if (running.length === 0) {
+				lines.push("No subagents currently active.");
+			} else {
+				for (const agent of running) {
+					const icon = STATUS_ICON[agent.status] ?? "❓";
+					lines.push("");
+					lines.push(`id: ${agent.id}`);
+					lines.push(`name: ${agent.agentName}`);
+					lines.push(`status: ${icon} ${agent.status}`);
+				}
+			}
+
+			const text = lines.join("\n");
+
+			if (running.length > 0) {
+				Promise.resolve().then(() => {
+					sendCrewListActiveWarning(pi.sendMessage.bind(pi), {
+						isIdle: ctx.isIdle(),
+						triggerTurn: true,
+					});
+				});
+			}
+
+			return { content: [{ type: "text", text }], details: {} };
+		},
+
+		renderCall(_args, theme, _context) {
+			return new Text(theme.fg("toolTitle", theme.bold("crew_list")), 0, 0);
+		},
+
+		renderResult(result, _options, _theme, _context) {
+			const text = result.content[0];
+			return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+		},
+	});
+}

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

@@ -0,0 +1,59 @@
+import { Type } from "typebox";
+import {
+	renderCrewCall,
+	renderCrewResult,
+	toolError,
+	toolSuccess,
+} from "../tool-presentation.js";
+import type { CrewToolDeps } from "./tool-deps.js";
+
+export function registerCrewRespondTool({ pi, crew }: CrewToolDeps): void {
+	pi.registerTool({
+		name: "crew_respond",
+		label: "Respond to Crew",
+		description:
+			"Send a follow-up message to an interactive subagent that is waiting for a response.",
+		parameters: Type.Object({
+			subagent_id: Type.String({
+				description:
+					"ID of the waiting subagent (from crew_list or crew_spawn result)",
+			}),
+			message: Type.String({ description: "Message to send to the subagent" }),
+		}),
+		promptSnippet:
+			"Send a follow-up message to a waiting interactive subagent.",
+		promptGuidelines: [
+			"crew_respond: Send a complete follow-up message to a waiting interactive subagent.",
+			"crew_respond: Use the waiting subagent ID from crew_spawn results or crew_list.",
+			"crew_respond: The response arrives as a steering message; do not poll crew_list.",
+		],
+
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const callerSessionId = ctx.sessionManager.getSessionId();
+			const { error } = crew.respond(
+				params.subagent_id,
+				params.message,
+				callerSessionId,
+			);
+			if (error) return toolError(error);
+
+			return toolSuccess(
+				`Message sent to subagent ${params.subagent_id}. Response will be delivered as a steering message.`,
+				{ id: params.subagent_id, message: params.message },
+			);
+		},
+
+		renderCall(args, theme, _context) {
+			return renderCrewCall(
+				theme,
+				"crew_respond",
+				args.subagent_id || "...",
+				args.message,
+			);
+		},
+
+		renderResult(result, _options, theme, _context) {
+			return renderCrewResult(result, theme);
+		},
+	});
+}