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

package/extensions/phi/init.ts

@@ -1,10 +1,8 @@
 /**
  * Phi Init Extension - Interactive setup wizard for Phi Code
  *
- * Three modes:
- * - auto: Use Alibaba Coding Plan defaults (instant, recommended)
- * - benchmark: Test available models with /benchmark, then assign (10-15 min)
- * - manual: User assigns each model role interactively
+ * Detects providers (API keys + local endpoints), then lets the user
+ * manually assign models to each agent role (code, debug, plan, explore, test, review).
  *
  * Creates ~/.phi/agent/ structure with routing, agents, and memory.
  */
@@ -13,7 +11,7 @@ import type { ExtensionAPI } from "phi-code";
 import { writeFile, mkdir, copyFile, readdir, access, readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 
 // ─── Types ───────────────────────────────────────────────────────────────
 
@@ -367,270 +365,10 @@ _Edit this file to customize Phi Code's behavior for your project._
 
 	// ─── MODE: Auto ──────────────────────────────────────────────────
 
-	// ─── Model Intelligence Database ─────────────────────────────────
-
-	interface ModelProfile {
-		id: string;
-		capabilities: {
-			coding: number;    // 0-100 score for code generation
-			reasoning: number; // 0-100 score for debugging/planning
-			speed: number;     // 0-100 score for fast tasks
-			general: number;   // 0-100 overall score
-		};
-		hasReasoning: boolean;
-	}
-
 	/**
-	 * Fetch model profiles from OpenRouter's free API.
-	 * Classifies each model based on its description, name, and supported parameters.
-	 * Falls back to name-based heuristics if OpenRouter is unreachable.
+	 * Manual mode is the only setup mode.
+	 * User assigns each model to each agent role interactively.
 	 */
-	async function fetchModelProfiles(modelIds: string[]): Promise<Map<string, ModelProfile>> {
-		const profiles = new Map<string, ModelProfile>();
-
-		try {
-			const controller = new AbortController();
-			const timeout = setTimeout(() => controller.abort(), 5000);
-			const res = await fetch("https://openrouter.ai/api/v1/models", {
-				signal: controller.signal,
-			});
-			clearTimeout(timeout);
-
-			if (res.ok) {
-				const data = await res.json() as any;
-				const orModels: any[] = data.data || [];
-
-				for (const modelId of modelIds) {
-					// Try exact match first, then fuzzy match by base name
-					const baseName = modelId.replace(/:.+$/, "").split("/").pop()?.toLowerCase() || modelId.toLowerCase();
-					const match = orModels.find((m: any) => {
-						const mId = m.id?.toLowerCase() || "";
-						const mName = m.name?.toLowerCase() || "";
-						return mId.includes(baseName) || mName.includes(baseName);
-					});
-
-					if (match) {
-						const desc = (match.description || "").toLowerCase();
-						const name = (match.name || "").toLowerCase();
-						const hasReasoning = (match.supported_parameters || []).includes("reasoning")
-							|| (match.supported_parameters || []).includes("include_reasoning");
-
-						// Score based on description keywords and model characteristics
-						let coding = 50, reasoning = 50, speed = 50, general = 60;
-
-						// Coding signals
-						if (/cod(e|ing|ex)|program|implement|refactor|software engineer/.test(desc) || /coder|codex|codestral/.test(name)) {
-							coding = 85;
-						}
-						// Reasoning signals
-						if (hasReasoning || /reason|think|logic|step.by.step|complex/.test(desc) || /o1|o3|pro|opus/.test(name)) {
-							reasoning = 85;
-						}
-						// Speed signals (smaller/cheaper models)
-						const pricing = match.pricing || {};
-						const promptCost = parseFloat(pricing.prompt || "0.01");
-						if (promptCost < 0.001 || /fast|flash|mini|small|haiku|lite|instant/.test(name)) {
-							speed = 85;
-						}
-						// General quality (larger context = usually better)
-						const ctx = match.context_length || 0;
-						if (ctx >= 200000) general = 80;
-						if (ctx >= 1000000) general = 90;
-						if (/frontier|flagship|most.advanced|best|state.of.the.art/.test(desc)) general = 90;
-
-						profiles.set(modelId, { id: modelId, capabilities: { coding, reasoning, speed, general }, hasReasoning });
-					}
-				}
-			}
-		} catch {
-			// OpenRouter unreachable — will fall back to heuristics
-		}
-
-		// Fill in any models not found in OpenRouter with name-based heuristics
-		for (const modelId of modelIds) {
-			if (!profiles.has(modelId)) {
-				profiles.set(modelId, classifyByName(modelId));
-			}
-		}
-
-		return profiles;
-	}
-
-	/**
-	 * Fallback: classify model by name patterns when OpenRouter data is unavailable.
-	 */
-	function classifyByName(modelId: string): ModelProfile {
-		const l = modelId.toLowerCase();
-		let coding = 50, reasoning = 50, speed = 50, general = 55;
-		let hasReasoning = false;
-
-		if (/coder|code|codestral/.test(l)) coding = 80;
-		if (/max|pro|plus|opus|large|o1|o3/.test(l)) { reasoning = 80; general = 75; }
-		if (/mini|flash|fast|small|haiku|lite/.test(l)) { speed = 80; }
-		if (/o1|o3|deepseek-r1|qwq/.test(l)) { hasReasoning = true; reasoning = 85; }
-
-		return { id: modelId, capabilities: { coding, reasoning, speed, general }, hasReasoning };
-	}
-
-	/**
-	 * Auto-assign models using OpenRouter rankings + models.dev data.
-	 * Works with ANY provider — cloud, local, or mixed.
-	 *
-	 * Strategy:
-	 * 1. Fetch model profiles from OpenRouter (free, no API key needed)
-	 * 2. Score each model for coding, reasoning, speed, and general tasks
-	 * 3. Assign best model per role based on scores
-	 * 4. Fall back to name-based heuristics if OpenRouter is unreachable
-	 * 5. Single model? → everything uses that model (still works!)
-	 */
-	async function autoMode(availableModels: string[], ctx?: any): Promise<Record<string, { preferred: string; fallback: string }>> {
-		const assignments: Record<string, { preferred: string; fallback: string }> = {};
-
-		if (availableModels.length === 0) {
-			const fb = { preferred: "default", fallback: "default" };
-			for (const role of TASK_ROLES) assignments[role.key] = fb;
-			assignments["default"] = fb;
-			return assignments;
-		}
-
-		if (availableModels.length === 1) {
-			const single = { preferred: availableModels[0], fallback: availableModels[0] };
-			for (const role of TASK_ROLES) assignments[role.key] = single;
-			assignments["default"] = single;
-			return assignments;
-		}
-
-		// Fetch intelligence from OpenRouter
-		if (ctx) ctx.ui.notify("📊 Fetching model rankings from OpenRouter...", "info");
-		const profiles = await fetchModelProfiles(availableModels);
-
-		// Find best model for each capability
-		function bestFor(capability: keyof ModelProfile["capabilities"]): string {
-			let best = availableModels[0], bestScore = 0;
-			for (const id of availableModels) {
-				const p = profiles.get(id);
-				if (p && p.capabilities[capability] > bestScore) {
-					bestScore = p.capabilities[capability];
-					best = id;
-				}
-			}
-			return best;
-		}
-
-		function secondBestFor(capability: keyof ModelProfile["capabilities"], excludeId: string): string {
-			let best = availableModels.find(m => m !== excludeId) || excludeId;
-			let bestScore = 0;
-			for (const id of availableModels) {
-				if (id === excludeId) continue;
-				const p = profiles.get(id);
-				if (p && p.capabilities[capability] > bestScore) {
-					bestScore = p.capabilities[capability];
-					best = id;
-				}
-			}
-			return best;
-		}
-
-		const bestCoder = bestFor("coding");
-		const bestReasoner = bestFor("reasoning");
-		const bestFast = bestFor("speed");
-		const bestGeneral = bestFor("general");
-
-		assignments["code"] = { preferred: bestCoder, fallback: secondBestFor("coding", bestCoder) };
-		assignments["debug"] = { preferred: bestReasoner, fallback: secondBestFor("reasoning", bestReasoner) };
-		assignments["plan"] = { preferred: bestReasoner, fallback: secondBestFor("reasoning", bestReasoner) };
-		assignments["explore"] = { preferred: bestFast, fallback: secondBestFor("speed", bestFast) };
-		assignments["test"] = { preferred: bestFast, fallback: secondBestFor("speed", bestFast) };
-		assignments["review"] = { preferred: bestGeneral, fallback: secondBestFor("general", bestGeneral) };
-		assignments["default"] = { preferred: bestGeneral, fallback: secondBestFor("general", bestGeneral) };
-
-		// Show what was assigned and why
-		if (ctx) {
-			ctx.ui.notify("📊 Model rankings applied:", "info");
-			for (const role of TASK_ROLES) {
-				const a = assignments[role.key];
-				const p = profiles.get(a.preferred);
-				const scores = p ? `(coding:${p.capabilities.coding} reasoning:${p.capabilities.reasoning} speed:${p.capabilities.speed})` : "";
-				ctx.ui.notify(`  ${role.label}: ${a.preferred} ${scores}`, "info");
-			}
-		}
-
-		return assignments;
-	}
-
-	// ─── MODE: Benchmark ─────────────────────────────────────────────
-
-	async function benchmarkMode(availableModels: string[], ctx: any): Promise<Record<string, { preferred: string; fallback: string }>> {
-		// Check if benchmark results already exist
-		const benchmarkPath = join(phiDir, "benchmark", "results.json");
-		let existingResults: any = null;
-		try {
-			await access(benchmarkPath);
-			const content = await readFile(benchmarkPath, "utf-8");
-			existingResults = JSON.parse(content);
-		} catch {
-			// No existing results
-		}
-
-		if (existingResults?.results?.length > 0) {
-			const useExisting = await ctx.ui.confirm(
-				"Use existing benchmarks?",
-				`Found ${existingResults.results.length} benchmark results from a previous run. Use them?`
-			);
-			if (useExisting) {
-				ctx.ui.notify("📊 Using existing benchmark results for model assignment.\n", "info");
-				return assignFromBenchmark(existingResults.results, availableModels);
-			}
-		}
-
-		// No existing results or user declined — run benchmarks now
-		ctx.ui.notify("🧪 Benchmark mode: launching model tests...", "info");
-		ctx.ui.notify("This tests each model with 6 coding tasks via real API calls.", "info");
-		ctx.ui.notify("⏱️ Estimated time: 2-3 minutes per model.\n", "info");
-
-		// Trigger benchmark via sendUserMessage — this runs /benchmark all
-		// which saves results to the same results.json path
-		pi.sendUserMessage("/benchmark all");
-		ctx.ui.notify("⏳ Benchmarks started. Once complete, run `/phi-init` again and select benchmark mode to use the results.\n", "info");
-		ctx.ui.notify("💡 The benchmark runs in the background. You'll see live results in the terminal.\n", "info");
-
-		// Return auto mode assignments as temporary defaults
-		// (will be overwritten when user re-runs /phi-init with benchmark results)
-		ctx.ui.notify("📋 Setting auto-mode defaults while benchmarks run...\n", "info");
-		return autoMode(availableModels, ctx);
-	}
-
-	function assignFromBenchmark(results: any[], availableModels: string[]): Record<string, { preferred: string; fallback: string }> {
-		const assignments: Record<string, { preferred: string; fallback: string }> = {};
-
-		// Sort by total score
-		const sorted = [...results].sort((a: any, b: any) => (b.totalScore || 0) - (a.totalScore || 0));
-		const bestOverall = sorted[0]?.modelId || availableModels[0];
-		const secondBest = sorted[1]?.modelId || bestOverall;
-
-		// Find best per category
-		function bestForCategory(category: string): string {
-			let best = { id: bestOverall, score: 0 };
-			for (const r of results) {
-				const catScore = r.categories?.[category]?.score ?? 0;
-				if (catScore > best.score) {
-					best = { id: r.modelId, score: catScore };
-				}
-			}
-			return best.id;
-		}
-
-		assignments["code"] = { preferred: bestForCategory("code-gen"), fallback: secondBest };
-		assignments["debug"] = { preferred: bestForCategory("debug"), fallback: secondBest };
-		assignments["plan"] = { preferred: bestForCategory("planning"), fallback: secondBest };
-		assignments["explore"] = { preferred: bestForCategory("speed"), fallback: secondBest };
-		assignments["test"] = { preferred: bestForCategory("speed"), fallback: secondBest };
-		assignments["review"] = { preferred: bestForCategory("orchestration"), fallback: secondBest };
-		assignments["default"] = { preferred: bestOverall, fallback: secondBest };
-
-		return assignments;
-	}
-
 	// ─── MODE: Manual ────────────────────────────────────────────────
 
 	async function manualMode(availableModels: string[], ctx: any): Promise<Record<string, { preferred: string; fallback: string }>> {
@@ -670,7 +408,7 @@ _Edit this file to customize Phi Code's behavior for your project._
 	// ─── Command ─────────────────────────────────────────────────────
 
 	pi.registerCommand("phi-init", {
-		description: "Initialize Phi Code — interactive setup wizard (3 modes: auto, benchmark, manual)",
+		description: "Initialize Phi Code — interactive setup wizard",
 		handler: async (args, ctx) => {
 			try {
 				ctx.ui.notify("╔══════════════════════════════════════╗", "info");
@@ -811,29 +549,10 @@ _Edit this file to customize Phi Code's behavior for your project._
 				const allModels = getAllAvailableModels(providers);
 				ctx.ui.notify(`\n✅ **${allModels.length} models** available from ${available.length} provider(s).\n`, "info");
 
-				// 2. Choose mode
-				const modeOptions = [
-					"auto — Use optimal defaults (instant)",
-					"benchmark — Test models first, assign by results (10-15 min)",
-					"manual — Choose each model yourself",
-				];
-				const modeChoice = await ctx.ui.select("Setup mode", modeOptions);
-				const mode = (modeChoice ?? "").startsWith("benchmark") ? "benchmark"
-					: (modeChoice ?? "").startsWith("manual") ? "manual"
-					: "auto";
-
-				ctx.ui.notify(`\n📋 Mode: **${mode}**\n`, "info");
-
-				// 3. Get assignments based on mode
-				let assignments: Record<string, { preferred: string; fallback: string }>;
-
-				if (mode === "auto") {
-					assignments = await autoMode(allModels, ctx);
-				} else if (mode === "benchmark") {
-					assignments = await benchmarkMode(allModels, ctx);
-				} else {
-					assignments = await manualMode(allModels, ctx);
-				}
+				// 2. Assign models to agents (manual)
+				ctx.ui.notify(`\n📋 **Assign a model to each agent role:**\n`, "info");
+
+				const assignments = await manualMode(allModels, ctx);
 
 				// 4. Create directory structure
 				ctx.ui.notify("\n📁 Creating directories...", "info");
@@ -882,130 +601,4 @@ _Edit this file to customize Phi Code's behavior for your project._
 		},
 	});
 
-	// ─── API Key Management Command ─────────────────────────────────
-
-	pi.registerCommand("api-key", {
-		description: "Set or view API keys (usage: /api-key set <provider> <key> | /api-key list)",
-		handler: async (args, ctx) => {
-			const parts = args.trim().split(/\s+/);
-			const action = parts[0]?.toLowerCase();
-
-			const PROVIDERS: Record<string, { envVar: string; name: string }> = {
-				alibaba: { envVar: "ALIBABA_CODING_PLAN_KEY", name: "Alibaba Coding Plan" },
-				dashscope: { envVar: "DASHSCOPE_API_KEY", name: "DashScope (Alibaba)" },
-				openai: { envVar: "OPENAI_API_KEY", name: "OpenAI" },
-				anthropic: { envVar: "ANTHROPIC_API_KEY", name: "Anthropic" },
-				google: { envVar: "GOOGLE_API_KEY", name: "Google" },
-				openrouter: { envVar: "OPENROUTER_API_KEY", name: "OpenRouter" },
-				groq: { envVar: "GROQ_API_KEY", name: "Groq" },
-				brave: { envVar: "BRAVE_API_KEY", name: "Brave Search" },
-			};
-
-			if (!action || action === "help") {
-				ctx.ui.notify(`**🔑 API Key Management**
-
-Usage:
-  /api-key set <provider> <key>   — Set an API key for this session
-  /api-key list                   — Show configured providers
-  /api-key providers              — List all supported providers
-
-Supported providers: ${Object.keys(PROVIDERS).join(", ")}
-
-Example:
-  /api-key set alibaba sk-sp-xxx
-  /api-key set openai sk-xxx
-
-Keys set with /api-key are active for the current session.
-For persistence, set environment variables:
-  • Windows: setx ALIBABA_CODING_PLAN_KEY "your-key"
-  • Linux/Mac: export ALIBABA_CODING_PLAN_KEY="your-key"`, "info");
-				return;
-			}
-
-			if (action === "list") {
-				let found = 0;
-				let msg = "**🔑 Configured API Keys:**\n";
-				for (const [id, info] of Object.entries(PROVIDERS)) {
-					const key = process.env[info.envVar];
-					if (key) {
-						const masked = key.substring(0, 6) + "..." + key.substring(key.length - 4);
-						msg += `  ✅ ${info.name} (${id}): ${masked}\n`;
-						found++;
-					}
-				}
-				if (found === 0) {
-					msg += "  ❌ No API keys configured\n";
-					msg += "\nUse `/api-key set <provider> <key>` to add one.";
-				}
-				ctx.ui.notify(msg, "info");
-				return;
-			}
-
-			if (action === "providers") {
-				let msg = "**Supported Providers:**\n";
-				for (const [id, info] of Object.entries(PROVIDERS)) {
-					const status = process.env[info.envVar] ? "✅" : "⬜";
-					msg += `  ${status} **${id}** — ${info.name} (${info.envVar})\n`;
-				}
-				ctx.ui.notify(msg, "info");
-				return;
-			}
-
-			if (action === "set") {
-				const provider = parts[1]?.toLowerCase();
-				const key = parts.slice(2).join(" ").trim();
-
-				if (!provider || !key) {
-					ctx.ui.notify("Usage: /api-key set <provider> <key>\nExample: /api-key set alibaba sk-sp-xxx", "warning");
-					return;
-				}
-
-				const info = PROVIDERS[provider];
-				if (!info) {
-					ctx.ui.notify(`Unknown provider "${provider}". Supported: ${Object.keys(PROVIDERS).join(", ")}`, "error");
-					return;
-				}
-
-				// Set in current process environment
-				process.env[info.envVar] = key;
-				if (provider === "alibaba") {
-					process.env.DASHSCOPE_API_KEY = key;
-				}
-
-				// Persist to models.json
-				const modelsJsonPath = join(homedir(), ".phi", "agent", "models.json");
-				let modelsConfig: any = { providers: {} };
-				try {
-					const existing = readFileSync(modelsJsonPath, "utf-8");
-					modelsConfig = JSON.parse(existing);
-				} catch { /* file doesn't exist yet */ }
-
-				// Find provider config from detectProviders
-				const providerDefs = detectProviders();
-				const providerDef = providerDefs.find(p => p.envVar === info.envVar);
-				if (providerDef) {
-					const providerId = providerDef.name.toLowerCase().replace(/\s+/g, "-");
-					modelsConfig.providers[providerId] = {
-						baseUrl: providerDef.baseUrl,
-						api: "openai-completions",
-						apiKey: key,
-						models: await Promise.all(providerDef.models.map(async (id: string) => {
-							const spec = await getModelSpec(id);
-							return {
-								id, name: id, reasoning: spec.reasoning, input: ["text"],
-								contextWindow: spec.contextWindow, maxTokens: spec.maxTokens,
-							};
-						})),
-					};
-					writeFileSync(modelsJsonPath, JSON.stringify(modelsConfig, null, 2), "utf-8");
-				}
-
-				const masked = key.substring(0, 6) + "..." + key.substring(key.length - 4);
-				ctx.ui.notify(`✅ **${info.name}** API key saved: ${masked}\n\n📁 Saved to \`~/.phi/agent/models.json\` (persistent)\n⚠️ **Restart phi** for the new models to load.`, "info");
-				return;
-			}
-
-			ctx.ui.notify("Unknown action. Use: /api-key set|list|providers|help", "warning");
-		},
-	});
 }

package/extensions/phi/orchestrator.ts

@@ -477,7 +477,7 @@ 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(`📋 Executing project with agent workflow...`, "info");
+			ctx.ui.notify(`📋 Launching orchestrator...`, "info");
 
 			// Build a single comprehensive prompt with all agent phases
 			const prompt = `# Project: ${description}
@@ -505,7 +505,8 @@ Check code quality. Fix any issues. Ensure everything is polished.
 - Announce each phase as you start it (e.g. "## Phase 1 — Exploring...")
 - Do NOT stop after planning — implement everything`;
 
-			ctx.ui.pasteToEditor(prompt);
+			// Send after handler returns (agent goes idle after command completes)
+			setTimeout(() => pi.sendUserMessage(prompt), 200);
 		},
 	});
 

package/package.json

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