pi-crew 0.9.50 → 0.9.52

package/src/adapters/export-util.ts

@@ -1,143 +0,0 @@
-import type { AgentConfig } from "../agents/agent-config.ts";
-import type { SkillDescriptor } from "../skills/discover-skills.ts";
-import type { TeamConfig } from "../teams/team-config.ts";
-import { resolveContainedPath } from "../utils/safe-paths.ts";
-import type { WorkflowConfig } from "../workflows/workflow-config.ts";
-import { adapterRegistry } from "./registry.ts";
-import type { ExportContent } from "./types.ts";
-
-function slugify(value: string): string {
-	return value
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-")
-		.replace(/^-+|-+$/g, "");
-}
-
-export function agentToExportContent(agent: AgentConfig): ExportContent {
-	const category = agent.routing?.category ?? "agent";
-	const tags = agent.routing?.triggers ?? [];
-	return {
-		id: slugify(agent.name),
-		name: agent.name,
-		description: agent.description,
-		category,
-		tags,
-		body: agent.systemPrompt,
-		source: { type: "agent", name: agent.name },
-	};
-}
-
-export function teamToExportContent(team: TeamConfig): ExportContent {
-	const category = team.routing?.category ?? "team";
-	const tags = team.routing?.triggers ?? [];
-	const rolesDesc = team.roles.map((role) => `- **${role.name}**: ${role.description ?? role.agent}`).join("\n");
-	const body = `${team.description}\n\n### Roles\n${rolesDesc}`;
-	return {
-		id: slugify(team.name),
-		name: team.name,
-		description: team.description,
-		category,
-		tags,
-		body,
-		source: { type: "team", name: team.name },
-	};
-}
-
-export function workflowToExportContent(workflow: WorkflowConfig): ExportContent {
-	const stepsDesc = workflow.steps.map((step) => `- **${step.id}** (${step.role}): ${step.task}`).join("\n");
-	const body = `${workflow.description}\n\n### Steps\n${stepsDesc}`;
-	return {
-		id: slugify(workflow.name),
-		name: workflow.name,
-		description: workflow.description,
-		category: "workflow",
-		tags: [],
-		body,
-		source: { type: "workflow", name: workflow.name },
-	};
-}
-
-export function skillToExportContent(skill: SkillDescriptor): ExportContent {
-	return {
-		id: slugify(skill.name),
-		name: skill.name,
-		description: skill.description || `Skill: ${skill.name}`,
-		category: "skill",
-		tags: [],
-		body: `Skill loaded from ${skill.source}: ${skill.path}`,
-		source: { type: "skill", name: skill.name },
-	};
-}
-
-export type ExportableResource =
-	| { kind: "agent"; config: AgentConfig }
-	| { kind: "team"; config: TeamConfig }
-	| { kind: "workflow"; config: WorkflowConfig }
-	| { kind: "skill"; config: SkillDescriptor };
-
-export function resourcesToExportContent(resources: ExportableResource[]): ExportContent[] {
-	const results: ExportContent[] = [];
-	for (const resource of resources) {
-		switch (resource.kind) {
-			case "agent":
-				results.push(agentToExportContent(resource.config));
-				break;
-			case "team":
-				results.push(teamToExportContent(resource.config));
-				break;
-			case "workflow":
-				results.push(workflowToExportContent(resource.config));
-				break;
-			case "skill":
-				results.push(skillToExportContent(resource.config));
-				break;
-		}
-	}
-	return results;
-}
-
-export interface ToolExportResult {
-	toolId: string;
-	files: Array<{ path: string; content: string }>;
-}
-
-export function generateToolExport(toolId: string, resources: ExportableResource[], projectRoot?: string): ToolExportResult {
-	const adapter = adapterRegistry.get(toolId);
-	if (!adapter) {
-		throw new Error(
-			`Unknown export adapter: ${toolId}. Available: ${adapterRegistry
-				.getAll()
-				.map((a) => a.toolId)
-				.join(", ")}`,
-		);
-	}
-	const contents = resourcesToExportContent(resources);
-	const files = contents.map((content): { path: string; content: string } => {
-		const filePath = adapter.getFilePath(content);
-		// Validate path containment when a project root is provided
-		if (projectRoot) {
-			try {
-				resolveContainedPath(projectRoot, filePath);
-			} catch (e) {
-				throw new Error(
-					`Export path '${filePath}' escapes project root '${projectRoot}': ${e instanceof Error ? e.message : String(e)}`,
-				);
-			}
-		}
-		return {
-			path: filePath,
-			content: adapter.formatFile(content),
-		};
-	});
-	// Merge duplicate file paths (e.g., codex adapter maps everything to AGENTS.md)
-	const merged = new Map<string, string>();
-	for (const f of files) {
-		const existing = merged.get(f.path);
-		merged.set(f.path, existing ? `${existing}\n\n${f.content}` : f.content);
-	}
-	const mergedFiles = [...merged.entries()].map(([p, content]) => ({
-		path: p,
-		content,
-	}));
-	return { toolId, files: mergedFiles };
-}

package/src/adapters/index.ts

@@ -1,15 +0,0 @@
-export { claudeAdapter } from "./claude-adapter.ts";
-export { codexAdapter } from "./codex-adapter.ts";
-export { cursorAdapter } from "./cursor-adapter.ts";
-export { generateToolExport, resourcesToExportContent } from "./export-util.ts";
-export { adapterRegistry, createAdapterRegistry } from "./registry.ts";
-export type { AdapterRegistry, ExportAdapter, ExportContent } from "./types.ts";
-
-import { claudeAdapter } from "./claude-adapter.ts";
-import { codexAdapter } from "./codex-adapter.ts";
-import { cursorAdapter } from "./cursor-adapter.ts";
-import { adapterRegistry } from "./registry.ts";
-
-adapterRegistry.register(claudeAdapter);
-adapterRegistry.register(cursorAdapter);
-adapterRegistry.register(codexAdapter);

package/src/adapters/registry.ts

@@ -1,18 +0,0 @@
-import type { AdapterRegistry, ExportAdapter } from "./types.ts";
-
-export function createAdapterRegistry(): AdapterRegistry {
-	const adapters = new Map<string, ExportAdapter>();
-	return {
-		get(toolId: string): ExportAdapter | undefined {
-			return adapters.get(toolId);
-		},
-		getAll(): ExportAdapter[] {
-			return [...adapters.values()];
-		},
-		register(adapter: ExportAdapter): void {
-			adapters.set(adapter.toolId, adapter);
-		},
-	};
-}
-
-export const adapterRegistry: AdapterRegistry = createAdapterRegistry();

package/src/adapters/types.ts

@@ -1,23 +0,0 @@
-export interface ExportContent {
-	id: string;
-	name: string;
-	description: string;
-	category: string;
-	tags: string[];
-	body: string;
-	source: { type: "agent" | "team" | "workflow" | "skill"; name: string };
-}
-
-export interface ExportAdapter {
-	readonly toolId: string;
-	readonly toolName: string;
-	readonly fileExtension: string;
-	getFilePath(content: ExportContent): string;
-	formatFile(content: ExportContent): string;
-}
-
-export interface AdapterRegistry {
-	get(toolId: string): ExportAdapter | undefined;
-	getAll(): ExportAdapter[];
-	register(adapter: ExportAdapter): void;
-}

package/src/agents/agent-config.ts

@@ -1,194 +0,0 @@
-import type { RoleToolConfig } from "../config/role-tools.ts";
-import { getToolConfig } from "../config/role-tools.ts";
-
-/**
- * F1 (v0.7.9): canonical built-in tool name list. Used by `parseToolsField`
- * to expand wildcard `*` / `all` patterns in agent frontmatter. Matches
- * pi-subagents' `BUILTIN_TOOL_NAMES` (derived from pi's `createCodingTools` /
- * `createReadOnlyTools`). If pi adds a new built-in, update this list and
- * the wildcard expansion will pick it up. The 7 names below are stable
- * across pi v0.77+ and cover read, edit, write, bash, grep, find, ls.
- */
-export const BUILTIN_TOOL_NAMES: readonly string[] = ["read", "edit", "write", "bash", "grep", "find", "ls"];
-
-/**
- * F1 (v0.7.9): normalize the raw `tools:` frontmatter CSV into a `string[]`.
- * Semantics (matching pi-subagents' `parseToolsField`):
- *   - omitted / undefined → returns `undefined` (back-compat: use the
- *     runtime default — today this is the role-tools default; tomorrow this
- *     could become the wildcard expansion if the user opts in).
- *   - `*` or `all` (case-insensitive) → returns the full BUILTIN_TOOL_NAMES
- *     list (no duplicates).
- *   - `none` or empty string → returns `[]` (zero built-ins; extension
- *     tools via `ext:` can still be added, though pi-crew doesn't parse
- *     `ext:` selectors yet — see F1 sub-gap).
- *   - CSV → returns the parsed entries (trimmed, empty entries dropped).
- * Plain tool names (no `*`) pass through unchanged so existing agent
- * files keep working with no edits.
- */
-export function parseToolsField(raw: unknown): string[] | undefined {
-	if (raw === undefined || raw === null) return undefined;
-	const s = typeof raw === "string" ? raw.trim() : String(raw).trim();
-	if (!s) return [];
-	const lowered = s.toLowerCase();
-	if (lowered === "none" || lowered === "[]") return [];
-	if (lowered === "*" || lowered === "all") return [...BUILTIN_TOOL_NAMES];
-	const items = s
-		.split(",")
-		.map((t) => t.trim())
-		.filter(Boolean);
-	return items;
-}
-
-export type ResourceSource = "builtin" | "user" | "project" | "git" | "dynamic" | "project-pi";
-
-export interface RoutingMetadata {
-	triggers?: string[];
-	useWhen?: string[];
-	avoidWhen?: string[];
-	cost?: "free" | "cheap" | "expensive";
-	category?: string;
-}
-
-export interface AgentConfig {
-	name: string;
-	description: string;
-	source: ResourceSource;
-	filePath: string;
-	systemPrompt: string;
-	model?: string;
-	fallbackModels?: string[];
-	thinking?: string;
-	tools?: string[];
-	extensions?: string[];
-	/**
-	 * F1 (v0.7.9): extension denylist (case-insensitive plain names). Applied
-	 * AFTER `extensions:` (which lists the allowed set) — an excluded
-	 * extension is removed from the allowlist and never loads. Plain names
-	 * only (no paths, no `*`); an unknown name logs a warning but is
-	 * tolerated. Back-compat: omitted = no exclusion.
-	 */
-	excludeExtensions?: string[];
-	skills?: string[];
-	systemPromptMode?: "replace" | "append";
-	inheritProjectContext?: boolean;
-	inheritSkills?: boolean;
-	routing?: RoutingMetadata;
-	memory?: "user" | "project" | "local";
-	/** Tool loading strategy: "essential" = always load all tools, "lean" = only load tools in defaultTools list */
-	loadMode?: "essential" | "lean";
-	/** Explicit tool list when loadMode is "lean". null means all available tools. */
-	defaultTools?: string[] | null;
-	/** Context mode: "fresh" = clean start, "fork" = inherit parent session context */
-	contextMode?: "fresh" | "fork";
-	/** Maximum turns for this agent. Overrides runtime config if set. */
-	maxTurns?: number;
-	/** Cap on output tokens per API call. Set via PI_CREW_MAX_OUTPUT env in child. */
-	maxTokens?: number;
-	/** Effort level for this agent. Controls how much work the agent puts in. */
-	effort?: "low" | "medium" | "high";
-	/** Tools to explicitly forbid for this agent. Takes precedence over allowedTools. */
-	disallowedTools?: string[];
-	/** Disable ALL tools (Pi `--no-tools`). Used by capability-locked agents like the goal-judge (P1)
-	 *  that must have NO agency — only emit a verdict. §0c C6: an empty `tools:[]` is INSUFFICIENT
-	 *  because pi-args.ts skips empty arrays, leaving default tools enabled. */
-	disableTools?: boolean;
-	disabled?: boolean;
-	override?: { source: "config"; path: string };
-}
-
-/**
- * Get session options (tools/excludeTools) for a specific role.
- * Used by child-pi to apply role-based tool restrictions.
- */
-export function getAgentSessionOptions(role: string): {
-	tools?: string[];
-	excludeTools?: string[];
-} {
-	const config: RoleToolConfig = getToolConfig(role);
-
-	if (config.tools || config.excludeTools) {
-		return {
-			tools: config.tools,
-			excludeTools: config.excludeTools,
-		};
-	}
-
-	return {};
-}
-
-/**
- * F1 unify (v0.8.0): the single source of truth for a worker's tool policy,
- * used by BOTH spawn paths (child-pi `pi-args.ts` and live-session
- * `live-session-runtime.ts`). Before this, the two paths disagreed:
- *   - child-pi: `roleConfig.tools ?? agent.tools` (role authoritative)
- *   - live-session: `agent.tools` only (frontmatter authoritative, role ignored)
- * so the same agent behaved differently depending on the runtime. A user
- * defining `tools:` or `disallowed_tools:` in a custom agent's frontmatter
- * saw it honored on one path and ignored on the other.
- *
- * Unified semantics (stable across both paths):
- *   - **allowlist precedence is source-aware**:
- *     - `source === "builtin"` → role-config authoritative (security: a
- *       builtin explorer MUST stay read-only even if its frontmatter is
- *       loose). Frontmatter is the fallback when the role has no allowlist.
- *     - `source !== "builtin"` (user / project) → frontmatter `tools:`
- *       authoritative (user intent). Role-config is the fallback.
- *   - **denylist is additive**: `roleConfig.excludeTools` and
- *     `agent.disallowedTools` are MERGED (dedup, order-insensitive). It is
- *     always safe to forbid more, and merging means a security exclude
- *     from the role can never be weakened by a frontmatter omission.
- *
- * Returns `{ tools, excludeTools }` where each is `undefined` when no
- * restriction of that kind applies (so callers no-op cleanly).
- */
-export interface ResolvedToolPolicy {
-	/** Allowlist; undefined = no allowlist restriction (all built-ins allowed). */
-	tools?: string[];
-	/** Denylist (additive); undefined = no denylist. */
-	excludeTools?: string[];
-}
-
-function uniqueToolMerge(...lists: Array<string[] | undefined>): string[] | undefined {
-	const merged = [...new Set(lists.flatMap((list) => list ?? []))];
-	return merged.length > 0 ? merged : undefined;
-}
-
-export function resolveToolPolicy(agent: AgentConfig, role?: string): ResolvedToolPolicy {
-	const roleConfig = role ? getToolConfig(role) : {};
-	// allowlist: source-aware precedence (see doc above).
-	const explicitTools = agent.source === "builtin" ? (roleConfig.tools ?? agent.tools) : (agent.tools ?? roleConfig.tools);
-	// L5: when the agent opts into `loadMode: "lean"` AND provides a
-	// non-empty `defaultTools` list, merge that list into the resolved
-	// allowlist. The merge is additive (union, dedup, order-preserving) so
-	// the existing source-aware precedence is preserved and a lean agent
-	// gets a focused-but-non-empty tool set. Signal flow:
-	//   agent YAML frontmatter (loadMode, defaultTools)
-	//     → parsed into AgentConfig
-	//     → resolveToolPolicy(agent, role) here
-	//     → policy.tools returned to buildPiWorkerArgs
-	//     → `args.push("--tools", policy.tools.join(","))` in pi-args.ts
-	//     → child pi process sees the merged allowlist
-	const tools =
-		agent.loadMode === "lean" && agent.defaultTools?.length ? uniqueToolMerge(explicitTools, agent.defaultTools) : explicitTools;
-	// denylist: additive merge of role excludeTools + agent disallowedTools.
-	const excludeTools = uniqueToolMerge(roleConfig.excludeTools, agent.disallowedTools);
-	return { tools, excludeTools };
-}
-
-/**
- * Build agent session options including role-based tool restrictions.
- * @param agent - The agent configuration
- * @param role - The role name to use for tool restrictions (defaults to agent.name)
- */
-/** @internal */
-function buildAgentSessionOptions(
-	agent: AgentConfig,
-	role?: string,
-): {
-	tools?: string[];
-	excludeTools?: string[];
-} {
-	const effectiveRole = role ?? agent.name;
-	return getAgentSessionOptions(effectiveRole);
-}

package/src/agents/agent-search.ts

@@ -1,98 +0,0 @@
-import type { AgentConfig } from "./agent-config.ts";
-
-// ─── BM25 Agent Search ──────────────────────────────────────────────────────
-// Lightweight BM25 search over agent descriptors for task-to-agent matching.
-// Based on the same BM25 algorithm used in oh-my-pi's tool-index.ts.
-
-export interface AgentSearchDocument {
-	agent: AgentConfig;
-	termFrequencies: Map<string, number>;
-	length: number;
-}
-
-export interface AgentSearchIndex {
-	documents: AgentSearchDocument[];
-	averageLength: number;
-	documentFrequencies: Map<string, number>;
-}
-
-export interface AgentSearchResult {
-	agent: AgentConfig;
-	score: number;
-}
-
-const BM25_K1 = 1.2;
-const BM25_B = 0.75;
-const FIELD_WEIGHTS = {
-	name: 6,
-	description: 2,
-	role: 3,
-} as const;
-
-function tokenize(value: string): string[] {
-	return value
-		.replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-		.replace(/[^a-zA-Z0-9]+/g, " ")
-		.toLowerCase()
-		.trim()
-		.split(/\s+/)
-		.filter((token) => token.length > 0);
-}
-
-function addWeightedTokens(termFrequencies: Map<string, number>, value: string | undefined, weight: number): void {
-	if (!value) return;
-	for (const token of tokenize(value)) {
-		termFrequencies.set(token, (termFrequencies.get(token) ?? 0) + weight);
-	}
-}
-
-function buildAgentSearchDocument(agent: AgentConfig): AgentSearchDocument {
-	const termFrequencies = new Map<string, number>();
-	addWeightedTokens(termFrequencies, agent.name, FIELD_WEIGHTS.name);
-	addWeightedTokens(termFrequencies, agent.description, FIELD_WEIGHTS.description);
-	// Role from agent name heuristic
-	const roleHint = agent.name?.replace(/[-_]/g, " ") ?? "";
-	addWeightedTokens(termFrequencies, roleHint, FIELD_WEIGHTS.role);
-	const length = Array.from(termFrequencies.values()).reduce((sum, value) => sum + value, 0);
-	return { agent, termFrequencies, length };
-}
-
-export function buildAgentSearchIndex(agents: Iterable<AgentConfig>): AgentSearchIndex {
-	const documents = Array.from(agents, buildAgentSearchDocument);
-	const averageLength = documents.reduce((sum, document) => sum + document.length, 0) / documents.length || 1;
-	const documentFrequencies = new Map<string, number>();
-	for (const document of documents) {
-		for (const token of new Set(document.termFrequencies.keys())) {
-			documentFrequencies.set(token, (documentFrequencies.get(token) ?? 0) + 1);
-		}
-	}
-	return { documents, averageLength, documentFrequencies };
-}
-
-export function searchAgents(index: AgentSearchIndex, query: string, limit: number): AgentSearchResult[] {
-	const queryTokens = tokenize(query);
-	if (queryTokens.length === 0) return [];
-	if (index.documents.length === 0) return [];
-
-	const queryTermCounts = new Map<string, number>();
-	for (const token of queryTokens) {
-		queryTermCounts.set(token, (queryTermCounts.get(token) ?? 0) + 1);
-	}
-
-	return index.documents
-		.map((document) => {
-			let score = 0;
-			for (const [token, queryTermCount] of queryTermCounts) {
-				const termFrequency = document.termFrequencies.get(token) ?? 0;
-				if (termFrequency === 0) continue;
-				const documentFrequency = index.documentFrequencies.get(token) ?? 0;
-				const idf = Math.log(1 + (index.documents.length - documentFrequency + 0.5) / (documentFrequency + 0.5));
-				const normalization = BM25_K1 * (1 - BM25_B + BM25_B * (document.length / index.averageLength));
-				score += queryTermCount * idf * ((termFrequency * (BM25_K1 + 1)) / (termFrequency + normalization));
-			}
-			return { agent: document.agent, score };
-		})
-		.filter((result) => result.score > 0)
-		.sort((left, right) => right.score - left.score || left.agent.name.localeCompare(right.agent.name))
-		.slice(0, limit);
-}

package/src/agents/agent-serializer.ts

@@ -1,38 +0,0 @@
-import type { AgentConfig } from "./agent-config.ts";
-
-function line(key: string, value: string | boolean | string[] | undefined): string | undefined {
-	if (value === undefined) return undefined;
-	if (Array.isArray(value)) return `${key}: ${value.join(", ")}`;
-	return `${key}: ${String(value)}`;
-}
-
-export function serializeAgent(agent: AgentConfig): string {
-	const lines = [
-		"---",
-		`name: ${agent.name}`,
-		`description: ${agent.description}`,
-		line("model", agent.model),
-		line("fallbackModels", agent.fallbackModels),
-		line("thinking", agent.thinking),
-		line("tools", agent.tools),
-		agent.extensions !== undefined ? (line("extensions", agent.extensions) ?? "extensions:") : undefined,
-		line("skills", agent.skills),
-		line("systemPromptMode", agent.systemPromptMode),
-		line("inheritProjectContext", agent.inheritProjectContext),
-		line("inheritSkills", agent.inheritSkills),
-		line("memory", agent.memory),
-		line("loadMode", agent.loadMode),
-		line("defaultTools", agent.defaultTools ?? undefined),
-		line("contextMode", agent.contextMode),
-		line("triggers", agent.routing?.triggers),
-		line("useWhen", agent.routing?.useWhen),
-		line("avoidWhen", agent.routing?.avoidWhen),
-		line("cost", agent.routing?.cost),
-		line("category", agent.routing?.category),
-		"---",
-		"",
-		agent.systemPrompt.trim(),
-		"",
-	].filter((entry): entry is string => entry !== undefined);
-	return lines.join("\n");
-}