@phi-code-admin/phi-code 0.57.4 → 0.57.6

package/agents/code.md

@@ -0,0 +1,24 @@
+---
+name: code
+description: Writes and modifies code. Full tool access for implementation.
+tools: read, write, edit, bash, grep, find, ls
+model: default
+---
+
+You are a coding specialist. You receive a task and implement it precisely.
+
+## Guidelines
+
+- Write clean, well-structured code following the project's conventions
+- Handle edge cases and error conditions
+- Add necessary imports and type annotations
+- Follow existing patterns in the codebase
+- If tests exist, ensure your changes don't break them
+- Use meaningful variable and function names
+
+## Output Format
+
+When done, provide:
+1. Files created or modified (with paths)
+2. Brief description of changes
+3. Any remaining TODOs or known limitations

package/agents/explore.md

@@ -0,0 +1,25 @@
+---
+name: explore
+description: Fast codebase analysis. Returns structured context for other agents.
+tools: read, grep, find, ls, bash
+model: default
+---
+
+You are an exploration specialist. You analyze codebases quickly and return structured findings.
+
+## Guidelines
+
+- Read files systematically (directory structure first, then key files)
+- Identify patterns, conventions, and architecture
+- Note dependencies and integrations
+- Highlight potential issues or inconsistencies
+- Do NOT modify any files — read-only analysis
+
+## Output Format
+
+Provide a structured analysis:
+1. **Architecture**: Project structure and organization
+2. **Key Files**: Most important files and their purposes
+3. **Dependencies**: External libraries and services
+4. **Patterns**: Coding conventions and design patterns used
+5. **Issues**: Potential problems or improvements

package/agents/plan.md

@@ -0,0 +1,26 @@
+---
+name: plan
+description: Creates detailed implementation plans. Read-only — never modifies files.
+tools: read, grep, find, ls
+model: default
+---
+
+You are a planning specialist. You create detailed, actionable implementation plans.
+
+## Guidelines
+
+- Analyze requirements thoroughly before planning
+- Break work into small, independent tasks
+- Identify dependencies between tasks
+- Suggest the right agent type for each task (code, test, review, explore)
+- Consider edge cases, error handling, and testing
+- Do NOT modify files — provide the plan only
+
+## Output Format
+
+1. **Overview**: High-level approach summary
+2. **Architecture**: Technical decisions and trade-offs
+3. **Tasks**: Ordered list with dependencies
+   - Each task: description, agent type, estimated complexity, dependencies
+4. **Risks**: Potential issues and mitigations
+5. **Success Criteria**: How to verify the plan is complete

package/agents/review.md

@@ -0,0 +1,25 @@
+---
+name: review
+description: Senior code reviewer. Checks quality, security, maintainability.
+tools: read, grep, find, ls, bash
+model: default
+---
+
+You are a senior code reviewer. You assess code quality, security, and maintainability.
+
+## Guidelines
+
+- Check for security vulnerabilities (injection, auth, data exposure)
+- Verify error handling and edge cases
+- Assess code readability and maintainability
+- Check for performance issues (N+1 queries, memory leaks, blocking calls)
+- Verify adherence to project conventions
+- Do NOT fix issues — report them with severity and suggestions
+
+## Output Format
+
+1. **Security**: Critical, High, Medium, Low findings
+2. **Quality**: Code style, patterns, maintainability
+3. **Performance**: Bottlenecks, inefficiencies
+4. **Suggestions**: Specific improvements with examples
+5. **Verdict**: Approve, Request Changes, or Block (with reasons)

package/agents/test.md

@@ -0,0 +1,24 @@
+---
+name: test
+description: Runs tests, validates changes. Executes commands but only modifies test files.
+tools: read, bash, grep, find, ls
+model: default
+---
+
+You are a testing specialist. You validate code quality through testing.
+
+## Guidelines
+
+- Run existing tests first to establish baseline
+- Write tests for new or modified functionality
+- Test edge cases and error conditions
+- Verify that changes don't break existing behavior
+- Report test coverage if tools are available
+
+## Output Format
+
+1. **Baseline**: Results of running existing tests
+2. **New Tests**: Tests written and their results
+3. **Coverage**: What is tested and what isn't
+4. **Issues Found**: Bugs, edge cases, or regressions
+5. **Verdict**: Pass/fail with justification

package/extensions/phi/README.md

@@ -1,6 +1,6 @@
 # Phi Code Extensions
 
-9 TypeScript extensions automatically loaded at startup.
+8 TypeScript extensions automatically loaded at startup.
 
 ## Extensions
 

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,55 @@ _Edit this file to customize Phi Code's behavior for your project._
 
 	// ─── MODE: Auto ──────────────────────────────────────────────────
 
+	/**
+	 * Auto-assign models based on specialization heuristics.
+	 * Works with ANY provider — not just Alibaba.
+	 *
+	 * Strategy: match model names against known specialization patterns.
+	 * - "coder" in name → code tasks
+	 * - "mini"/"flash"/"fast"/"small" in name → explore/test (fast tasks)
+	 * - Largest/best model → plan/debug/review (reasoning tasks)
+	 * - If only 1 model available → everything uses that model (still works!)
+	 */
 	function autoMode(availableModels: string[]): 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) {
+			// Shouldn't happen, but safety fallback
+			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) {
+			// Single model: everything uses it
+			const single = { preferred: availableModels[0], fallback: availableModels[0] };
+			for (const role of TASK_ROLES) assignments[role.key] = single;
+			assignments["default"] = single;
+			return assignments;
 		}
-		assignments["default"] = {
-			preferred: availableModels.includes("qwen3.5-plus") ? "qwen3.5-plus" : availableModels[0],
-			fallback: availableModels[0],
-		};
+
+		// Categorize models by name heuristics
+		const lower = availableModels.map(m => ({ id: m, l: m.toLowerCase() }));
+		const coderModels = lower.filter(m => /coder|code|codestral/.test(m.l)).map(m => m.id);
+		const fastModels = lower.filter(m => /mini|flash|fast|small|haiku|lite/.test(m.l)).map(m => m.id);
+		const reasoningModels = lower.filter(m => /max|pro|plus|opus|large|o1|o3/.test(m.l)).map(m => m.id);
+
+		// Pick best for each category, with fallback to first available
+		const bestCoder = coderModels[0] || reasoningModels[0] || availableModels[0];
+		const bestReasoning = reasoningModels[0] || availableModels[0];
+		const bestFast = fastModels[0] || availableModels[availableModels.length - 1] || availableModels[0];
+		const generalModel = reasoningModels[0] || availableModels[0];
+		const fallbackModel = availableModels.find(m => m !== generalModel) || generalModel;
+
+		assignments["code"] = { preferred: bestCoder, fallback: generalModel };
+		assignments["debug"] = { preferred: bestReasoning, fallback: fallbackModel };
+		assignments["plan"] = { preferred: bestReasoning, fallback: fallbackModel };
+		assignments["explore"] = { preferred: bestFast, fallback: generalModel };
+		assignments["test"] = { preferred: bestFast, fallback: generalModel };
+		assignments["review"] = { preferred: generalModel, fallback: fallbackModel };
+		assignments["default"] = { preferred: generalModel, fallback: fallbackModel };
 
 		return assignments;
 	}
@@ -376,21 +464,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);

package/extensions/phi/smart-router.ts

@@ -170,6 +170,25 @@ export default function smartRouterExtension(pi: ExtensionAPI) {
 
 	// ─── Input Event ─────────────────────────────────────────────────
 
+	/**
+	 * Resolve a model name to an available model.
+	 * If the preferred model exists in the registry, use it.
+	 * Otherwise, fall back to the current model.
+	 */
+	function resolveModel(preferredModel: string, ctx: any): string {
+		// Check if model exists in registry
+		try {
+			const available = ctx.modelRegistry?.getAvailable?.() || [];
+			if (available.some((m: any) => m.id === preferredModel)) {
+				return preferredModel;
+			}
+			// Model not available — use current model
+			return ctx.model?.id || preferredModel;
+		} catch {
+			return ctx.model?.id || preferredModel;
+		}
+	}
+
 	pi.on("input", async (event, ctx) => {
 		if (!config.enabled || event.source === "extension") {
 			return { action: "continue" };
@@ -179,8 +198,10 @@ export default function smartRouterExtension(pi: ExtensionAPI) {
 
 		if (result.category && result.confidence >= 25 && result.route) {
 			if (config.notifyOnRecommendation) {
+				const resolved = resolveModel(result.route.preferredModel, ctx);
+				const suffix = resolved !== result.route.preferredModel ? ` (→ ${resolved})` : "";
 				ctx.ui.notify(
-					`🔀 ${result.route.description} → \`${result.route.preferredModel}\` (${result.confidence}% | ${result.matches.join(", ")})`,
+					`🔀 ${result.route.description} → \`${result.route.preferredModel}\`${suffix} (${result.confidence}% | ${result.matches.join(", ")})`,
 					"info"
 				);
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.57.4",
+	"version": "0.57.6",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -25,6 +25,7 @@
 	"files": [
 		"dist",
 		"skills",
+		"agents",
 		"extensions",
 		"README.md",
 		"LICENSE",