pi-crew 0.9.53 → 0.9.55

package/src/extension/project-init.ts

@@ -0,0 +1,170 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { configPath as globalConfigPath } from "../config/config.ts";
+import { DEFAULT_UI } from "../config/defaults.ts";
+import { packageRoot, projectCrewRoot, projectPiRoot } from "../utils/paths.ts";
+
+export interface ProjectInitOptions {
+	copyBuiltins?: boolean;
+	overwrite?: boolean;
+	configScope?: "global" | "project" | "none";
+	ignoreMethod?: "gitignore" | "exclude";
+}
+
+export interface ProjectInitResult {
+	createdDirs: string[];
+	copiedFiles: string[];
+	skippedFiles: string[];
+	gitignorePath: string;
+	gitignoreUpdated: boolean;
+	configPath: string;
+	configScope: "global" | "project" | "none";
+	configCreated: boolean;
+	configSkipped: boolean;
+}
+
+function ensureDir(dir: string, createdDirs: string[]): void {
+	if (!fs.existsSync(dir)) {
+		fs.mkdirSync(dir, { recursive: true });
+		createdDirs.push(dir);
+	} else {
+		fs.mkdirSync(dir, { recursive: true });
+	}
+}
+
+const DEFAULT_PI_CREW_CONFIG = {
+	// Keep generated config non-invasive: do not set runtime/limits defaults here.
+	// Those are provided by pi-crew internals and should not make a normal workflow block.
+	autonomous: {
+		enabled: true,
+		injectPolicy: true,
+		preferAsyncForLongTasks: false,
+		allowWorktreeSuggestion: true,
+	},
+	agents: {
+		overrides: {
+			explorer: { model: false, thinking: "off" },
+			writer: { model: false, thinking: "off" },
+			planner: { model: false, thinking: "medium" },
+			analyst: { model: false, thinking: "off" },
+			critic: { model: false, thinking: "low" },
+			executor: { model: false, thinking: "medium" },
+			reviewer: { model: false, thinking: "off" },
+			"security-reviewer": { model: false, thinking: "medium" },
+			"test-engineer": { model: false, thinking: "low" },
+			verifier: { model: false, thinking: "off" },
+		},
+	},
+	ui: {
+		widgetPlacement: DEFAULT_UI.widgetPlacement,
+		widgetMaxLines: DEFAULT_UI.widgetMaxLines,
+		powerbar: DEFAULT_UI.powerbar,
+		dashboardPlacement: DEFAULT_UI.dashboardPlacement,
+		dashboardWidth: DEFAULT_UI.dashboardWidth,
+		dashboardLiveRefreshMs: DEFAULT_UI.dashboardLiveRefreshMs,
+		autoOpenDashboard: DEFAULT_UI.autoOpenDashboard,
+		autoOpenDashboardForForegroundRuns: DEFAULT_UI.autoOpenDashboardForForegroundRuns,
+		showModel: DEFAULT_UI.showModel,
+		showTokens: DEFAULT_UI.showTokens,
+		showTools: DEFAULT_UI.showTools,
+	},
+};
+
+function copyBuiltinDir(
+	kind: "agents" | "teams" | "workflows",
+	targetDir: string,
+	overwrite: boolean,
+	copiedFiles: string[],
+	skippedFiles: string[],
+): void {
+	const sourceDir = path.join(packageRoot(), kind);
+	if (!fs.existsSync(sourceDir)) return;
+	for (const entry of fs.readdirSync(sourceDir)) {
+		const source = path.join(sourceDir, entry);
+		const target = path.join(targetDir, entry);
+		if (!fs.statSync(source).isFile()) continue;
+		if (fs.existsSync(target) && !overwrite) {
+			skippedFiles.push(target);
+			continue;
+		}
+		fs.copyFileSync(source, target);
+		copiedFiles.push(target);
+	}
+}
+
+export function initializeProject(cwd: string, options: ProjectInitOptions = {}): ProjectInitResult {
+	const createdDirs: string[] = [];
+	const copiedFiles: string[] = [];
+	const skippedFiles: string[] = [];
+	const crewRoot = projectCrewRoot(cwd);
+	const usingLegacyPi = path.basename(crewRoot) === "teams" && path.basename(path.dirname(crewRoot)) === ".pi";
+	const ignorePrefix = usingLegacyPi ? ".pi/teams" : ".crew";
+	const agentsDir = path.join(crewRoot, "agents");
+	const teamsDir = path.join(crewRoot, "teams");
+	const workflowsDir = path.join(crewRoot, "workflows");
+	const configScope = options.configScope ?? "global";
+	const configPath =
+		configScope === "project" ? path.join(projectPiRoot(cwd), "pi-crew.json") : configScope === "global" ? globalConfigPath() : "";
+	ensureDir(agentsDir, createdDirs);
+	ensureDir(teamsDir, createdDirs);
+	ensureDir(workflowsDir, createdDirs);
+	ensureDir(path.join(crewRoot, "imports"), createdDirs);
+
+	let configCreated = false;
+	let configSkipped = false;
+	if (configPath) {
+		if (configScope === "project") ensureDir(path.dirname(configPath), createdDirs);
+		else fs.mkdirSync(path.dirname(configPath), { recursive: true });
+		if (!fs.existsSync(configPath) || options.overwrite === true) {
+			fs.writeFileSync(configPath, `${JSON.stringify(DEFAULT_PI_CREW_CONFIG, null, 2)}\n`, "utf-8");
+			configCreated = true;
+		} else {
+			configSkipped = true;
+		}
+	}
+
+	if (options.copyBuiltins) {
+		copyBuiltinDir("agents", agentsDir, options.overwrite === true, copiedFiles, skippedFiles);
+		copyBuiltinDir("teams", teamsDir, options.overwrite === true, copiedFiles, skippedFiles);
+		copyBuiltinDir("workflows", workflowsDir, options.overwrite === true, copiedFiles, skippedFiles);
+	}
+
+	const ignoreMethod = options.ignoreMethod ?? "gitignore";
+	const desired = [`${ignorePrefix}/state/`, `${ignorePrefix}/artifacts/`, `${ignorePrefix}/worktrees/`, `${ignorePrefix}/imports/`];
+	const gitignorePath = ignoreMethod === "exclude" ? path.join(cwd, ".git", "info", "exclude") : path.join(cwd, ".gitignore");
+	let gitignoreUpdated = false;
+	if (ignoreMethod === "exclude") {
+		// Ensure .git/info/ directory exists
+		const infoDir = path.dirname(gitignorePath);
+		if (!fs.existsSync(infoDir)) {
+			fs.mkdirSync(infoDir, { recursive: true });
+		}
+	}
+	const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf-8") : "";
+	const missing = desired.filter((entry) => !existing.split(/\r?\n/).includes(entry));
+	if (missing.length > 0) {
+		const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+		const comment = "# pi-crew runtime state";
+		fs.writeFileSync(gitignorePath, `${existing}${prefix}\n${comment}\n${missing.join("\n")}\n`, "utf-8");
+		gitignoreUpdated = true;
+	}
+
+	// v0.8.14: pi-crew no longer injects a guidance block into AGENTS.md on init.
+	// AGENTS.md is the USER's project-instructions file (Pi loads it as project
+	// guidance) — extensions modifying it was out-of-scope and redundant: the
+	// `team` tool already self-describes via its schema description, so the agent
+	// learns pi-crew's commands from tool registration, not AGENTS.md.
+	// `team action=cleanup` still removes any block injected by older versions.
+
+	return {
+		createdDirs,
+		copiedFiles,
+		skippedFiles,
+		gitignorePath,
+		gitignoreUpdated,
+		configPath,
+		configScope,
+		configCreated,
+		configSkipped,
+	};
+}

package/src/extension/register.ts

@@ -0,0 +1,113 @@
+/**
+ * pi-crew extension entry point.
+ *
+ * Single import surface Pi calls during extension load: `registerPiTeams(pi)`.
+ * Delegates to focused modules under `./registration/`:
+ *   • registration-types        — shared RegistrationContext
+ *   • context-builder           — buildRegistrationContext (state init)
+ *   • subagent-manager-setup    — SubagentManager + callbacks
+ *   • foreground-run-controller — start/abort/openLiveSidebar
+ *   • runtime-cleanup           — cleanupRuntime + cleanupSwitch
+ *   • lazy-configurers          — notifications/observability/delivery
+ *   • lifecycle-handlers        — session_start/shutdown/before_switch
+ *   • hook-registration         — tool_call/tool_result/resources_discover
+ *   • tool-registration         — registerTeamTool + registerSubagentTools
+ *   • command-registration      — registerTeamCommands
+ *   • crash-recovery-cache      — lazy importCrashRecovery
+ *   • wire-cross-extension      — RPC handle + global registry install
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "../config/config.ts";
+import { primePeerDep } from "../runtime/peer-dep.ts";
+import { startRuntimeWarmup } from "../runtime/runtime-warmup.ts";
+import { deployBundledThemes } from "../ui/deploy-bundled-themes.ts";
+import { resetTimings, time } from "../utils/timings.ts";
+import { registerAutonomousPolicy } from "./autonomous-policy.ts";
+import { registerContextStatusInjection } from "./context-status-injection.ts";
+import { registerCleanupHandler } from "./crew-cleanup.ts";
+import { registerCrewInputRouter } from "./crew-input-router.ts";
+import { registerCrewShortcuts } from "./crew-shortcuts.ts";
+import { registerCrewVibes } from "./crew-vibes/index.ts";
+import { registerKnowledgeInjection } from "./knowledge-injection.ts";
+import { registerCrewMessageRenderers } from "./message-renderers.ts";
+import { registerPiCommands } from "./registration/command-registration.ts";
+import { buildRegistrationContext } from "./registration/context-builder.ts";
+import { importCrashRecovery, purgeStaleActiveRunIndexSyncIfLoaded } from "./registration/crash-recovery-cache.ts";
+import { installForegroundRunController } from "./registration/foreground-run-controller.ts";
+import { installPiHooks } from "./registration/hook-registration.ts";
+import { installLazyConfigurers } from "./registration/lazy-configurers.ts";
+import { installCrewBrokerLifecycleController, installSessionLifecycleHandlers } from "./registration/lifecycle-handlers.ts";
+import { installRuntimeCleanup } from "./registration/runtime-cleanup.ts";
+import { __test__subagentSpawnParams } from "./registration/subagent-helpers.ts";
+import { installSubagentManager } from "./registration/subagent-manager-setup.ts";
+import { registerPiTools } from "./registration/tool-registration.ts";
+import { installCrossExtensionWiring } from "./registration/wire-cross-extension.ts";
+
+export { __test__subagentSpawnParams };
+
+/**
+ * Pi extension entry point. See module-level docstring for the full pipeline.
+ */
+export function registerPiTeams(pi: ExtensionAPI): void {
+	resetTimings();
+	time("register:start");
+
+	startRuntimeWarmup();
+	primePeerDep().catch(() => {});
+	deployBundledThemes();
+
+	const ctx = buildRegistrationContext(pi);
+	ctx.importCrashRecovery = importCrashRecovery;
+	ctx.purgeStaleActiveRunIndexSyncIfLoaded = purgeStaleActiveRunIndexSyncIfLoaded;
+	installRuntimeCleanup(pi, ctx);
+	installForegroundRunController(pi, ctx);
+	installSubagentManager(pi, ctx);
+	installLazyConfigurers(pi, ctx);
+	installCrossExtensionWiring(pi, ctx);
+
+	time("register.policy");
+	registerAutonomousPolicy(pi);
+	registerKnowledgeInjection(pi);
+
+	registerPiTools(pi, ctx);
+	registerPiCommands(pi, ctx);
+	installPiHooks(pi, ctx);
+	installSessionLifecycleHandlers(pi, ctx);
+	// Phase 0 inter-pi broker: install the lifecycle controller immediately
+	// after the session handlers. The controller's gate (broker.enabled AND
+	// root-session only) decides whether anything is actually done; for
+	// subagents or when the flag is off, it returns a no-op controller.
+	ctx.brokerController = installCrewBrokerLifecycleController(pi, ctx);
+
+	registerCleanupHandler(pi, { disposeTerminalStatus: () => ctx.terminalStatus?.dispose?.() });
+	registerCompactionGuard(pi, {
+		foregroundControllers: ctx.foregroundControllers,
+		foregroundTeamRunControllers: ctx.foregroundTeamRunControllers,
+	});
+
+	if (process.env.CREW_RESILIENT_EDIT === "1") {
+		// LAZY: resilient-edit only loads when the opt-in env var is set.
+		import("../runtime/resilient-edit.ts")
+			.then(({ wrapEditWithResilientReplace }) => wrapEditWithResilientReplace(pi))
+			.catch(() => {
+				/* non-critical */
+			});
+	}
+
+	registerCrewMessageRenderers(pi);
+	registerCrewInputRouter(pi);
+	registerCrewShortcuts(pi);
+	registerContextStatusInjection(pi, {
+		enabled: loadConfig(process.cwd()).config.reliability?.ambientStatusInjection !== false,
+	});
+
+	try {
+		registerCrewVibes(pi);
+	} catch (err) {
+		console.warn("[pi-crew] crew-vibes initialization failed:", err instanceof Error ? err.message : err);
+	}
+}
+
+// Bottom-of-file import: keeps compaction-guard out of the top-level
+// import surface to avoid pulling its heavy transitive deps.
+import { registerCompactionGuard } from "./registration/compaction-guard.ts";

package/src/extension/registration/artifact-cleanup.ts

@@ -0,0 +1,20 @@
+import * as path from "node:path";
+import { DEFAULT_ARTIFACT_CLEANUP, DEFAULT_PATHS } from "../../config/defaults.ts";
+import { CLEANUP_MARKER_FILE, cleanupOldArtifacts } from "../../state/artifact-store.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { projectCrewRoot, userCrewRoot } from "../../utils/paths.ts";
+
+export function runArtifactCleanup(cwd: string): void {
+	try {
+		cleanupOldArtifacts(path.join(userCrewRoot(), DEFAULT_PATHS.state.artifactsSubdir), {
+			maxAgeDays: DEFAULT_ARTIFACT_CLEANUP.maxAgeDays,
+			markerFile: CLEANUP_MARKER_FILE,
+		});
+		cleanupOldArtifacts(path.join(projectCrewRoot(cwd), DEFAULT_PATHS.state.artifactsSubdir), {
+			maxAgeDays: DEFAULT_ARTIFACT_CLEANUP.maxAgeDays,
+			markerFile: CLEANUP_MARKER_FILE,
+		});
+	} catch (error) {
+		logInternalError("register.artifact-cleanup", error, `cwd=${cwd}`);
+	}
+}

package/src/extension/registration/command-registration.ts

@@ -0,0 +1,58 @@
+/**
+ * Command registration installer for pi-crew.
+ *
+ * Single entry point that wires every `pi.registerCommand(...)` call
+ * site in the extension. Today that means one heavy call:
+ *   • `registerTeamCommands` — registers every `/crew-*`, `/team-*`,
+ *     `/teams`, and friends. The full set lives in
+ *     `registration/commands.ts` (already extracted); this file is
+ *     the orchestrator-level wrapper that calls it with the right deps.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "../../config/config.ts";
+import { updatePiCrewPowerbar } from "../../ui/powerbar-publisher.ts";
+import { updateCrewWidget } from "../../ui/widget/index.ts";
+import { registerTeamCommands } from "./commands.ts";
+import type { RegistrationContext } from "./registration-types.ts";
+
+/**
+ * Register all pi-crew slash commands on the ExtensionAPI.
+ *
+ * The dismiss-notifications callback (used by commands like
+ * `/crew-notifications dismiss`) needs to refresh both the widget and
+ * the powerbar with the new count, so we read `currentCtx` + `widgetState`
+ * lazily off the context.
+ */
+export function registerPiCommands(pi: ExtensionAPI, ctx: RegistrationContext): void {
+	registerTeamCommands(pi, {
+		startForegroundRun: ctx.startForegroundRun,
+		abortForegroundRun: ctx.abortForegroundRun,
+		openLiveSidebar: ctx.openLiveSidebar,
+		getManifestCache: ctx.getManifestCache,
+		getRunSnapshotCache: ctx.getRunSnapshotCache,
+		getMetricRegistry: () => ctx.observabilityState.metricRegistry,
+		uiState: ctx.uiState,
+		dismissNotifications: () => {
+			ctx.widgetState.notificationCount = 0;
+			if (ctx.currentCtx) {
+				const uiConfig = loadConfig(ctx.currentCtx.cwd).config.ui;
+				updateCrewWidget(
+					ctx.currentCtx,
+					ctx.widgetState,
+					uiConfig,
+					ctx.getManifestCache(ctx.currentCtx.cwd),
+					ctx.getRunSnapshotCache(ctx.currentCtx.cwd),
+				);
+				updatePiCrewPowerbar(
+					pi.events,
+					ctx.currentCtx.cwd,
+					uiConfig,
+					ctx.getManifestCache(ctx.currentCtx.cwd),
+					ctx.getRunSnapshotCache(ctx.currentCtx.cwd),
+					ctx.currentCtx,
+					0,
+				);
+			}
+		},
+	});
+}

package/src/extension/registration/command-utils.ts

@@ -0,0 +1,58 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+
+export function parseRunArgs(args: string): TeamToolParamsValue {
+	const tokens = args.match(/"[^"]*"|'[^']*'|\S+/g)?.map((token) => token.replace(/^['"]|['"]$/g, "")) ?? [];
+	const params: TeamToolParamsValue = { action: "run" };
+	const goalParts: string[] = [];
+	for (const token of tokens) {
+		if (token === "--async") params.async = true;
+		else if (token === "--worktree") params.workspaceMode = "worktree";
+		else if (token.startsWith("--team=")) params.team = token.slice("--team=".length);
+		else if (token.startsWith("--workflow=")) params.workflow = token.slice("--workflow=".length);
+		else if (token.startsWith("--agent=")) params.agent = token.slice("--agent=".length);
+		else if (token.startsWith("--role=")) params.role = token.slice("--role=".length);
+		else if (!params.team && goalParts.length === 0 && !token.startsWith("--")) params.team = token;
+		else goalParts.push(token);
+	}
+	params.goal = goalParts.join(" ").trim() || undefined;
+	return params;
+}
+
+export function commandText(result: { content?: Array<{ type: string; text?: string }> }): string {
+	return result.content?.map((item) => item.text ?? "").join("\n") ?? "";
+}
+
+export async function notifyCommandResult(ctx: ExtensionCommandContext, text: string): Promise<void> {
+	ctx.ui.notify(text.length > 800 ? `${text.slice(0, 797)}...` : text, "info");
+}
+
+export function parseScalar(raw: string): unknown {
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+	if (/^-?\d+$/.test(raw)) return Number(raw);
+	if (raw.includes(","))
+		return raw
+			.split(",")
+			.map((entry) => entry.trim())
+			.filter(Boolean);
+	return raw;
+}
+
+export function pushUnset(config: Record<string, unknown>, key: string): void {
+	const current = Array.isArray(config.unset) ? config.unset : [];
+	current.push(key);
+	config.unset = current;
+}
+
+export function setNestedConfig(config: Record<string, unknown>, key: string, value: unknown): void {
+	const parts = key.split(".").filter(Boolean);
+	if (parts.length === 0) return;
+	let target = config;
+	for (const part of parts.slice(0, -1)) {
+		const current = target[part];
+		if (!current || typeof current !== "object" || Array.isArray(current)) target[part] = {};
+		target = target[part] as Record<string, unknown>;
+	}
+	target[parts[parts.length - 1]!] = value;
+}