pi-crew 0.9.55 → 0.9.57

package/scripts/watch-bundle.mjs

@@ -1,259 +0,0 @@
-#!/usr/bin/env node
-/**
- * Auto-rebuild bundle watcher — dev-loop ergonomics for v0.9.17+.
- *
- * Watches `src/`, `index.bundle.ts` for changes and rebuilds
- * `dist/index.mjs` after a 300ms debounce. Solves the "edit src/foo.ts,
- * forget to rebuild, run stale bundle" race that motivated check:
- * bundle-staleness as a CI gate.
- *
- * Usage:
- *   node scripts/watch-bundle.mjs                # default: watch src/ + index.bundle.ts
- *   node scripts/watch-bundle.mjs --once         # build once and exit (CI prep)
- *   node scripts/watch-bundle.mjs --debounce 500 # custom debounce ms
- *
- * Why native fs.watch (not chokidar):
- *   - Adds zero deps (chokidar would add ~50 transitive deps)
- *   - Node 22 + Linux/macOS support recursive watching (fs.watch recursive)
- *
- * Why not in-process (bundled into build:bundle):
- *   - Watch is a separate dev concern; doesn't belong in the build script
- *   - Keeps the build script one-shot (CI-friendly, deterministic)
- */
-import { spawn } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
-import { readdir, watch } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import path from "node:path";
-
-const args = process.argv.slice(2);
-let onceMode = false;
-let debounceMs = 300;
-for (let i = 0; i < args.length; i += 1) {
-	if (args[i] === "--once") {
-		onceMode = true;
-	} else if (args[i] === "--debounce" && args[i + 1]) {
-		debounceMs = Number(args[i + 1]);
-		i += 1;
-	}
-}
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const root = path.resolve(here, "..");
-
-const WATCH_PATHS = ["src", "index.bundle.ts"];
-const EXTENSIONS_TO_WATCH = new Set([".ts", ".mts", ".cts", ".js", ".mjs"]);
-const IGNORE_DIRS = new Set(["node_modules", "dist", ".git"]);
-
-let pending = null;
-let lastBuildReason = null;
-
-function scheduleRebuild(reason, file) {
-	lastBuildReason = `${reason} ${path.relative(root, file ?? "")}`;
-	if (pending) clearTimeout(pending);
-	pending = setTimeout(() => {
-		pending = null;
-		runBuild().catch((err) => console.error("[watch-bundle] build crashed:", err));
-	}, debounceMs);
-}
-
-function runBuild() {
-	return new Promise((resolve, reject) => {
-		const startMs = Date.now();
-		const child = spawn(process.execPath, [path.join(root, "scripts/build-bundle.mjs")], {
-			stdio: ["ignore", "pipe", "pipe"],
-			cwd: root,
-			env: { ...process.env, FORCE_COLOR: "0" },
-		});
-		let stderr = "";
-		child.stdout.on("data", (chunk) => {
-			const text = String(chunk);
-			if (text.includes("[build-bundle] dist/index.mjs")) {
-				process.stdout.write(`[watch-bundle] ${text}`);
-			}
-		});
-		child.stderr.on("data", (chunk) => {
-			stderr += String(chunk);
-			process.stderr.write(`[watch-bundle] ${chunk}`);
-		});
-		child.on("exit", (code) => {
-			const ms = Date.now() - startMs;
-			if (code === 0) {
-				console.log(`[watch-bundle] ok in ${ms}ms (${lastBuildReason ?? "initial"})`);
-				resolve();
-			} else {
-				reject(new Error(`build exited with code ${code}: ${stderr.trim().split("\n").slice(-3).join(" / ")}`));
-			}
-		});
-		child.on("error", reject);
-	});
-}
-
-async function listFiles(dir) {
-	const out = [];
-	let entries;
-	try {
-		entries = await readdir(dir, { withFileTypes: true });
-	} catch {
-		return out;
-	}
-	for (const entry of entries) {
-		const full = path.join(dir, entry.name);
-		if (entry.isDirectory()) {
-			if (IGNORE_DIRS.has(entry.name)) continue;
-			out.push(...(await listFiles(full)));
-		} else if (entry.isFile()) {
-			const ext = path.extname(entry.name).toLowerCase();
-			if (EXTENSIONS_TO_WATCH.has(ext)) out.push(full);
-		}
-	}
-	return out;
-}
-
-async function watchDir(dir) {
-	// Linux inotify (used by fs.watch {recursive: true} on modern Node)
-	// sometimes misses events on deep trees. Walk the tree once and
-	// spawn a per-directory watcher for robustness. Cost: O(2N) FDs
-	// where N = number of source dirs (~5 for a typical pi-crew tree).
-	// Each watcher is independent and yields events as its dir changes.
-	const watcherJobs = [];
-	try {
-		// Watch the dir itself (catches direct children changes)
-		const rootWatcher = await watch(dir, { persistent: true });
-		watcherJobs.push(
-			(async () => {
-				for await (const e of rootWatcher) {
-					if (e.filename) handleEvent(dir, e.filename);
-				}
-			})(),
-		);
-	} catch (err) {
-		console.warn(`[watch-bundle] cannot watch ${dir}:`, err?.code ?? err?.message ?? err);
-	}
-	// Recurse into subdirectories (skip ignored) — each gets its own watcher
-	try {
-		const entries = await readdir(dir, { withFileTypes: true });
-		for (const entry of entries) {
-			if (!entry.isDirectory()) continue;
-			if (IGNORE_DIRS.has(entry.name)) continue;
-			const sub = path.join(dir, entry.name);
-			watcherJobs.push(
-				(async () => {
-					try {
-						const subWatcher = await watch(sub, { persistent: true });
-						for await (const e of subWatcher) {
-							if (e.filename) handleEvent(sub, e.filename);
-						}
-					} catch (err) {
-						console.warn(
-							`[watch-bundle] cannot watch ${sub}:`,
-							err?.code ?? err?.message ?? err,
-						);
-					}
-				})(),
-			);
-		}
-	} catch {
-		// ignore readdir errors
-	}
-	// Block until any watcher completes (they shouldn't, they're persistent)
-	await Promise.race(watcherJobs);
-}
-
-function handleEvent(watchedDir, filename) {
-	const fullPath = path.resolve(watchedDir, filename);
-	const ext = path.extname(fullPath).toLowerCase();
-	if (!EXTENSIONS_TO_WATCH.has(ext)) return;
-	if (fullPath.includes(`${path.sep}dist${path.sep}`)) return;
-	scheduleRebuild("change", fullPath);
-}
-
-async function watchFile(file) {
-	if (!existsSync(file)) return;
-	const dir = path.dirname(file);
-	const watcher = watch(dir, { persistent: true });
-	for await (const event of watcher) {
-		if (!event.filename) continue;
-		const changed = path.resolve(dir, event.filename);
-		if (changed === file) scheduleRebuild("change", changed);
-	}
-}
-
-async function main() {
-	const watchables = WATCH_PATHS.map((p) => path.join(root, p)).filter((p) => {
-		try {
-			return existsSync(p);
-		} catch {
-			return false;
-		}
-	});
-	if (watchables.length === 0) {
-		console.error("[watch-bundle] no watchable paths found (run from repo root)");
-		process.exit(1);
-	}
-
-	console.log("[watch-bundle] initial build...");
-	let initialOk = true;
-	try {
-		await runBuild();
-	} catch (err) {
-		console.error("[watch-bundle] initial build failed:", err.message);
-		initialOk = false;
-	}
-
-	if (onceMode) {
-		process.exit(initialOk ? 0 : 2);
-	}
-
-	if (!initialOk) {
-		console.warn("[watch-bundle] initial build failed; watching anyway");
-	}
-
-	let seedCount = 0;
-	for (const p of watchables) {
-		try {
-			const stat = statSync(p);
-			if (stat.isDirectory()) {
-				seedCount += (await listFiles(p)).length;
-			} else if (stat.isFile()) {
-				seedCount += 1;
-			}
-		} catch {
-			// skip
-		}
-	}
-	console.log(`[watch-bundle] seeded with ${seedCount} source files`);
-
-	const watchJobs = [];
-	for (const p of watchables) {
-		try {
-			const stat = statSync(p);
-			watchJobs.push(stat.isDirectory() ? watchDir(p) : watchFile(p));
-		} catch (err) {
-			console.warn(`[watch-bundle] cannot watch ${p}:`, err?.code ?? err?.message ?? err);
-		}
-	}
-
-	console.log(`[watch-bundle] watching ${watchables.length} paths; debounce=${debounceMs}ms; Ctrl+C to stop`);
-
-	let shutting = false;
-	const stop = () => {
-		if (shutting) return;
-		shutting = true;
-		console.log("\n[watch-bundle] shutting down...");
-		if (pending) {
-			clearTimeout(pending);
-			pending = null;
-		}
-		setTimeout(() => process.exit(0), 200);
-	};
-	process.on("SIGINT", stop);
-	process.on("SIGTERM", stop);
-
-	await Promise.race(watchJobs);
-}
-
-main().catch((err) => {
-	console.error("[watch-bundle] fatal:", err);
-	process.exit(1);
-});

package/scripts/watchdog-harness.ts

@@ -1,119 +0,0 @@
-/**
- * Watchdog harness — a minimal script that mimics the background-runner's
- * watchdog + keepAlive mechanism WITHOUT needing a real team/run manifest.
- *
- * This is used by test/integration/background-runner-watchdog-e2e.test.ts to
- * verify the watchdog fires and force-exits a hung process.
- *
- * Usage:
- *   node --experimental-strip-types scripts/watchdog-harness.ts
- *
- * Env vars:
- *   PI_CREW_MAX_RUN_MS          — watchdog timeout (ms). Default: 2h.
- *   PI_CREW_PARENT_PID          — parent guard PID. If parent dies, exit 124.
- *   PI_CREW_HARD_KILL_GRACE_MS  — grace period before force-exit. Default: 15000.
- *
- * The script:
- *   1. Starts the parent guard (self-terminates if parent dies)
- *   2. Starts a keepAlive interval (prevents event-loop exit)
- *   3. Starts a watchdog timer (fires after MAX_RUN_MS, schedules force-exit)
- *   4. NEVER resolves — simulating a hung team run
- *
- * Expected behaviour: process exits via watchdog force-exit within
- *   PI_CREW_MAX_RUN_MS + PI_CREW_HARD_KILL_GRACE_MS milliseconds.
- */
-
-// ─── Config (from env — mirrors background-runner.ts) ─────────────────────────
-const MAX_BACKGROUND_RUN_MS = (() => {
-	const env = Number.parseInt(process.env.PI_CREW_MAX_RUN_MS ?? "", 10);
-	return Number.isFinite(env) && env > 0 ? env : 2 * 60 * 60 * 1000; // 2h default
-})();
-
-const HARD_KILL_GRACE_MS = Number.parseInt(process.env.PI_CREW_HARD_KILL_GRACE_MS ?? "", 10) || 15_000;
-
-// ─── Global error handlers (mirror background-runner.ts patterns) ─────────────
-// These prevent unhandled exceptions/rejections from crashing the process
-// before the watchdog can fire. The harness deliberately hangs, so these are
-// the only way to keep the process alive long enough for the watchdog to trigger.
-process.on("uncaughtException", (err) => {
-	console.error(`[watchdog-harness] uncaughtException: ${err.message}`);
-});
-
-process.on("unhandledRejection", (reason) => {
-	const msg = reason instanceof Error ? reason.message : String(reason);
-	console.error(`[watchdog-harness] unhandledRejection: ${msg}`);
-});
-
-// ─── Parent Guard ──────────────────────────────────────────────────────────────
-const parentPid = Number(process.env.PI_CREW_PARENT_PID);
-if (parentPid > 0) {
-	const POLL_INTERVAL_MS = 500;
-
-	function isPidAlive(pid: number): boolean {
-		try {
-			process.kill(pid, 0);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-
-	const guard = setInterval(() => {
-		// Wrap in try/catch: if isPidAlive throws unexpectedly (e.g. EPERM on
-		// some platforms), we don't want the interval itself to crash and prevent
-		// the watchdog from ever firing.
-		try {
-			if (!isPidAlive(parentPid)) {
-				clearInterval(guard);
-				process.exit(124); // 124 = "parent died" exit code
-			}
-		} catch (err) {
-			// Unexpected error in parent guard — log and continue polling.
-			console.error(`[watchdog-harness] parent-guard error: ${err}`);
-		}
-	}, POLL_INTERVAL_MS);
-	// NOTE: intentionally NOT unref'd — must keep event loop alive while parent is alive.
-}
-
-// ─── KeepAlive (same interval as background-runner.ts) ─────────────────────────
-const keepAlive = setInterval(() => {}, 5000);
-// NOTE: intentionally NOT unref'd — must hold the event loop open while the
-// process is alive. The event loop MUST stay alive so the forceExit setTimeout
-// below can fire. If keepAlive is cleared too early, the event loop drains
-// and all pending setTimeouts are silently cancelled before they fire.
-
-// ─── Watchdog ─────────────────────────────────────────────────────────────────
-// Track whether abort+force-exit has already been triggered (prevents double-fire).
-let watchdogFired = false;
-
-const watchdogTimer = setTimeout(() => {
-	if (watchdogFired) return;
-	watchdogFired = true;
-
-	console.error(
-		`[watchdog-harness] WATCHDOG: run exceeded ${MAX_BACKGROUND_RUN_MS}ms — scheduling force-exit in ${HARD_KILL_GRACE_MS}ms (zombie prevention)`,
-	);
-
-	// Hard-exit safety net: if the abort does not propagate within grace period,
-	// force-kill so the process cannot linger. Matches background-runner.ts logic.
-	// NOTE: keepAlive is NOT cleared here — it keeps the event loop alive so
-	// the forceExit setTimeout below can fire. If keepAlive is cleared, the
-	// event loop drains and forceExit is silently cancelled (observed: process
-	// exits via module-level finally/runCleanup with the last exit code instead).
-	const forceExit = setTimeout(() => {
-		// Clear keepAlive only at the very end, right before force-exit.
-		clearInterval(keepAlive);
-		clearTimeout(watchdogTimer);
-		process.exit(1);
-	}, HARD_KILL_GRACE_MS);
-	// NOTE: intentionally NOT unref'd — this timer MUST fire to force-exit.
-}, MAX_BACKGROUND_RUN_MS);
-
-// ─── Hung run simulation ──────────────────────────────────────────────────────
-// NEVER resolve this promise — simulates a team run that hangs forever.
-// The watchdog setTimeout above fires and force-exits the process first.
-await new Promise<void>((resolve) => {
-	// Intentionally never resolved. The unhandledRejection handler above keeps
-	// the process alive until the watchdog fires and calls process.exit().
-	void resolve;
-});

package/src/adapters/claude-adapter.ts

@@ -1,23 +0,0 @@
-import type { ExportAdapter, ExportContent } from "./types.ts";
-
-export const claudeAdapter: ExportAdapter = {
-	toolId: "claude",
-	toolName: "Claude Code",
-	fileExtension: ".md",
-
-	getFilePath(content: ExportContent): string {
-		return `.claude/commands/pi-crew/${content.id}.md`;
-	},
-
-	formatFile(content: ExportContent): string {
-		const tagLines = content.tags.length > 0 ? ["tags:", ...content.tags.map((tag) => `  - ${JSON.stringify(tag)}`)] : [];
-		const frontmatter = [
-			"---",
-			`description: ${JSON.stringify(content.description)}`,
-			`category: ${JSON.stringify(content.category)}`,
-			...tagLines,
-			"---",
-		].join("\n");
-		return `${frontmatter}\n\n# ${content.name}\n\n${content.body}\n`;
-	},
-};

package/src/adapters/codex-adapter.ts

@@ -1,21 +0,0 @@
-import type { ExportAdapter, ExportContent } from "./types.ts";
-
-export const codexAdapter: ExportAdapter = {
-	toolId: "codex",
-	toolName: "Codex",
-	fileExtension: ".md",
-
-	getFilePath(_content: ExportContent): string {
-		return "AGENTS.md";
-	},
-
-	formatFile(content: ExportContent): string {
-		const tags = content.tags.length > 0 ? ` (${content.tags.join(", ")})` : "";
-		return [
-			`## ${content.name}${tags}\n`,
-			`**Source:** ${content.source.type}/${content.source.name}  `,
-			`**Category:** ${content.category}\n`,
-			content.body,
-		].join("\n");
-	},
-};

package/src/adapters/cursor-adapter.ts

@@ -1,17 +0,0 @@
-import type { ExportAdapter, ExportContent } from "./types.ts";
-
-export const cursorAdapter: ExportAdapter = {
-	toolId: "cursor",
-	toolName: "Cursor",
-	fileExtension: ".md",
-
-	getFilePath(content: ExportContent): string {
-		return `.cursor/rules/pi-crew-${content.id}.md`;
-	},
-
-	formatFile(content: ExportContent): string {
-		const header = `# ${content.name}\n\n> ${content.description}`;
-		const tags = content.tags.length > 0 ? `\n\n**Tags:** ${content.tags.join(", ")}` : "";
-		return `${header}${tags}\n\n${content.body}\n`;
-	},
-};

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 { resolveRealContainedPath } 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 {
-				resolveRealContainedPath(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;
-}