@melihmucuk/pi-crew 1.0.17 → 1.0.19

package/extension/agent-discovery.ts

@@ -1,123 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import {
-	AgentCatalog,
-	type AgentCatalogSource,
-	type AgentConfigFile,
-	type AgentDefinitionFile,
-	type AgentDefinitionSourceGroup,
-	type AgentDiscoveryResult,
-	type AgentDiscoveryWarning,
-} from "./agent-catalog.js";
-
-export type {
-	AgentConfig,
-	AgentDiscoveryResult,
-	AgentDiscoveryWarning,
-} from "./agent-catalog.js";
-
-function createDiscoveryWarning(filePath: string, message: string): AgentDiscoveryWarning {
-	return { filePath, message };
-}
-
-function loadAgentFile(filePath: string): AgentDefinitionFile {
-	try {
-		return {
-			filePath,
-			content: fs.readFileSync(filePath, "utf-8"),
-		};
-	} catch (error) {
-		const reason = error instanceof Error ? error.message : String(error);
-		return {
-			filePath,
-			content: null,
-			warnings: [
-				createDiscoveryWarning(
-					filePath,
-					`Ignored subagent definition. File could not be read: ${reason}`,
-				),
-			],
-		};
-	}
-}
-
-function loadAgentDefinitionGroup(agentsDir: string): AgentDefinitionSourceGroup | null {
-	if (!fs.existsSync(agentsDir)) return null;
-
-	let entries: fs.Dirent[];
-	try {
-		entries = fs.readdirSync(agentsDir, { withFileTypes: true });
-	} catch (error) {
-		const reason = error instanceof Error ? error.message : String(error);
-		return {
-			agentsDir,
-			files: [],
-			warnings: [
-				createDiscoveryWarning(
-					agentsDir,
-					`Subagent directory could not be read: ${reason}`,
-				),
-			],
-		};
-	}
-
-	return {
-		agentsDir,
-		files: entries
-			.filter((entry) => entry.name.endsWith(".md"))
-			.filter((entry) => entry.isFile() || entry.isSymbolicLink())
-			.map((entry) => loadAgentFile(path.join(agentsDir, entry.name))),
-	};
-}
-
-function loadConfigFile(filePath: string): AgentConfigFile | null {
-	if (!fs.existsSync(filePath)) return null;
-
-	try {
-		return {
-			filePath,
-			content: fs.readFileSync(filePath, "utf-8"),
-		};
-	} catch (error) {
-		const reason = error instanceof Error ? error.message : String(error);
-		return {
-			filePath,
-			content: null,
-			warnings: [
-				createDiscoveryWarning(
-					filePath,
-					`Ignored pi-crew config. File could not be read: ${reason}`,
-				),
-			],
-		};
-	}
-}
-
-const bundledAgentsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "agents");
-
-class FilesystemAgentCatalogSource implements AgentCatalogSource {
-	loadAgentDefinitionGroups(cwd: string): AgentDefinitionSourceGroup[] {
-		return [
-			path.join(cwd, ".pi", "agents"),
-			path.join(getAgentDir(), "agents"),
-			bundledAgentsDir,
-		]
-			.map(loadAgentDefinitionGroup)
-			.filter((group): group is AgentDefinitionSourceGroup => group !== null);
-	}
-
-	loadConfigFiles(cwd: string): AgentConfigFile[] {
-		return [
-			path.join(getAgentDir(), "pi-crew.json"),
-			path.join(cwd, ".pi", "pi-crew.json"),
-		]
-			.map(loadConfigFile)
-			.filter((file): file is AgentConfigFile => file !== null);
-	}
-}
-
-export function discoverAgents(cwd: string = process.cwd()): AgentDiscoveryResult {
-	return new AgentCatalog(new FilesystemAgentCatalogSource()).discover(cwd);
-}

package/extension/bootstrap-session.ts

@@ -1,131 +0,0 @@
-import {
-  type AgentSession,
-  createAgentSession,
-  DefaultResourceLoader,
-  type ModelRegistry,
-  SessionManager,
-  SettingsManager,
-} from "@earendil-works/pi-coding-agent";
-import type { Api, Model } from "@earendil-works/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/integration/crew-tool-actions.ts

@@ -1,306 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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);
-		},
-	});
-}