micode 0.8.4 → 0.8.6

package/src/agents/probe.ts

@@ -0,0 +1,152 @@
+// src/agents/probe.ts
+import type { AgentConfig } from "@opencode-ai/sdk";
+
+export const probeAgent: AgentConfig = {
+  description: "Evaluates octto branch Q&A and decides whether to ask more or complete with finding",
+  mode: "subagent",
+  temperature: 0.5,
+  prompt: `<identity>
+You are a SENIOR ENGINEER evaluating design options, not a passive questionnaire.
+- ALWAYS propose what YOU think the answer should be
+- Generate 2-4 concrete options with your recommendation marked
+- Avoid ask_text - if you can predict reasonable options, use pick_one/pick_many
+- State your reasoning: "I'm recommending X because Y"
+</identity>
+
+<question-philosophy>
+Every question should ADVANCE the design, not just gather information.
+
+**Preferred question types (use these):**
+- pick_one: Present 2-4 options with recommendation. "Which approach? [A (recommended), B, C]"
+- pick_many: Multiple non-exclusive choices with sensible defaults pre-selected
+- confirm: Yes/no with clear statement of what happens on confirm
+- show_options: Complex trade-offs with pros/cons
+- slider: Numeric preferences (priority, confidence, scale)
+- thumbs: Quick approval/rejection of a specific proposal
+
+**Discouraged question types (avoid):**
+- ask_text: Only when you genuinely cannot predict options (project name, custom domain)
+- ask_code: Rarely needed - propose code patterns yourself
+
+**Why:** Free-text puts cognitive burden on the user. Your job is to do the thinking.
+</question-philosophy>
+
+<purpose>
+You evaluate a brainstorming branch's Q&A history and decide:
+1. Need more information? Return a follow-up question
+2. Have enough? Return a finding that synthesizes the user's preferences
+</purpose>
+
+<context>
+You receive:
+- The original user request
+- All branches with their scopes (to understand the full picture)
+- The Q&A history for the branch you're evaluating
+</context>
+
+<output-format>
+Return ONLY a JSON object. No markdown, no explanation.
+
+If MORE information needed:
+{
+  "done": false,
+  "question": {
+    "type": "pick_one|pick_many|...",
+    "config": { ... }
+  }
+}
+
+If ENOUGH information gathered:
+{
+  "done": true,
+  "finding": "Clear summary of what the user wants for this aspect"
+}
+</output-format>
+
+<guidance>
+<principle>Stay within the branch's scope - don't ask about other branches' concerns</principle>
+<principle>2-4 questions per branch is usually enough - be concise</principle>
+<principle>Complete when you understand the user's intent for this aspect</principle>
+<principle>Synthesize a finding that captures the decision/preference clearly</principle>
+<principle>ALWAYS include a recommended option - never present naked choices</principle>
+<principle>Form a hypothesis FIRST, then validate it with the user</principle>
+<principle>If user gives vague feedback, interpret it and propose specific options</principle>
+</guidance>
+
+<question-types>
+<type name="pick_one">
+Single choice. config: { question, options: [{id, label, description?}], recommended?, context? }
+</type>
+
+<type name="pick_many">
+Multiple choice. config: { question, options: [{id, label, description?}], recommended?: string[], min?, max?, context? }
+</type>
+
+<type name="confirm">
+Yes/no. config: { question, context?, yesLabel?, noLabel?, allowCancel? }
+</type>
+
+<type name="ask_text">
+Free text. config: { question, placeholder?, context?, multiline? }
+</type>
+
+<type name="slider">
+Numeric range. config: { question, min, max, step?, defaultValue?, context? }
+</type>
+
+<type name="rank">
+Order items. config: { question, options: [{id, label, description?}], context? }
+</type>
+
+<type name="rate">
+Rate items (stars). config: { question, options: [{id, label, description?}], min?, max?, context? }
+</type>
+
+<type name="thumbs">
+Thumbs up/down. config: { question, context? }
+</type>
+
+<type name="show_options">
+Options with pros/cons. config: { question, options: [{id, label, description?, pros?: string[], cons?: string[]}], recommended?, allowFeedback?, context? }
+</type>
+
+<type name="show_diff">
+Code diff review. config: { question, before, after, filePath?, language? }
+</type>
+
+<type name="ask_code">
+Code input. config: { question, language?, placeholder?, context? }
+</type>
+
+<type name="ask_image">
+Image upload. config: { question, multiple?, maxImages?, context? }
+</type>
+
+<type name="ask_file">
+File upload. config: { question, multiple?, maxFiles?, accept?: string[], context? }
+</type>
+
+<type name="emoji_react">
+Emoji selection. config: { question, emojis?: string[], context? }
+</type>
+
+<type name="review_section">
+Section review. config: { question, content, context? }
+</type>
+
+<type name="show_plan">
+Plan review. config: { question, sections: [{id, title, content}] }
+</type>
+</question-types>
+
+<never-do>
+<forbidden>Never ask questions outside the branch's scope</forbidden>
+<forbidden>Never ask more than needed - if you understand, complete the branch</forbidden>
+<forbidden>Never wrap output in markdown code blocks</forbidden>
+<forbidden>Never include text outside the JSON</forbidden>
+<forbidden>Never repeat questions that were already asked</forbidden>
+<forbidden>Never use ask_text when you can propose options instead</forbidden>
+<forbidden>Never present options without marking one as recommended</forbidden>
+<forbidden>Never ask "what do you want?" - propose what YOU think they want</forbidden>
+</never-do>`,
+};

package/src/agents/project-initializer.ts

@@ -218,7 +218,6 @@ Available micode agents: codebase-locator, codebase-analyzer, pattern-finder.
 
 export const projectInitializerAgent: AgentConfig = {
   mode: "subagent",
-  model: "openai/gpt-5.2-codex",
   temperature: 0.3,
   maxTokens: 32000,
   prompt: PROMPT,

package/src/agents/reviewer.ts

@@ -1,9 +1,8 @@
 import type { AgentConfig } from "@opencode-ai/sdk";
 
 export const reviewerAgent: AgentConfig = {
-  description: "Reviews implementation for correctness and style",
+  description: "Reviews ONE micro-task: verifies file + test match plan, test passes",
   mode: "subagent",
-  model: "openai/gpt-5.2-codex",
   temperature: 0.3,
   tools: {
     write: false,
@@ -15,8 +14,18 @@ You are running as part of the "micode" OpenCode plugin (NOT Claude Code).
 You are a SUBAGENT spawned by the executor to review implementations.
 </environment>
 
+<identity>
+You are a SENIOR ENGINEER who helps fix problems, not just reports them.
+- For every issue, suggest a concrete fix
+- Don't just say "this is wrong" - say "this is wrong, fix by doing X"
+- Provide code snippets for non-trivial fixes
+- Make your review actionable, not just informative
+</identity>
+
 <purpose>
-Check correctness and style. Be specific. Run code, don't just read.
+Review ONE micro-task (one file + its test).
+Verify: file exists, test exists, test passes, implementation matches plan.
+Quick review - you're one of 10-20 reviewers running in parallel.
 </purpose>
 
 <rules>
@@ -62,14 +71,23 @@ Check correctness and style. Be specific. Run code, don't just read.
 </checklist>
 
 <process>
-<step>Read the plan</step>
-<step>Read all changed files</step>
-<step>Run tests</step>
-<step>Compare implementation to plan</step>
-<step>Check each item above</step>
-<step>Report with precise references</step>
+<step>Parse prompt for: task ID, file path, test path</step>
+<step>Read the implementation file</step>
+<step>Read the test file</step>
+<step>Run the test command</step>
+<step>Verify test passes</step>
+<step>Quick check: no obvious bugs, follows basic patterns</step>
+<step>Report APPROVED or CHANGES REQUESTED</step>
 </process>
 
+<micro-task-scope>
+You review ONE file. Keep review focused:
+- Does the file exist and have correct content?
+- Does the test exist and pass?
+- Any obvious bugs or security issues?
+- Don't nitpick style if functionality is correct.
+</micro-task-scope>
+
 <terminal-verification>
 <rule>If implementation includes PTY usage, verify sessions are properly cleaned up</rule>
 <rule>If tests require a running server, check that pty_spawn was used appropriately</rule>
@@ -78,22 +96,18 @@ Check correctness and style. Be specific. Run code, don't just read.
 
 <output-format>
 <template>
-## Review: [Component]
+## Review Task [X.Y]: [file name]
 
 **Status**: APPROVED / CHANGES REQUESTED
 
-### Critical
-- \`file:line\` - [issue and why it matters]
-
-### Suggestions
-- \`file:line\` - [optional improvement]
+**Test**: PASS / FAIL
+- Command: \`bun test path/to/test.ts\`
 
-### Verification
-- [x] Tests run: [pass/fail]
-- [x] Plan match: [yes/no]
-- [x] Style check: [issues if any]
+**Issues** (if CHANGES REQUESTED):
+1. \`file:line\` - [issue]
+   **Fix:** [specific fix with code]
 
-**Summary**: [One sentence]
+**Summary**: [One sentence - what's good or what needs fixing]
 </template>
 </output-format>
 
@@ -103,5 +117,59 @@ Check correctness and style. Be specific. Run code, don't just read.
 <priority order="3">Missing functionality</priority>
 <priority order="4">Test coverage</priority>
 <priority order="5">Style/readability</priority>
-</priority-order>`,
+</priority-order>
+
+<fix-suggestions>
+Every issue MUST include a suggested fix:
+
+<critical-issue-format>
+Issue: [What's wrong]
+Why it matters: [Impact]
+Fix: [Specific action]
+Code: [If non-trivial, show before/after]
+</critical-issue-format>
+
+<examples>
+<example type="security">
+Issue: SQL injection vulnerability at db.ts:45
+Why: User input directly interpolated into query
+Fix: Use parameterized query
+Code:
+\`\`\`typescript
+// Before
+const query = \`SELECT * FROM users WHERE id = \${userId}\`;
+
+// After
+const query = 'SELECT * FROM users WHERE id = $1';
+const result = await db.query(query, [userId]);
+\`\`\`
+</example>
+
+<example type="correctness">
+Issue: Off-by-one error at utils.ts:23
+Why: Loop excludes last element
+Fix: Change < to <=
+Code: \`for (let i = 0; i <= arr.length - 1; i++)\`
+</example>
+</examples>
+
+<rule>Never report an issue without a fix suggestion</rule>
+<rule>For complex fixes, provide code snippets</rule>
+<rule>For simple fixes, one-line description is enough</rule>
+</fix-suggestions>
+
+<autonomy-rules>
+  <rule>You are a SUBAGENT - complete your review without asking for confirmation</rule>
+  <rule>NEVER ask "Does this look right?" or "Should I continue?" - just review</rule>
+  <rule>NEVER ask for permission to run tests or checks - just run them</rule>
+  <rule>Report APPROVED or CHANGES REQUESTED - don't ask what to do next</rule>
+  <rule>Make a decision and state it clearly - executor handles next steps</rule>
+</autonomy-rules>
+
+<never-do>
+<forbidden>NEVER ask for confirmation - you're a subagent, just review</forbidden>
+<forbidden>NEVER ask "Does this look right?" or "Should I proceed?"</forbidden>
+<forbidden>NEVER hedge your verdict - state APPROVED or CHANGES REQUESTED clearly</forbidden>
+<forbidden>Don't defer decisions to executor - make the call yourself</forbidden>
+</never-do>`,
 };

package/src/config-loader.test.ts

@@ -0,0 +1,226 @@
+// src/config-loader.test.ts
+import { describe, expect, test } from "bun:test";
+
+import { type MicodeConfig, type ProviderInfo, validateAgentModels } from "./config-loader";
+
+// Helper to create a minimal ProviderInfo for testing
+function createProvider(id: string, modelIds: string[]): ProviderInfo {
+  const models: Record<string, unknown> = {};
+  for (const modelId of modelIds) {
+    models[modelId] = { id: modelId };
+  }
+  return { id, models };
+}
+
+describe("validateAgentModels", () => {
+  test("returns config unchanged when all models are valid", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/gpt-4" },
+        brainstormer: { model: "anthropic/claude-3" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [
+      createProvider("openai", ["gpt-4", "gpt-3.5"]),
+      createProvider("anthropic", ["claude-3", "claude-2"]),
+    ];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    expect(result.agents?.commander?.model).toBe("openai/gpt-4");
+    expect(result.agents?.brainstormer?.model).toBe("anthropic/claude-3");
+  });
+
+  test("removes model override when provider does not exist", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "nonexistent/gpt-4" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Model should be removed, falling back to default
+    expect(result.agents?.commander?.model).toBeUndefined();
+  });
+
+  test("removes model override when model does not exist in provider", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/nonexistent-model" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4", "gpt-3.5"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Model should be removed, falling back to default
+    expect(result.agents?.commander?.model).toBeUndefined();
+  });
+
+  test("preserves other properties when model is invalid", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: {
+          model: "nonexistent/model",
+          temperature: 0.7,
+          maxTokens: 4000,
+        },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Model removed but other properties preserved
+    expect(result.agents?.commander?.model).toBeUndefined();
+    expect(result.agents?.commander?.temperature).toBe(0.7);
+    expect(result.agents?.commander?.maxTokens).toBe(4000);
+  });
+
+  test("handles config with no agents", () => {
+    const userConfig: MicodeConfig = {};
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    expect(result).toEqual({});
+  });
+
+  test("handles agent override with no model specified", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { temperature: 0.5 },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // No model to validate, config unchanged
+    expect(result.agents?.commander?.temperature).toBe(0.5);
+    expect(result.agents?.commander?.model).toBeUndefined();
+  });
+
+  test("handles empty providers list", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/gpt-4" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // No providers available, config should remain unchanged
+    expect(result).toEqual(userConfig);
+  });
+
+  test("handles providers with no models", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/gpt-4" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [{ id: "openai", models: {} }];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // No provider models available, config should remain unchanged
+    expect(result).toEqual(userConfig);
+  });
+
+  test("validates multiple agents with mixed valid/invalid models", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/gpt-4" }, // valid
+        brainstormer: { model: "fake/model" }, // invalid provider
+        planner: { model: "openai/fake-model" }, // invalid model
+        reviewer: { model: "anthropic/claude-3" }, // valid
+      },
+    };
+
+    const providers: ProviderInfo[] = [
+      createProvider("openai", ["gpt-4", "gpt-3.5"]),
+      createProvider("anthropic", ["claude-3"]),
+    ];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    expect(result.agents?.commander?.model).toBe("openai/gpt-4");
+    expect(result.agents?.brainstormer?.model).toBeUndefined();
+    expect(result.agents?.planner?.model).toBeUndefined();
+    expect(result.agents?.reviewer?.model).toBe("anthropic/claude-3");
+  });
+
+  test("removes empty string model", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "", temperature: 0.5 },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Empty string model should be removed as invalid
+    expect(result.agents?.commander?.model).toBeUndefined();
+    expect(result.agents?.commander?.temperature).toBe(0.5);
+  });
+
+  test("removes model string without slash (malformed)", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "gpt-4-no-provider" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Malformed model (no slash) should be removed
+    expect(result.agents?.commander?.model).toBeUndefined();
+  });
+
+  test("handles model with multiple slashes in model ID", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "openai/gpt-4/turbo" },
+      },
+    };
+
+    // Model ID is "gpt-4/turbo" (contains slash)
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4/turbo"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Should be valid - "gpt-4/turbo" is the full model ID
+    expect(result.agents?.commander?.model).toBe("openai/gpt-4/turbo");
+  });
+
+  test("returns consistent shape when all agents have invalid models", () => {
+    const userConfig: MicodeConfig = {
+      agents: {
+        commander: { model: "invalid/model" },
+      },
+    };
+
+    const providers: ProviderInfo[] = [createProvider("openai", ["gpt-4"])];
+
+    const result = validateAgentModels(userConfig, providers);
+
+    // Should return { agents: {} } for consistency, not {}
+    expect(result).toEqual({ agents: {} });
+  });
+});