@phi-code-admin/phi-code 0.65.0 → 0.66.1

package/extensions/phi/init.ts

@@ -464,76 +464,107 @@ _Edit this file to customize Phi Code's behavior for your project._
 
 				// No warning needed — the wizard itself handles configuration
 
-				// Always offer to add a provider via select menu
-				const providerOptions = [
-					"Skip (continue with current providers)",
-					...providers.map(p => {
-						const status = p.available ? "✅" : "⬜";
-						const tag = p.local ? " (local)" : "";
-						return `${status} ${p.name}${tag}`;
-					}),
-				];
-				const addProvider = await ctx.ui.select("Add or change a provider?", providerOptions);
-
-				const choiceIdx = providerOptions.indexOf(addProvider ?? "");
-				if (choiceIdx > 0) { // 0 = Skip
+				// Provider configuration loop — add as many providers as needed
+				let addingProviders = true;
+				while (addingProviders) {
+					const providerOptions = [
+						"Done — continue with current providers",
+						...providers.map(p => {
+							const status = p.available ? "✅" : "⬜";
+							const tag = p.local ? " (local)" : "";
+							const modelCount = p.available ? ` (${p.models.length} models)` : "";
+							return `${status} ${p.name}${tag}${modelCount}`;
+						}),
+					];
+					const addProvider = await ctx.ui.select("Configure a provider (add multiple!):", providerOptions);
+
+					const choiceIdx = providerOptions.indexOf(addProvider ?? "");
+					if (choiceIdx <= 0) { // 0 = Done, or cancelled
+						addingProviders = false;
+						break;
+					}
+
 					const chosen = providers[choiceIdx - 1];
 
 					if (chosen.local) {
 						const port = chosen.name === "Ollama" ? 11434 : 1234;
 						if (!chosen.available) {
 							ctx.ui.notify(`\n💡 **${chosen.name}** — make sure it's running on port ${port}.`, "info");
-							ctx.ui.notify("Then restart phi and run `/phi-init` again.", "info");
-							return;
+							ctx.ui.notify("Then restart phi and run `/phi-init` again.\n", "info");
+						} else {
+							ctx.ui.notify(`\n✅ **${chosen.name}** is running with ${chosen.models.length} model(s).\n`, "info");
 						}
-						ctx.ui.notify(`\n✅ **${chosen.name}** is running with ${chosen.models.length} model(s).`, "info");
 					} else {
-						// Cloud provider — ask for API key
-						ctx.ui.notify(`\n🔑 **${chosen.name}**`, "info");
-
-						const apiKey = await ctx.ui.input(
-							`Enter your ${chosen.name} API key`,
-							"Paste your key here"
+						// Cloud provider — choose auth method
+						const supportsOAuth = ["openai", "anthropic", "google"].includes(
+							chosen.name.toLowerCase().split(" ")[0]
 						);
 
-						if (!apiKey || apiKey.trim().length < 5) {
-							ctx.ui.notify("❌ Invalid API key. Skipped.", "error");
-						} else {
-							// Save to models.json
-							let modelsConfig: any = { providers: {} };
-							try {
-								const existing = await readFile(modelsJsonPath, "utf-8");
-								modelsConfig = JSON.parse(existing);
-							} catch { /* new file */ }
-
-							const providerId = chosen.name.toLowerCase().replace(/\s+/g, "-");
-							modelsConfig.providers[providerId] = {
-								baseUrl: chosen.baseUrl,
-								api: "openai-completions",
-								apiKey: apiKey.trim(),
-								models: await Promise.all(chosen.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,
-									};
-								})),
-							};
-
-							await writeFile(modelsJsonPath, JSON.stringify(modelsConfig, null, 2), "utf-8");
-							process.env[chosen.envVar] = apiKey.trim();
-							chosen.available = true;
+						let authMethod = "api-key";
+						if (supportsOAuth) {
+							const authChoice = await ctx.ui.select(
+								`How to authenticate with ${chosen.name}?`,
+								["API Key (paste your key)", "OAuth (browser login via /login)"]
+							);
+							if (authChoice?.includes("OAuth")) {
+								authMethod = "oauth";
+							}
+						}
 
-							const masked = apiKey.trim().substring(0, 6) + "..." + apiKey.trim().slice(-4);
-							ctx.ui.notify(`✅ **${chosen.name}** saved (${masked})`, "info");
-							ctx.ui.notify(`   ${chosen.models.length} models configured in \`models.json\``, "info");
+						if (authMethod === "oauth") {
+							ctx.ui.notify(`\n🔐 **${chosen.name}** — Use \`/login\` after setup to authenticate via OAuth.`, "info");
+							ctx.ui.notify("OAuth opens a browser window for secure login.\n", "info");
+							// Mark as available for model assignment (auth will be done via /login)
+							chosen.available = true;
+						} else {
+							// API Key method
+							ctx.ui.notify(`\n🔑 **${chosen.name}**`, "info");
+
+							const apiKey = await ctx.ui.input(
+								`Enter your ${chosen.name} API key`,
+								"Paste your key here"
+							);
+
+							if (!apiKey || apiKey.trim().length < 5) {
+								ctx.ui.notify("❌ Invalid API key. Skipped.\n", "error");
+							} else {
+								// Save to models.json (merges with existing)
+								let modelsConfig: any = { providers: {} };
+								try {
+									const existing = await readFile(modelsJsonPath, "utf-8");
+									modelsConfig = JSON.parse(existing);
+									if (!modelsConfig.providers) modelsConfig.providers = {};
+								} catch { /* new file */ }
+
+								const providerId = chosen.name.toLowerCase().replace(/\s+/g, "-");
+								modelsConfig.providers[providerId] = {
+									baseUrl: chosen.baseUrl,
+									api: "openai-completions",
+									apiKey: apiKey.trim(),
+									models: await Promise.all(chosen.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,
+										};
+									})),
+								};
+
+								await writeFile(modelsJsonPath, JSON.stringify(modelsConfig, null, 2), "utf-8");
+								process.env[chosen.envVar] = apiKey.trim();
+								chosen.available = true;
+
+								const masked = apiKey.trim().substring(0, 6) + "..." + apiKey.trim().slice(-4);
+								ctx.ui.notify(`✅ **${chosen.name}** configured (${masked})`, "info");
+								ctx.ui.notify(`   ${chosen.models.length} models added to \`models.json\`\n`, "info");
+							}
 						}
 					}
-				}
+				} // end while (addingProviders)
 
 				// Re-check available after potential additions
 				available = providers.filter(p => p.available);

package/extensions/phi/orchestrator.ts

@@ -503,6 +503,7 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 
 	/**
 	 * Load routing config and build phase queue with model assignments + agent definitions.
+	 * Each phase now reads outputs from previous phases and writes structured outputs.
 	 */
 	function buildPhases(description: string): OrchestratorPhase[] {
 		const routingPath = join(homedir(), ".phi", "agent", "routing.json");
@@ -525,31 +526,195 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		const test = getModel("test");
 		const review = getModel("review");
 
+		const ts = timestamp();
+
 		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.`,
+				instruction: `You are the EXPLORE agent. Analyze the project requirements and existing codebase.
+
+**Project Request:** ${description}
+
+**Your tasks:**
+1. List all existing files and read key ones
+2. Identify tech stack, patterns, and constraints
+3. Create a STRUCTURED PROJECT BRIEF in \`.phi/plans/brief-${ts}.md\`:
+   - Context: what exists now
+   - Objective: what needs to be built
+   - Requirements: specific features needed
+   - Tech decisions: frameworks, patterns to use
+   - Constraints: what to NOT break
+
+**Step 4:** Write your findings to \`.phi/plans/explore-${ts}.md\`
+
+**Format for the project brief:**
+\`\`\`markdown
+## Project Brief
+
+### Context
+[Analyze what the user is asking for]
+
+### Objective
+[Clear, specific goal]
+
+### Requirements
+[Bullet list of what must be built]
+
+### Tech Decisions
+[Frameworks, patterns, architecture choices]
+
+### Constraints
+- Production-quality code, no placeholders
+- Every function fully implemented
+- Follow existing patterns if codebase exists
+- [Any other specific constraints]
+\`\`\``,
 			},
 			{
 				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.`,
+				instruction: `You are the PLAN agent. Design the architecture and create a detailed task list.
+
+**Project Request:** ${description}
+
+**Step 1:** Read \`.phi/plans/brief-*.md\` (created by the explore phase)
+**Step 2:** Read \`.phi/plans/explore-*.md\` to understand the codebase analysis
+**Step 3:** Design the architecture based on findings
+**Step 4:** Create a DETAILED TODO LIST in \`.phi/plans/todo-${ts}.md\`:
+   For each task:
+   - Task number and title
+   - Agent assignment (code/test)
+   - Files to create/modify
+   - Specific implementation details
+   - Dependencies on other tasks
+
+**Format for the todo list:**
+\`\`\`markdown
+# TODO: Project Tasks
+
+## Task 1: [Task Title] [agent-type]
+- [ ] Specific implementation details
+- [ ] Files to create: path/to/file.ext
+- [ ] Expected behavior
+- Dependencies: None
+
+## Task 2: [Task Title] [agent-type]
+- [ ] Implementation details
+- Dependencies: Task 1
+\`\`\``,
 			},
 			{
 				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`,
+				instruction: `You are the CODE agent. Implement the complete project.
+
+**Project Request:** ${description}
+
+**Step 1:** Read \`.phi/plans/brief-*.md\` for project context
+**Step 2:** Read \`.phi/plans/todo-*.md\` to get your task list
+**Step 3:** Implement EVERY task from the todo list, in order
+**Step 4:** Write a progress report to \`.phi/plans/progress-${ts}.md\`
+
+**Rules:**
+- Create every file listed in the plan
+- No placeholders, no TODOs, no stubs
+- Every function must be fully implemented
+- Follow the architecture from the plan
+- Check off tasks in your progress report as you complete them
+
+**Progress report format:**
+\`\`\`markdown
+# Progress Report
+
+## Completed Tasks
+- [x] Task 1: Description - DONE
+- [x] Task 2: Description - DONE
+
+## Files Created
+- path/to/file1.ext - Purpose
+- path/to/file2.ext - Purpose
+
+## Implementation Notes
+[Any important decisions or changes made]
+\`\`\``,
 			},
 			{
 				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.`,
+				instruction: `You are the TEST agent. Verify the implementation.
+
+**Project Request:** ${description}
+
+**Step 1:** Read \`.phi/plans/todo-*.md\` to know what was planned
+**Step 2:** Read \`.phi/plans/progress-*.md\` to see what was done
+**Step 3:** Run the code, check for errors, test key features
+**Step 4:** Fix any errors you find
+**Step 5:** Write test results to \`.phi/plans/test-${ts}.md\`
+
+**Test report format:**
+\`\`\`markdown
+# Test Report
+
+## Tests Executed
+- [ ] Feature 1: Description - PASS/FAIL
+- [ ] Feature 2: Description - PASS/FAIL
+
+## Errors Found & Fixed
+- Error: Description
+  - Fix: What was done
+
+## Manual Testing
+- Tested: What was manually verified
+- Result: Pass/Fail with details
+
+## Final Status
+✅ All tests pass / ❌ Issues remain
+\`\`\``,
 			},
 			{
 				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.`,
+				instruction: `You are the REVIEW agent. Final quality review.
+
+**Project Request:** ${description}
+
+**Step 1:** Read all \`.phi/plans/*.md\` files
+**Step 2:** Review code quality, security, performance
+**Step 3:** Fix any issues found
+**Step 4:** Write final report to \`.phi/plans/review-${ts}.md\`
+
+**Review checklist:**
+- Code quality: naming, structure, readability
+- Security: input validation, error handling
+- Performance: efficiency, resource usage
+- Documentation: comments, README if needed
+- Completeness: all requirements met
+
+**Final report format:**
+\`\`\`markdown
+# Final Review
+
+## Code Quality ✅/❌
+- Structure: Good/Needs work
+- Naming: Clear/Unclear
+- Comments: Adequate/Missing
+
+## Security ✅/❌
+- Input validation: Present/Missing
+- Error handling: Robust/Weak
+
+## Performance ✅/❌
+- Efficiency: Good/Could improve
+- Resource usage: Optimal/Excessive
+
+## Completeness ✅/❌
+- All requirements met: Yes/No
+- All files created: Yes/No
+
+## Final Verdict
+✅ Project ready for production / ❌ Issues need resolution
+\`\`\``,
 			},
 		];
 	}

package/package.json

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