pi-crew 0.1.45 → 0.1.49

package/src/runtime/cancellation.ts

@@ -0,0 +1,61 @@
+import type { OperationTerminalEvidence } from "../state/types.ts";
+
+export type CancellationReasonCode = "caller_cancelled" | "leader_interrupted" | "provider_timeout" | "worker_timeout" | "tool_timeout" | "shutdown" | "unknown";
+
+export interface CancellationReason {
+	code: CancellationReasonCode;
+	message: string;
+	cause?: unknown;
+}
+
+export function buildSyntheticTerminalEvidence(
+	operation: "worker" | "tool" | "model",
+	reason: CancellationReason,
+	startedAt?: string,
+): OperationTerminalEvidence {
+	return { operation, status: "cancelled", startedAt, finishedAt: new Date().toISOString(), reason };
+}
+
+const KNOWN_CODES: ReadonlySet<string> = new Set(["caller_cancelled", "leader_interrupted", "provider_timeout", "worker_timeout", "tool_timeout", "shutdown", "unknown"]);
+
+export class CrewCancellationError extends Error {
+	readonly reason: CancellationReason;
+
+	constructor(reason: CancellationReason) {
+		super(reason.message);
+		this.name = "CrewCancellationError";
+		this.reason = reason;
+	}
+}
+
+function reasonFromString(value: string): CancellationReason {
+	const trimmed = value.trim();
+	if (KNOWN_CODES.has(trimmed)) return { code: trimmed as CancellationReasonCode, message: `Cancelled: ${trimmed}` };
+	return { code: "caller_cancelled", message: trimmed || "Cancelled by caller." };
+}
+
+export function cancellationReasonFromUnknown(value: unknown): CancellationReason {
+	if (value instanceof CrewCancellationError) return value.reason;
+	if (value instanceof Error) return { code: "caller_cancelled", message: value.message || "Cancelled by caller.", cause: value };
+	if (typeof value === "string") return reasonFromString(value);
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const record = value as { code?: unknown; reason?: unknown; message?: unknown; cause?: unknown };
+		const rawCode = typeof record.code === "string" ? record.code : typeof record.reason === "string" ? record.reason : undefined;
+		const code = rawCode && KNOWN_CODES.has(rawCode) ? rawCode as CancellationReasonCode : "caller_cancelled";
+		const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : `Cancelled: ${code}`;
+		return { code, message, cause: record.cause ?? value };
+	}
+	return { code: "caller_cancelled", message: "Cancelled by caller." };
+}
+
+export function cancellationReasonFromSignal(signal: AbortSignal | undefined): CancellationReason {
+	return cancellationReasonFromUnknown(signal?.reason);
+}
+
+export function cancellationErrorFromSignal(signal: AbortSignal | undefined): CrewCancellationError {
+	return new CrewCancellationError(cancellationReasonFromSignal(signal));
+}
+
+export function throwIfCancelled(signal: AbortSignal | undefined): void {
+	if (signal?.aborted) throw cancellationErrorFromSignal(signal);
+}

package/src/runtime/capability-inventory.ts

@@ -0,0 +1,116 @@
+import type { AgentConfig, ResourceSource } from "../agents/agent-config.ts";
+import { discoverAgents } from "../agents/discover-agents.ts";
+import { discoverTeams } from "../teams/discover-teams.ts";
+import { discoverWorkflows } from "../workflows/discover-workflows.ts";
+import { discoverSkills } from "../skills/discover-skills.ts";
+import type { PiTeamsConfig } from "../config/config.ts";
+
+export type CapabilityKind = "team" | "workflow" | "agent" | "skill" | "tool" | "runtime";
+export type CapabilitySource = "builtin" | "project" | "user" | "package" | "git";
+export type CapabilityState = "active" | "disabled" | "shadowed" | "missing";
+
+export interface CapabilityItem {
+	id: string;
+	kind: CapabilityKind;
+	name: string;
+	description: string;
+	source: CapabilitySource;
+	path?: string;
+	state: CapabilityState;
+	disabledReason?: string;
+	shadowedBy?: string;
+}
+
+function normalizeAgents(agents: AgentConfig[], source: CapabilitySource, disabledIds: Set<string>): CapabilityItem[] {
+	return agents.map((agent) => {
+		const id = `agent:${agent.name}`;
+		const configDisabled = disabledIds.has(id);
+		const agentDisabled = agent.disabled || configDisabled;
+		return {
+			id,
+			kind: "agent" as const,
+			name: agent.name,
+			description: agent.description,
+			source,
+			path: agent.filePath,
+			state: agentDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : agent.disabled ? "disabled in config" : undefined,
+		};
+	});
+}
+
+function normalizeSkills(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
+	const skills = discoverSkills(cwd);
+	return skills.map((skill) => {
+		const id = `skill:${skill.name}`;
+		const configDisabled = disabledIds.has(id);
+		return {
+			id,
+			kind: "skill" as const,
+			name: skill.name,
+			description: skill.description,
+			source: skill.source as CapabilitySource,
+			path: skill.path,
+			state: configDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : undefined,
+		};
+	});
+}
+
+function normalizeTeams(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
+	const result = discoverTeams(cwd);
+	return [...result.builtin, ...result.user, ...result.project].map((team) => {
+		const id = `team:${team.name}`;
+		const configDisabled = disabledIds.has(id);
+		return {
+			id,
+			kind: "team" as const,
+			name: team.name,
+			description: team.description,
+			source: team.source as CapabilitySource,
+			path: team.filePath,
+			state: configDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : undefined,
+		};
+	});
+}
+
+function normalizeWorkflows(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
+	const result = discoverWorkflows(cwd);
+	return [...result.builtin, ...result.user, ...result.project].map((workflow) => {
+		const id = `workflow:${workflow.name}`;
+		const configDisabled = disabledIds.has(id);
+		return {
+			id,
+			kind: "workflow" as const,
+			name: workflow.name,
+			description: workflow.description,
+			source: workflow.source as CapabilitySource,
+			path: workflow.filePath,
+			state: configDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : undefined,
+		};
+	});
+}
+
+export function buildCapabilityInventory(cwd: string, config?: PiTeamsConfig): CapabilityItem[] {
+	const disabledIds = new Set<string>(config?.policy?.disabledCapabilities ?? []);
+	const agents = discoverAgents(cwd);
+	const items = [
+		...normalizeTeams(cwd, disabledIds),
+		...normalizeWorkflows(cwd, disabledIds),
+		...normalizeAgents([...agents.builtin, ...agents.user, ...agents.project], "builtin", disabledIds),
+		...normalizeSkills(cwd, disabledIds),
+	];
+
+	// Mark shadowed resources: project/user items with same kind:name as a builtin
+	const builtinNames = new Set(items.filter((item) => item.source === "builtin" || item.source === "package").map((item) => `${item.kind}:${item.name}`));
+	for (const item of items) {
+		if (item.source !== "builtin" && item.source !== "package" && builtinNames.has(`${item.kind}:${item.name}`)) {
+			item.state = "shadowed";
+			item.shadowedBy = `builtin:${item.kind}:${item.name}`;
+		}
+	}
+
+	return items.sort((a, b) => a.id.localeCompare(b.id));
+}