@phi-code-admin/phi-code 0.62.2 → 0.63.1

package/extensions/phi/orchestrator.ts

@@ -2,21 +2,18 @@
  * Orchestrator Extension - Full-cycle project planning and execution
  *
  * WORKFLOW (single command):
- *   /plan <description> → LLM analyzes → orchestrate tool → spec + todo → auto-execute → progress
- *   Everything happens in one shot. No manual steps.
+ *   /plan <description> → 5 sequential agent phases → each with its own model
+ *
+ * The orchestrator uses event-driven phase chaining:
+ *   1. Send phase 1 message with model A
+ *   2. Detect when agent goes idle (output event + polling)
+ *   3. Switch to model B, send phase 2
+ *   4. Repeat until all 5 phases complete
  *
  * Commands:
- *   /plan   — Full workflow: plan + execute with sub-agents
- *   /run    — Re-execute an existing plan (e.g. after fixes)
+ *   /plan   — Full workflow: plan + execute with agents
+ *   /run    — Re-execute an existing plan
  *   /plans  — List plans and their execution status
- *
- * Sub-agent execution:
- * Each task spawns a separate `phi` CLI process with:
- * - Its own system prompt (from the agent .md file)
- * - Its own model (from routing.json)
- * - Its own context (isolated, no shared history)
- * - Its own tool access (read, write, edit, bash, etc.)
- * Results are collected into progress.md and reported to the user.
  */
 
 import { Type } from "@sinclair/typebox";
@@ -451,10 +448,226 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	// ─── Orchestration State ─────────────────────────────────────────
+
+	interface AgentDef {
+		name: string;
+		tools: string[];
+		systemPrompt: string;
+	}
+
+	interface OrchestratorPhase {
+		key: string;
+		label: string;
+		model: string;
+		fallback: string;
+		agent: AgentDef | null;
+		instruction: string;
+	}
+
+	let phaseQueue: OrchestratorPhase[] = [];
+	let orchestrationActive = false;
+	let idlePollTimer: ReturnType<typeof setInterval> | null = null;
+	let activeAgentPrompt: string | null = null;
+	let activeAgentTools: string[] | null = null;
+	let savedTools: string[] | null = null;
+
+	/**
+	 * Parse agent .md file with YAML frontmatter
+	 */
+	function loadAgentDef(name: string): AgentDef | null {
+		const dirs = [
+			join(process.cwd(), ".phi", "agents"),
+			join(homedir(), ".phi", "agent", "agents"),
+		];
+		for (const dir of dirs) {
+			const filePath = join(dir, `${name}.md`);
+			try {
+				const content = readFileSync(filePath, "utf-8");
+				const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+				if (!fmMatch) continue;
+				const fields: Record<string, string> = {};
+				for (const line of fmMatch[1].split("\n")) {
+					const m = line.match(/^(\w+):\s*(.*)$/);
+					if (m) fields[m[1]] = m[2].trim();
+				}
+				return {
+					name: fields.name || name,
+					tools: (fields.tools || "").split(",").map(t => t.trim()).filter(Boolean),
+					systemPrompt: fmMatch[2].trim(),
+				};
+			} catch { continue; }
+		}
+		return null;
+	}
+
+	/**
+	 * Load routing config and build phase queue with model assignments + agent definitions.
+	 */
+	function buildPhases(description: string): OrchestratorPhase[] {
+		const routingPath = join(homedir(), ".phi", "agent", "routing.json");
+		let routing: any = { routes: {}, default: { model: "default" } };
+		try {
+			routing = JSON.parse(readFileSync(routingPath, "utf-8"));
+		} catch { /* no routing config */ }
+
+		function getModel(routeKey: string): { preferred: string; fallback: string } {
+			const route = routing.routes?.[routeKey];
+			return {
+				preferred: route?.preferredModel || routing.default?.model || "default",
+				fallback: route?.fallback || routing.default?.model || "default",
+			};
+		}
+
+		const explore = getModel("explore");
+		const plan = getModel("plan");
+		const code = getModel("code");
+		const test = getModel("test");
+		const review = getModel("review");
+
+		return [
+			{
+				key: "explore", label: "🔍 Phase 1 — EXPLORE", model: explore.preferred, fallback: explore.fallback,
+				agent: loadAgentDef("explore"),
+				instruction: `Analyze the project requirements and existing codebase. Identify what exists, what's needed, and any constraints.\n\n**Project:** ${description}\n\nList files, read key ones, check dependencies. Return a structured summary.`,
+			},
+			{
+				key: "plan", label: "📐 Phase 2 — PLAN", model: plan.preferred, fallback: plan.fallback,
+				agent: loadAgentDef("plan"),
+				instruction: `Design the architecture for this project. Define file structure, tech choices, and implementation approach.\n\n**Project:** ${description}\n\nBe specific: list every file to create with its purpose.`,
+			},
+			{
+				key: "code", label: "💻 Phase 3 — CODE", model: code.preferred, fallback: code.fallback,
+				agent: loadAgentDef("code"),
+				instruction: `Implement the COMPLETE project. Create ALL files with production-quality code.\n\n**Project:** ${description}\n\n**Rules:**\n- Create every file needed\n- No placeholders, no TODOs, no stubs\n- Every function must be fully implemented\n- Follow the architecture from the previous planning phase`,
+			},
+			{
+				key: "test", label: "🧪 Phase 4 — TEST", model: test.preferred, fallback: test.fallback,
+				agent: loadAgentDef("test"),
+				instruction: `Test the implementation. Run the code, check for errors, verify it works.\n\n**Project:** ${description}\n\nFix any errors you find. Ensure the project runs correctly.`,
+			},
+			{
+				key: "review", label: "🔍 Phase 5 — REVIEW", model: review.preferred, fallback: review.fallback,
+				agent: loadAgentDef("review"),
+				instruction: `Review the code quality, security, and performance. Fix any issues.\n\n**Project:** ${description}\n\nCheck: error handling, edge cases, code style, documentation.`,
+			},
+		];
+	}
+
+	/**
+	 * Switch model for the current phase.
+	 */
+	async function switchModelForPhase(phase: OrchestratorPhase, ctx: any): Promise<string> {
+		const available = ctx.modelRegistry?.getAvailable?.() || [];
+		const preferred = available.find((m: any) => m.id === phase.model);
+		const fallback = available.find((m: any) => m.id === phase.fallback);
+		const target = preferred || fallback;
+
+		if (target && target.id !== ctx.model?.id) {
+			const switched = await pi.setModel(target);
+			if (switched) return target.id;
+		}
+		return ctx.model?.id || phase.model;
+	}
+
+	/**
+	 * Activate agent for a phase: set system prompt + restrict tools.
+	 */
+	function activateAgent(phase: OrchestratorPhase, ctx: any) {
+		if (phase.agent) {
+			// Save current tools for restoration
+			if (!savedTools) {
+				savedTools = pi.getActiveTools();
+			}
+			// Set agent's system prompt (will be injected via before_agent_start)
+			activeAgentPrompt = phase.agent.systemPrompt;
+			// Restrict tools to agent's allowed tools
+			if (phase.agent.tools.length > 0) {
+				activeAgentTools = phase.agent.tools;
+				pi.setActiveTools(phase.agent.tools);
+			}
+		} else {
+			activeAgentPrompt = null;
+			activeAgentTools = null;
+		}
+	}
+
+	/**
+	 * Deactivate agent: restore tools, clear prompt override.
+	 */
+	function deactivateAgent() {
+		activeAgentPrompt = null;
+		activeAgentTools = null;
+		if (savedTools) {
+			pi.setActiveTools(savedTools);
+			savedTools = null;
+		}
+	}
+
+	/**
+	 * Send the next phase in the queue.
+	 */
+	function sendNextPhase(ctx: any) {
+		if (phaseQueue.length === 0) {
+			orchestrationActive = false;
+			deactivateAgent();
+			ctx.ui.notify(`\n✅ **All 5 phases complete!**`, "info");
+			return;
+		}
+
+		const phase = phaseQueue.shift()!;
+
+		switchModelForPhase(phase, ctx).then((modelId) => {
+			activateAgent(phase, ctx);
+			const agentName = phase.agent?.name || phase.key;
+			ctx.ui.notify(`\n${phase.label} → \`${modelId}\` (agent: ${agentName})`, "info");
+			setTimeout(() => pi.sendUserMessage(phase.instruction), 200);
+		});
+	}
+
+	// ─── System Prompt Injection — Agent personas ────────────────────
+
+	pi.on("before_agent_start", async (event, _ctx) => {
+		if (!orchestrationActive || !activeAgentPrompt) {
+			return { };
+		}
+		// Replace system prompt with the active agent's prompt
+		return { systemPrompt: activeAgentPrompt };
+	});
+
+	// ─── Output Event — Phase Chaining ───────────────────────────────
+
+	pi.on("output", async (_event, ctx) => {
+		if (!orchestrationActive || phaseQueue.length === 0) return;
+
+		if (idlePollTimer) {
+			clearInterval(idlePollTimer);
+			idlePollTimer = null;
+		}
+
+		let attempts = 0;
+		idlePollTimer = setInterval(() => {
+			attempts++;
+			if (attempts > 120) {
+				clearInterval(idlePollTimer!);
+				idlePollTimer = null;
+				ctx.ui.notify("⚠️ Orchestrator timeout — phase took too long.", "warning");
+				orchestrationActive = false;
+				deactivateAgent();
+				return;
+			}
+			if (ctx.isIdle()) {
+				clearInterval(idlePollTimer!);
+				idlePollTimer = null;
+				sendNextPhase(ctx);
+			}
+		}, 500);
+	});
+
 	// ─── /plan Command — Full workflow ───────────────────────────────
 
 	pi.registerCommand("plan", {
-		description: "Plan AND execute a project with agents — describe what to build",
+		description: "Plan AND execute a project — 5 phases, each with its own model from routing.json",
 		handler: async (args, ctx) => {
 			const description = args.trim();
 
@@ -477,36 +690,28 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 			const specFile = `spec-${ts}.md`;
 			await writeFile(join(plansDir, specFile), `# ${description}\n\n**Created:** ${new Date().toLocaleString()}\n`, "utf-8");
 
-			ctx.ui.notify(`📋 Launching orchestrator...`, "info");
-
-			// Build a single comprehensive prompt with all agent phases
-			const prompt = `# Project: ${description}
-
-## Your workflow (follow these phases in order):
-
-### Phase 1 — 🔍 EXPLORE
-Analyze the project requirements and any existing codebase. List what exists, what's needed, and constraints.
-
-### Phase 2 — 📐 PLAN  
-Design the architecture, file structure, and tech choices. Be specific about file names and structure.
+			// Build phases with model assignments + agent definitions
+			const phases = buildPhases(description);
+			phaseQueue = phases.slice(1); // Queue phases 2-5
+			orchestrationActive = true;
+			const firstPhase = phases[0];
 
-### Phase 3 — 💻 CODE
-Implement EVERYTHING. Create ALL files with complete, production-quality code. No placeholders, no TODOs, no "implement later". Every file must be fully functional.
+			ctx.ui.notify(`📋 **Orchestrator started** — 5 phases with model routing + agent roles\n`, "info");
 
-### Phase 4 — 🧪 TEST
-Run the code. Verify it works. Fix any errors you find.
-
-### Phase 5 — 🔍 REVIEW
-Check code quality. Fix any issues. Ensure everything is polished.
-
-## Rules
-- Complete ALL 5 phases in this turn
-- Create every file needed for a working project
-- Announce each phase as you start it (e.g. "## Phase 1 — Exploring...")
-- Do NOT stop after planning — implement everything`;
-
-			// Send after handler returns (agent goes idle after command completes)
-			setTimeout(() => pi.sendUserMessage(prompt), 200);
+			// Show the plan
+			for (const p of phases) {
+				const agentName = p.agent?.name || p.key;
+				const toolCount = p.agent?.tools.length || 0;
+				ctx.ui.notify(`  ${p.label} → \`${p.model}\` (agent: ${agentName}, ${toolCount} tools)`, "info");
+			}
+			ctx.ui.notify("", "info");
+
+			// Switch model and activate agent for first phase
+			const modelId = await switchModelForPhase(firstPhase, ctx);
+			activateAgent(firstPhase, ctx);
+			const agentName = firstPhase.agent?.name || firstPhase.key;
+			ctx.ui.notify(`${firstPhase.label} → \`${modelId}\` (agent: ${agentName})`, "info");
+			setTimeout(() => pi.sendUserMessage(firstPhase.instruction), 200);
 		},
 	});
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.62.2",
+	"version": "0.63.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {