@phi-code-admin/phi-code 0.57.5 → 0.57.7

package/extensions/phi/init.ts

@@ -23,6 +23,7 @@ interface DetectedProvider {
 	baseUrl: string;
 	models: string[];
 	available: boolean;
+	local?: boolean; // True for Ollama/LM Studio (models discovered at runtime)
 }
 
 interface RoutingConfig {
@@ -82,15 +83,65 @@ function detectProviders(): DetectedProvider[] {
 			models: ["llama-3.3-70b-versatile", "mixtral-8x7b-32768"],
 			available: false,
 		},
+		{
+			name: "Ollama",
+			envVar: "OLLAMA",
+			baseUrl: "http://localhost:11434/v1",
+			models: [], // Discovered at runtime
+			available: false,
+			local: true,
+		},
+		{
+			name: "LM Studio",
+			envVar: "LM_STUDIO",
+			baseUrl: "http://localhost:1234/v1",
+			models: [], // Discovered at runtime
+			available: false,
+			local: true,
+		},
 	];
 
 	for (const p of providers) {
-		p.available = !!process.env[p.envVar];
+		if (p.local) {
+			// Local providers: check if server is running by probing the URL
+			p.available = false; // Will be checked async in detectLocalProviders()
+		} else {
+			p.available = !!process.env[p.envVar];
+		}
 	}
 
 	return providers;
 }
 
+/**
+ * Detect local providers (Ollama, LM Studio) by probing their endpoints
+ * and fetching available models dynamically.
+ */
+async function detectLocalProviders(providers: DetectedProvider[]): Promise<void> {
+	for (const p of providers) {
+		if (!p.local) continue;
+		try {
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), 3000);
+			const res = await fetch(`${p.baseUrl}/models`, {
+				signal: controller.signal,
+				headers: { Authorization: `Bearer ${p.envVar === "OLLAMA" ? "ollama" : "lm-studio"}` },
+			});
+			clearTimeout(timeout);
+			if (res.ok) {
+				const data = await res.json() as any;
+				const models = (data.data || []).map((m: any) => m.id).filter(Boolean);
+				if (models.length > 0) {
+					p.models = models;
+					p.available = true;
+				}
+			}
+		} catch {
+			// Server not running — that's fine
+		}
+	}
+}
+
 function getAllAvailableModels(providers: DetectedProvider[]): string[] {
 	return providers.filter(p => p.available).flatMap(p => p.models);
 }
@@ -210,18 +261,193 @@ _Edit this file to customize Phi Code's behavior for your project._
 
 	// ─── MODE: Auto ──────────────────────────────────────────────────
 
-	function autoMode(availableModels: string[]): Record<string, { preferred: string; fallback: string }> {
+	// ─── 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.
+	 */
+	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 }> = {};
 
-		for (const role of TASK_ROLES) {
-			const preferred = availableModels.includes(role.defaultModel) ? role.defaultModel : availableModels[0];
-			const fallbackModel = availableModels.includes("qwen3.5-plus") ? "qwen3.5-plus" : availableModels[0];
-			assignments[role.key] = { preferred, fallback: fallbackModel };
+		if (availableModels.length === 0) {
+			const fb = { preferred: "qwen3.5-plus", fallback: "qwen3.5-plus" };
+			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");
+			}
 		}
-		assignments["default"] = {
-			preferred: availableModels.includes("qwen3.5-plus") ? "qwen3.5-plus" : availableModels[0],
-			fallback: availableModels[0],
-		};
 
 		return assignments;
 	}
@@ -259,7 +485,7 @@ _Edit this file to customize Phi Code's behavior for your project._
 		ctx.ui.notify("Run: `/benchmark all` then `/phi-init` again with mode=benchmark to use results.\n", "info");
 
 		// Fall back to auto for now
-		return autoMode(availableModels);
+		return autoMode(availableModels, ctx);
 	}
 
 	function assignFromBenchmark(results: any[], availableModels: string[]): Record<string, { preferred: string; fallback: string }> {
@@ -376,21 +602,32 @@ _Edit this file to customize Phi Code's behavior for your project._
 				ctx.ui.notify("║     Φ  Phi Code Setup Wizard        ║", "info");
 				ctx.ui.notify("╚══════════════════════════════════════╝\n", "info");
 
-				// 1. Detect API keys
-				ctx.ui.notify("🔍 Detecting API keys...", "info");
+				// 1. Detect API keys and local providers
+				ctx.ui.notify("🔍 Detecting providers...", "info");
 				const providers = detectProviders();
+
+				// Probe local providers (Ollama, LM Studio)
+				ctx.ui.notify("🔍 Probing local model servers...", "info");
+				await detectLocalProviders(providers);
+
 				const available = providers.filter(p => p.available);
 
 				if (available.length === 0) {
-					ctx.ui.notify("❌ No API keys found. Set at least one:\n" +
-						providers.map(p => `  export ${p.envVar}="your-key"  # ${p.name}`).join("\n") +
-						"\n\n💡 Free option: Get an Alibaba Coding Plan key at https://help.aliyun.com/zh/model-studio/", "error");
+					const cloudProviders = providers.filter(p => !p.local);
+					ctx.ui.notify("❌ No providers found. Options:\n\n" +
+						"**Cloud providers** (set API key):\n" +
+						cloudProviders.map(p => `  export ${p.envVar}="your-key"  # ${p.name}`).join("\n") +
+						"\n\n**Local providers** (start the server):\n" +
+						"  • Ollama: `ollama serve` (default port 11434)\n" +
+						"  • LM Studio: Start server in app (default port 1234)\n" +
+						"\n💡 Free options: Alibaba Coding Plan (cloud, $0) or Ollama (local, free)", "error");
 					return;
 				}
 
 				ctx.ui.notify(`✅ Found ${available.length} provider(s):`, "info");
 				for (const p of available) {
-					ctx.ui.notify(`  • ${p.name} — ${p.models.length} models`, "info");
+					const tag = p.local ? " (local)" : "";
+					ctx.ui.notify(`  • ${p.name}${tag} — ${p.models.length} model(s)${p.local ? ": " + p.models.join(", ") : ""}`, "info");
 				}
 
 				const allModels = getAllAvailableModels(providers);
@@ -418,8 +655,7 @@ _Edit this file to customize Phi Code's behavior for your project._
 				let assignments: Record<string, { preferred: string; fallback: string }>;
 
 				if (mode === "auto") {
-					assignments = autoMode(allModels);
-					ctx.ui.notify("⚡ Auto-assigned models based on public rankings and model specializations.", "info");
+					assignments = await autoMode(allModels, ctx);
 				} else if (mode === "benchmark") {
 					assignments = await benchmarkMode(allModels, ctx);
 				} else {

package/package.json

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