pi-crew 0.2.3 → 0.2.5

package/src/extension/tool-result.ts

@@ -1,16 +1,16 @@
-import type { AgentToolResult } from "@mariozechner/pi-agent-core";
-import type { TeamToolDetails } from "./team-tool-types.ts";
-
-export type PiTeamsToolResult<TDetails = TeamToolDetails> = AgentToolResult<TDetails> & { isError?: boolean };
-
-export function toolResult<TDetails>(text: string, details: TDetails, isError = false): PiTeamsToolResult<TDetails> {
-	return { content: [{ type: "text", text }], details, isError };
-}
-
-export function isToolError(result: { isError?: boolean }): boolean {
-	return result.isError === true;
-}
-
-export function textFromToolResult(result: { content?: Array<{ type: string; text?: string }> }): string {
-	return result.content?.map((item) => item.text ?? "").join("\n") ?? "";
-}
+import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import type { TeamToolDetails } from "./team-tool-types.ts";
+
+export type PiTeamsToolResult<TDetails = TeamToolDetails> = AgentToolResult<TDetails> & { isError?: boolean };
+
+export function toolResult<TDetails>(text: string, details: TDetails, isError = false): PiTeamsToolResult<TDetails> {
+	return { content: [{ type: "text", text }], details, isError };
+}
+
+export function isToolError(result: { isError?: boolean }): boolean {
+	return result.isError === true;
+}
+
+export function textFromToolResult(result: { content?: Array<{ type: string; text?: string }> }): string {
+	return result.content?.map((item) => item.text ?? "").join("\n") ?? "";
+}

package/src/extension/validate-resources.ts

@@ -1,77 +1,77 @@
-import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
-import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
-import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
-import { validateWorkflowForTeam } from "../workflows/validate-workflow.ts";
-
-export interface ValidationIssue {
-	level: "error" | "warning";
-	resource: string;
-	message: string;
-}
-
-export interface ValidationReport {
-	issues: ValidationIssue[];
-	agents: number;
-	teams: number;
-	workflows: number;
-}
-
-export function validateResources(cwd: string): ValidationReport {
-	const agents = allAgents(discoverAgents(cwd));
-	const teams = allTeams(discoverTeams(cwd));
-	const workflows = allWorkflows(discoverWorkflows(cwd));
-	const agentNames = new Set(agents.map((agent) => agent.name));
-	const workflowNames = new Set(workflows.map((workflow) => workflow.name));
-	const issues: ValidationIssue[] = [];
-
-	for (const agent of agents) {
-		const modelValues = [agent.model, ...(agent.fallbackModels ?? [])].filter((value): value is string => typeof value === "string" && value.length > 0);
-		for (const model of modelValues) {
-			if (/\s/.test(model)) {
-				issues.push({ level: "warning", resource: `agent:${agent.name}`, message: `Model reference '${model}' contains whitespace.` });
-			}
-			if (model.includes("/") && model.split("/").some((part) => part.trim() === "")) {
-				issues.push({ level: "warning", resource: `agent:${agent.name}`, message: `Model reference '${model}' has an empty provider/model segment.` });
-			}
-		}
-	}
-
-	for (const team of teams) {
-		for (const role of team.roles) {
-			if (!agentNames.has(role.agent)) {
-				issues.push({ level: "error", resource: `team:${team.name}`, message: `Role '${role.name}' references unknown agent '${role.agent}'.` });
-			}
-		}
-		if (team.defaultWorkflow && !workflowNames.has(team.defaultWorkflow)) {
-			issues.push({ level: "error", resource: `team:${team.name}`, message: `defaultWorkflow references unknown workflow '${team.defaultWorkflow}'.` });
-		}
-		const workflow = workflows.find((candidate) => candidate.name === team.defaultWorkflow);
-		if (workflow) {
-			for (const error of validateWorkflowForTeam(workflow, team)) {
-				issues.push({ level: "error", resource: `workflow:${workflow.name}`, message: `Team '${team.name}': ${error}` });
-			}
-		}
-	}
-
-	for (const workflow of workflows) {
-		if (workflow.steps.length === 0) {
-			issues.push({ level: "warning", resource: `workflow:${workflow.name}`, message: "Workflow has no steps." });
-		}
-	}
-
-	return { issues, agents: agents.length, teams: teams.length, workflows: workflows.length };
-}
-
-export function formatValidationReport(report: ValidationReport): string {
-	const lines = [
-		"pi-crew resource validation:",
-		`Agents: ${report.agents}`,
-		`Teams: ${report.teams}`,
-		`Workflows: ${report.workflows}`,
-		`Issues: ${report.issues.length}`,
-	];
-	if (report.issues.length > 0) {
-		lines.push("", ...report.issues.map((issue) => `- ${issue.level.toUpperCase()} ${issue.resource}: ${issue.message}`));
-	}
-	return lines.join("\n");
-}
+import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
+import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
+import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
+import { validateWorkflowForTeam } from "../workflows/validate-workflow.ts";
+
+export interface ValidationIssue {
+	level: "error" | "warning";
+	resource: string;
+	message: string;
+}
+
+export interface ValidationReport {
+	issues: ValidationIssue[];
+	agents: number;
+	teams: number;
+	workflows: number;
+}
+
+export function validateResources(cwd: string): ValidationReport {
+	const agents = allAgents(discoverAgents(cwd));
+	const teams = allTeams(discoverTeams(cwd));
+	const workflows = allWorkflows(discoverWorkflows(cwd));
+	const agentNames = new Set(agents.map((agent) => agent.name));
+	const workflowNames = new Set(workflows.map((workflow) => workflow.name));
+	const issues: ValidationIssue[] = [];
+
+	for (const agent of agents) {
+		const modelValues = [agent.model, ...(agent.fallbackModels ?? [])].filter((value): value is string => typeof value === "string" && value.length > 0);
+		for (const model of modelValues) {
+			if (/\s/.test(model)) {
+				issues.push({ level: "warning", resource: `agent:${agent.name}`, message: `Model reference '${model}' contains whitespace.` });
+			}
+			if (model.includes("/") && model.split("/").some((part) => part.trim() === "")) {
+				issues.push({ level: "warning", resource: `agent:${agent.name}`, message: `Model reference '${model}' has an empty provider/model segment.` });
+			}
+		}
+	}
+
+	for (const team of teams) {
+		for (const role of team.roles) {
+			if (!agentNames.has(role.agent)) {
+				issues.push({ level: "error", resource: `team:${team.name}`, message: `Role '${role.name}' references unknown agent '${role.agent}'.` });
+			}
+		}
+		if (team.defaultWorkflow && !workflowNames.has(team.defaultWorkflow)) {
+			issues.push({ level: "error", resource: `team:${team.name}`, message: `defaultWorkflow references unknown workflow '${team.defaultWorkflow}'.` });
+		}
+		const workflow = workflows.find((candidate) => candidate.name === team.defaultWorkflow);
+		if (workflow) {
+			for (const error of validateWorkflowForTeam(workflow, team)) {
+				issues.push({ level: "error", resource: `workflow:${workflow.name}`, message: `Team '${team.name}': ${error}` });
+			}
+		}
+	}
+
+	for (const workflow of workflows) {
+		if (workflow.steps.length === 0) {
+			issues.push({ level: "warning", resource: `workflow:${workflow.name}`, message: "Workflow has no steps." });
+		}
+	}
+
+	return { issues, agents: agents.length, teams: teams.length, workflows: workflows.length };
+}
+
+export function formatValidationReport(report: ValidationReport): string {
+	const lines = [
+		"pi-crew resource validation:",
+		`Agents: ${report.agents}`,
+		`Teams: ${report.teams}`,
+		`Workflows: ${report.workflows}`,
+		`Issues: ${report.issues.length}`,
+	];
+	if (report.issues.length > 0) {
+		lines.push("", ...report.issues.map((issue) => `- ${issue.level.toUpperCase()} ${issue.resource}: ${issue.message}`));
+	}
+	return lines.join("\n");
+}

package/src/hooks/registry.ts

@@ -1,61 +1,61 @@
-import type { HookDefinition, HookName, HookContext, HookResult, HookExecutionReport } from "./types.ts";
-import { appendEvent } from "../state/event-log.ts";
-import type { TeamRunManifest } from "../state/types.ts";
-import { runEventBus } from "../ui/run-event-bus.ts";
-
-const registry = new Map<HookName, HookDefinition[]>();
-
-export function registerHook(definition: HookDefinition): void {
-	const hooks = registry.get(definition.name) ?? [];
-	hooks.push(definition);
-	registry.set(definition.name, hooks);
-}
-
-export function clearHooks(): void {
-	registry.clear();
-}
-
-export function getHooks(name: HookName): HookDefinition[] {
-	return registry.get(name) ?? [];
-}
-
-export async function executeHook(name: HookName, ctx: HookContext): Promise<HookExecutionReport> {
-	const hooks = getHooks(name);
-	if (hooks.length === 0) return { hookName: name, outcome: "allow", durationMs: 0 };
-	const start = Date.now();
-	const diagnostics: string[] = [];
-	let capturedModifications: Record<string, unknown> | undefined;
-	for (const hook of hooks) {
-		try {
-			const result: HookResult = await hook.handler(ctx);
-			if (hook.mode === "blocking" && result.outcome === "block") {
-				return { hookName: name, outcome: "block", durationMs: Date.now() - start, reason: result.reason };
-			}
-			if (result.outcome === "modify" && result.data) {
-				Object.assign(ctx, result.data);
-				capturedModifications = { ...result.data };
-			}
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			if (hook.mode === "blocking") {
-				return { hookName: name, outcome: "block", durationMs: Date.now() - start, reason: `Hook error: ${message}` };
-			}
-			// Non-blocking hook errors are accumulated as diagnostics; continue to next hook
-			diagnostics.push(message);
-			}
-	}
-	if (diagnostics.length > 0) {
-		return { hookName: name, outcome: "diagnostic", durationMs: Date.now() - start, reason: diagnostics.join("; "), modifiedData: capturedModifications };
-	}
-	return { hookName: name, outcome: "allow", durationMs: Date.now() - start, modifiedData: capturedModifications };
-}
-
-export function appendHookEvent(manifest: TeamRunManifest, report: HookExecutionReport): void {
-	appendEvent(manifest.eventsPath, {
-		type: "hook.executed",
-		runId: manifest.runId,
-		message: `Hook ${report.hookName} completed with outcome=${report.outcome}${report.reason ? `: ${report.reason}` : ""}`,
-		data: { hookName: report.hookName, outcome: report.outcome, durationMs: report.durationMs, reason: report.reason },
-	});
-	runEventBus.emit({ type: "effectiveness_changed", runId: manifest.runId, data: { hookName: report.hookName, outcome: report.outcome } });
-}
+import type { HookDefinition, HookName, HookContext, HookResult, HookExecutionReport } from "./types.ts";
+import { appendEvent } from "../state/event-log.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+import { runEventBus } from "../ui/run-event-bus.ts";
+
+const registry = new Map<HookName, HookDefinition[]>();
+
+export function registerHook(definition: HookDefinition): void {
+	const hooks = registry.get(definition.name) ?? [];
+	hooks.push(definition);
+	registry.set(definition.name, hooks);
+}
+
+export function clearHooks(): void {
+	registry.clear();
+}
+
+export function getHooks(name: HookName): HookDefinition[] {
+	return registry.get(name) ?? [];
+}
+
+export async function executeHook(name: HookName, ctx: HookContext): Promise<HookExecutionReport> {
+	const hooks = getHooks(name);
+	if (hooks.length === 0) return { hookName: name, outcome: "allow", durationMs: 0 };
+	const start = Date.now();
+	const diagnostics: string[] = [];
+	let capturedModifications: Record<string, unknown> | undefined;
+	for (const hook of hooks) {
+		try {
+			const result: HookResult = await hook.handler(ctx);
+			if (hook.mode === "blocking" && result.outcome === "block") {
+				return { hookName: name, outcome: "block", durationMs: Date.now() - start, reason: result.reason };
+			}
+			if (result.outcome === "modify" && result.data) {
+				Object.assign(ctx, result.data);
+				capturedModifications = { ...result.data };
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (hook.mode === "blocking") {
+				return { hookName: name, outcome: "block", durationMs: Date.now() - start, reason: `Hook error: ${message}` };
+			}
+			// Non-blocking hook errors are accumulated as diagnostics; continue to next hook
+			diagnostics.push(message);
+			}
+	}
+	if (diagnostics.length > 0) {
+		return { hookName: name, outcome: "diagnostic", durationMs: Date.now() - start, reason: diagnostics.join("; "), modifiedData: capturedModifications };
+	}
+	return { hookName: name, outcome: "allow", durationMs: Date.now() - start, modifiedData: capturedModifications };
+}
+
+export function appendHookEvent(manifest: TeamRunManifest, report: HookExecutionReport): void {
+	appendEvent(manifest.eventsPath, {
+		type: "hook.executed",
+		runId: manifest.runId,
+		message: `Hook ${report.hookName} completed with outcome=${report.outcome}${report.reason ? `: ${report.reason}` : ""}`,
+		data: { hookName: report.hookName, outcome: report.outcome, durationMs: report.durationMs, reason: report.reason },
+	});
+	runEventBus.emit({ type: "effectiveness_changed", runId: manifest.runId, data: { hookName: report.hookName, outcome: report.outcome } });
+}

package/src/hooks/types.ts

@@ -1,41 +1,41 @@
-export type HookName =
-	| "before_run_start"
-	| "before_task_start"
-	| "task_result"
-	| "before_cancel"
-	| "before_retry"
-	| "before_forget"
-	| "before_cleanup"
-	| "before_publish"
-	| "session_before_switch"
-	| "run_recovery";
-
-export type HookMode = "blocking" | "non_blocking";
-export type HookOutcome = "allow" | "block" | "modify" | "diagnostic";
-
-export interface HookContext {
-	runId: string;
-	taskId?: string;
-	cwd: string;
-	[key: string]: unknown;
-}
-
-export interface HookResult {
-	outcome: HookOutcome;
-	reason?: string;
-	data?: Record<string, unknown>;
-}
-
-export interface HookDefinition {
-	name: HookName;
-	mode: HookMode;
-	handler: (ctx: HookContext) => HookResult | Promise<HookResult>;
-}
-
-export interface HookExecutionReport {
-	hookName: HookName;
-	outcome: HookOutcome;
-	durationMs: number;
-	reason?: string;
-	modifiedData?: Record<string, unknown>;
+export type HookName =
+	| "before_run_start"
+	| "before_task_start"
+	| "task_result"
+	| "before_cancel"
+	| "before_retry"
+	| "before_forget"
+	| "before_cleanup"
+	| "before_publish"
+	| "session_before_switch"
+	| "run_recovery";
+
+export type HookMode = "blocking" | "non_blocking";
+export type HookOutcome = "allow" | "block" | "modify" | "diagnostic";
+
+export interface HookContext {
+	runId: string;
+	taskId?: string;
+	cwd: string;
+	[key: string]: unknown;
+}
+
+export interface HookResult {
+	outcome: HookOutcome;
+	reason?: string;
+	data?: Record<string, unknown>;
+}
+
+export interface HookDefinition {
+	name: HookName;
+	mode: HookMode;
+	handler: (ctx: HookContext) => HookResult | Promise<HookResult>;
+}
+
+export interface HookExecutionReport {
+	hookName: HookName;
+	outcome: HookOutcome;
+	durationMs: number;
+	reason?: string;
+	modifiedData?: Record<string, unknown>;
 }