opencode-conductor-cdd-plugin 1.0.0-beta.20 → 1.0.0-beta.22

package/dist/tools/delegate.js

@@ -1,45 +1,96 @@
 import { tool } from "@opencode-ai/plugin/tool";
+import { detectCDDConfig, getAvailableOMOAgents, getAgentModel } from "../utils/configDetection.js";
+import { resolveAgentForDelegation } from "../utils/synergyDelegation.js";
+/**
+ * Creates a delegation tool that follows the OMO 3.0 agent invocation pattern.
+ *
+ * This implementation uses the synchronous prompt() API pattern:
+ * 1. Create a child session with parentID
+ * 2. Send prompt with agent specification and tool restrictions
+ * 3. Poll for completion by checking when session becomes idle
+ * 4. Extract and return the final response
+ *
+ * Based on OMO 3.0 call_omo_agent implementation:
+ * https://github.com/code-yeongyu/oh-my-opencode/blob/main/src/tools/call-omo-agent/tools.ts
+ */
 export function createDelegationTool(ctx) {
     return tool({
-        description: "Delegate a specific task to a specialized subagent",
+        description: "Delegate a specific task to a specialized subagent using OMO 3.0 invocation pattern",
         args: {
             task_description: tool.schema.string().describe("Summary of the work"),
-            subagent_type: tool.schema.string().describe("The name of the agent to call"),
+            subagent_type: tool.schema.string().describe("The name of the agent to call (e.g., explore, oracle, librarian)"),
             prompt: tool.schema.string().describe("Detailed instructions for the subagent"),
         },
         async execute(args, toolContext) {
-            // 1. Create a sub-session linked to the current one
-            const createResult = await ctx.client.session.create({
-                body: {
-                    parentID: toolContext.sessionID,
-                    title: `${args.task_description} (Delegated to ${args.subagent_type})`,
-                },
-            });
-            if (createResult.error)
-                return `Error: ${createResult.error}`;
-            const sessionID = createResult.data.id;
-            // 2. Send the prompt to the subagent
-            await ctx.client.session.prompt({
-                path: { id: sessionID },
-                body: {
-                    agent: args.subagent_type,
-                    tools: {
-                        "cdd_delegate": false,
+            try {
+                const config = detectCDDConfig();
+                const availableAgents = getAvailableOMOAgents();
+                const delegationResult = resolveAgentForDelegation(args.subagent_type, config.synergyFramework, availableAgents);
+                if (!delegationResult.success) {
+                    return `Cannot delegate to '${args.subagent_type}': ${delegationResult.reason}\n\nFalling back to @cdd for manual implementation.`;
+                }
+                const resolvedAgentName = delegationResult.resolvedAgent;
+                // 1. Create a sub-session linked to the current one
+                const createResult = await ctx.client.session.create({
+                    body: {
+                        parentID: toolContext.sessionID,
+                        title: `${args.task_description} (@${resolvedAgentName})`,
                     },
-                    parts: [{ type: "text", text: args.prompt }],
-                },
-            });
-            // 3. Fetch and return the assistant's response
-            const messagesResult = await ctx.client.session.messages({
-                path: { id: sessionID },
-            });
-            const lastMessage = messagesResult.data
-                ?.filter((m) => m.info.role === "assistant")
-                .pop();
-            const responseText = lastMessage?.parts
-                .filter((p) => p.type === "text")
-                .map((p) => p.text).join("\n") || "No response.";
-            return `${responseText}\n\n<task_metadata>\nsession_id: ${sessionID}\n</task_metadata>`;
+                });
+                if (createResult.error) {
+                    return `Error creating session: ${createResult.error}`;
+                }
+                const sessionID = createResult.data.id;
+                const agentModel = getAgentModel(resolvedAgentName);
+                await ctx.client.session.prompt({
+                    path: { id: sessionID },
+                    body: {
+                        agent: resolvedAgentName,
+                        model: agentModel,
+                        tools: {
+                            cdd_delegate: false,
+                            cdd_bg_task: false,
+                        },
+                        parts: [{ type: "text", text: args.prompt }],
+                    },
+                });
+                const MAX_POLL_TIME_MS = 5 * 60 * 1000;
+                const POLL_INTERVAL_MS = 2000;
+                const startTime = Date.now();
+                while (Date.now() - startTime < MAX_POLL_TIME_MS) {
+                    await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+                    try {
+                        const statusResult = await ctx.client.session.status();
+                        const sessionStatus = statusResult.data?.[sessionID];
+                        if (sessionStatus?.type === "idle") {
+                            break;
+                        }
+                    }
+                    catch (statusError) {
+                        console.warn("[CDD Delegate] Status check failed:", statusError);
+                    }
+                }
+                const messagesResult = await ctx.client.session.messages({
+                    path: { id: sessionID },
+                });
+                if (messagesResult.error) {
+                    return `Error fetching messages: ${messagesResult.error}`;
+                }
+                const assistantMessages = (messagesResult.data || [])
+                    .filter((m) => m.info.role === "assistant");
+                if (assistantMessages.length === 0) {
+                    return `No response from agent ${resolvedAgentName}`;
+                }
+                const lastMessage = assistantMessages[assistantMessages.length - 1];
+                const responseText = lastMessage.parts
+                    .filter((p) => p.type === "text")
+                    .map((p) => p.text)
+                    .join("\n") || "No response.";
+                return `${responseText}\n\n<task_metadata>\nsession_id: ${sessionID}\nagent: ${resolvedAgentName}\nrequested: ${args.subagent_type}\n</task_metadata>`;
+            }
+            catch (error) {
+                return `Error during delegation: ${error.message || String(error)}`;
+            }
         },
     });
 }

package/dist/utils/agentInitialization.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/agentInitialization.test.js

@@ -0,0 +1,262 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as configDetection from "./configDetection.js";
+/**
+ * Phase 2: Agent Initialization with Resolved Model
+ *
+ * Tests verify that the resolved model configuration is properly
+ * passed to @cdd agent initialization and delegated agents.
+ */
+describe("Phase 2: Agent Initialization with Resolved Model", () => {
+    let originalEnv;
+    beforeEach(() => {
+        originalEnv = { ...process.env };
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    describe("@cdd agent receives correct model from resolved config", () => {
+        it("should pass resolved model to agent initialization when oh-my-opencode-slim has model", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            // Simulate what the plugin does with the config
+            const commandDefaults = configDetectionResult.cddModel
+                ? { agent: "cdd", model: configDetectionResult.cddModel }
+                : { agent: "cdd" };
+            // Assert
+            if (configDetectionResult.cddModel) {
+                expect(commandDefaults).toHaveProperty("model");
+                expect(commandDefaults).toMatchObject({
+                    agent: "cdd",
+                    model: configDetectionResult.cddModel,
+                });
+            }
+        });
+        it("should use fallback defaults when no model is configured", () => {
+            // Arrange
+            const configDetectionResult = {
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                hasCDDInSlim: false,
+                synergyActive: false,
+                cddModel: undefined,
+                synergyFramework: "none",
+            };
+            // Act - simulate plugin behavior
+            const commandDefaults = configDetectionResult.cddModel
+                ? { agent: "cdd", model: configDetectionResult.cddModel }
+                : { agent: "cdd" };
+            // Assert
+            expect(commandDefaults).toEqual({
+                agent: "cdd",
+            });
+            expect(commandDefaults).not.toHaveProperty("model");
+        });
+        it("should maintain model throughout all CDD command defaults", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const commandDefaults = configDetectionResult.cddModel
+                ? { agent: "cdd", model: configDetectionResult.cddModel }
+                : { agent: "cdd" };
+            // Simulate all CDD commands
+            const commands = {
+                "cdd:setup": { ...commandDefaults },
+                "cdd:newTrack": { ...commandDefaults },
+                "cdd:implement": { ...commandDefaults },
+                "cdd:status": { ...commandDefaults },
+                "cdd:revert": { ...commandDefaults },
+            };
+            // Assert: all commands should have consistent model config
+            Object.entries(commands).forEach(([name, config]) => {
+                expect(config).toMatchObject({
+                    agent: "cdd",
+                });
+                if (configDetectionResult.cddModel) {
+                    expect(config).toHaveProperty("model", configDetectionResult.cddModel);
+                }
+            });
+        });
+    });
+    describe("Agent initialization handles invalid model config gracefully", () => {
+        it("should handle undefined model gracefully", () => {
+            // Arrange
+            const configDetectionResult = {
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                hasCDDInSlim: false,
+                synergyActive: false,
+                cddModel: undefined,
+                synergyFramework: "none",
+            };
+            // Act
+            const commandDefaults = configDetectionResult.cddModel
+                ? { agent: "cdd", model: configDetectionResult.cddModel }
+                : { agent: "cdd" };
+            // Assert
+            expect(commandDefaults).toBeDefined();
+            expect(commandDefaults.agent).toBe("cdd");
+            expect(() => {
+                if (!commandDefaults.agent)
+                    throw new Error("Agent not set");
+            }).not.toThrow();
+        });
+        it("should handle empty model string gracefully", () => {
+            // Arrange
+            const configDetectionResult = {
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                hasCDDInSlim: false,
+                synergyActive: false,
+                cddModel: "",
+                synergyFramework: "none",
+            };
+            // Act
+            const commandDefaults = configDetectionResult.cddModel
+                ? { agent: "cdd", model: configDetectionResult.cddModel }
+                : { agent: "cdd" };
+            // Assert - empty string is falsy, should fall back
+            expect(commandDefaults).not.toHaveProperty("model");
+        });
+        it("should validate model string format before passing to agent", () => {
+            // Arrange
+            const validModel = "anthropic/claude-3-5-sonnet";
+            const configDefaults = {
+                agent: "cdd",
+                model: validModel,
+            };
+            // Assert - model should be a valid string identifier
+            if (configDefaults.model) {
+                expect(typeof configDefaults.model).toBe("string");
+                expect(configDefaults.model).toMatch(/^[a-z0-9\-]+\/[a-z0-9\-]+$/i);
+            }
+        });
+    });
+    describe("Delegated agent model propagation", () => {
+        it("should pass model to @explorer agent when configured", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const parentModel = configDetectionResult.cddModel;
+            // Act - simulate delegation
+            const delegationConfig = parentModel
+                ? { agent: "explorer", model: parentModel }
+                : { agent: "explorer" };
+            // Assert
+            expect(delegationConfig).toMatchObject({
+                agent: "explorer",
+            });
+            if (parentModel) {
+                expect(delegationConfig).toHaveProperty("model", parentModel);
+            }
+        });
+        it("should pass model to @designer agent when configured", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const parentModel = configDetectionResult.cddModel;
+            // Act - simulate delegation
+            const delegationConfig = parentModel
+                ? { agent: "designer", model: parentModel }
+                : { agent: "designer" };
+            // Assert
+            expect(delegationConfig).toMatchObject({
+                agent: "designer",
+            });
+            if (parentModel) {
+                expect(delegationConfig).toHaveProperty("model", parentModel);
+            }
+        });
+        it("should pass model to @librarian agent when configured", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const parentModel = configDetectionResult.cddModel;
+            // Act - simulate delegation
+            const delegationConfig = parentModel
+                ? { agent: "librarian", model: parentModel }
+                : { agent: "librarian" };
+            // Assert
+            expect(delegationConfig).toMatchObject({
+                agent: "librarian",
+            });
+            if (parentModel) {
+                expect(delegationConfig).toHaveProperty("model", parentModel);
+            }
+        });
+        it("should pass model to @oracle agent when configured", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const parentModel = configDetectionResult.cddModel;
+            // Act - simulate delegation
+            const delegationConfig = parentModel
+                ? { agent: "oracle", model: parentModel }
+                : { agent: "oracle" };
+            // Assert
+            expect(delegationConfig).toMatchObject({
+                agent: "oracle",
+            });
+            if (parentModel) {
+                expect(delegationConfig).toHaveProperty("model", parentModel);
+            }
+        });
+        it("should maintain consistent model across delegation chain", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const parentModel = configDetectionResult.cddModel;
+            // Act - simulate full delegation chain
+            const cddConfig = parentModel
+                ? { agent: "cdd", model: parentModel }
+                : { agent: "cdd" };
+            const delegatedAgents = ["explorer", "designer", "librarian", "oracle"];
+            const delegationConfigs = delegatedAgents.map((agent) => parentModel
+                ? { agent: agent, model: parentModel }
+                : { agent: agent });
+            // Assert - all delegates should have same model as parent
+            delegationConfigs.forEach((delegateConfig) => {
+                if (parentModel) {
+                    expect(delegateConfig).toHaveProperty("model", parentModel);
+                }
+                if (cddConfig && "model" in cddConfig) {
+                    expect(delegateConfig).toHaveProperty("model", cddConfig.model);
+                }
+            });
+        });
+    });
+    describe("Synergy framework agent model propagation", () => {
+        it("should detect and use slim framework model when active", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            // Act
+            const hasSlimModel = configDetectionResult.hasCDDInSlim && configDetectionResult.cddModel;
+            // Assert
+            if (hasSlimModel) {
+                expect(configDetectionResult.synergyFramework).toBe("oh-my-opencode-slim");
+                expect(configDetectionResult.cddModel).toBeDefined();
+            }
+        });
+        it("should detect and use OMO framework model when slim not active", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            // Act
+            const hasOmoModel = configDetectionResult.hasCDDInOMO &&
+                !configDetectionResult.hasCDDInSlim &&
+                configDetectionResult.cddModel;
+            // Assert
+            if (hasOmoModel) {
+                expect(configDetectionResult.synergyFramework).toBe("oh-my-opencode");
+                expect(configDetectionResult.cddModel).toBeDefined();
+            }
+        });
+        it("should respect synergy priority when resolving model", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            // Act & Assert - verify priority chain
+            if (configDetectionResult.hasCDDInSlim) {
+                expect(configDetectionResult.synergyFramework).toBe("oh-my-opencode-slim");
+            }
+            else if (configDetectionResult.hasCDDInOMO) {
+                expect(configDetectionResult.synergyFramework).toBe("oh-my-opencode");
+            }
+            else {
+                expect(configDetectionResult.synergyFramework).toBe("none");
+            }
+        });
+    });
+});

package/dist/utils/commandDefaults.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Factory for creating OpenCode command defaults with CDD agent configuration.
+ * Handles model resolution and provides type-safe command default objects.
+ */
+export interface CommandDefaults {
+    agent: "cdd";
+    model?: string;
+}
+/**
+ * Creates command defaults for CDD commands with optional model configuration.
+ *
+ * @param cddModel - The resolved model string from config detection (undefined = use OpenCode default)
+ * @returns Command defaults object with agent and optional model
+ *
+ * @example
+ * // With model configured
+ * const defaults = createCommandDefaults("anthropic/claude-3-5-sonnet");
+ * // { agent: "cdd", model: "anthropic/claude-3-5-sonnet" }
+ *
+ * @example
+ * // Without model (fallback to OpenCode default)
+ * const defaults = createCommandDefaults(undefined);
+ * // { agent: "cdd" }
+ */
+export declare function createCommandDefaults(cddModel: string | undefined): CommandDefaults;
+/**
+ * Validates that a model string is properly formatted.
+ *
+ * @param model - Model string to validate
+ * @returns true if valid, false otherwise
+ *
+ * @example
+ * validateModelString("anthropic/claude-3-5-sonnet") // true
+ * validateModelString("google/gemini-flash-1.5") // true
+ * validateModelString("") // false
+ * validateModelString("  ") // false
+ */
+export declare function validateModelString(model: string | undefined): boolean;

package/dist/utils/commandDefaults.js

@@ -0,0 +1,54 @@
+/**
+ * Factory for creating OpenCode command defaults with CDD agent configuration.
+ * Handles model resolution and provides type-safe command default objects.
+ */
+/**
+ * Creates command defaults for CDD commands with optional model configuration.
+ *
+ * @param cddModel - The resolved model string from config detection (undefined = use OpenCode default)
+ * @returns Command defaults object with agent and optional model
+ *
+ * @example
+ * // With model configured
+ * const defaults = createCommandDefaults("anthropic/claude-3-5-sonnet");
+ * // { agent: "cdd", model: "anthropic/claude-3-5-sonnet" }
+ *
+ * @example
+ * // Without model (fallback to OpenCode default)
+ * const defaults = createCommandDefaults(undefined);
+ * // { agent: "cdd" }
+ */
+export function createCommandDefaults(cddModel) {
+    if (typeof cddModel === "string" && cddModel.trim() === "") {
+        console.warn("[CDD] Invalid model configuration detected. Model must be a non-empty string. Falling back to OpenCode default.");
+        return { agent: "cdd" };
+    }
+    if (!cddModel) {
+        return { agent: "cdd" };
+    }
+    return {
+        agent: "cdd",
+        model: cddModel,
+    };
+}
+/**
+ * Validates that a model string is properly formatted.
+ *
+ * @param model - Model string to validate
+ * @returns true if valid, false otherwise
+ *
+ * @example
+ * validateModelString("anthropic/claude-3-5-sonnet") // true
+ * validateModelString("google/gemini-flash-1.5") // true
+ * validateModelString("") // false
+ * validateModelString("  ") // false
+ */
+export function validateModelString(model) {
+    if (!model)
+        return false;
+    if (typeof model !== "string")
+        return false;
+    if (model.trim() === "")
+        return false;
+    return true;
+}

package/dist/utils/commandDefaults.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/commandDefaults.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createCommandDefaults, validateModelString } from './commandDefaults.js';
+describe('commandDefaults', () => {
+    describe('createCommandDefaults', () => {
+        it('should return defaults with model when valid model provided', () => {
+            const result = createCommandDefaults('anthropic/claude-3-5-sonnet');
+            expect(result).toEqual({
+                agent: 'cdd',
+                model: 'anthropic/claude-3-5-sonnet',
+            });
+        });
+        it('should return defaults without model when undefined provided', () => {
+            const result = createCommandDefaults(undefined);
+            expect(result).toEqual({
+                agent: 'cdd',
+            });
+        });
+        it('should return defaults without model when empty string provided', () => {
+            const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const result = createCommandDefaults('');
+            expect(result).toEqual({
+                agent: 'cdd',
+            });
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('[CDD] Invalid model configuration detected'));
+            consoleWarnSpy.mockRestore();
+        });
+        it('should return defaults without model when whitespace-only string provided', () => {
+            const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const result = createCommandDefaults('   ');
+            expect(result).toEqual({
+                agent: 'cdd',
+            });
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('[CDD] Invalid model configuration detected'));
+            consoleWarnSpy.mockRestore();
+        });
+        it('should handle various valid model formats', () => {
+            const testCases = [
+                'anthropic/claude-3-5-sonnet',
+                'google/gemini-flash-1.5',
+                'openai/gpt-4',
+                'anthropic/claude-3-opus-20240229',
+            ];
+            testCases.forEach(model => {
+                const result = createCommandDefaults(model);
+                expect(result.model).toBe(model);
+                expect(result.agent).toBe('cdd');
+            });
+        });
+        it('should return object with correct TypeScript type', () => {
+            const result = createCommandDefaults('anthropic/claude-3-5-sonnet');
+            expect(result.agent).toBe('cdd');
+            expect(typeof result.model).toBe('string');
+        });
+    });
+    describe('validateModelString', () => {
+        it('should return true for valid model strings', () => {
+            expect(validateModelString('anthropic/claude-3-5-sonnet')).toBe(true);
+            expect(validateModelString('google/gemini-flash-1.5')).toBe(true);
+            expect(validateModelString('openai/gpt-4')).toBe(true);
+        });
+        it('should return false for undefined', () => {
+            expect(validateModelString(undefined)).toBe(false);
+        });
+        it('should return false for empty string', () => {
+            expect(validateModelString('')).toBe(false);
+        });
+        it('should return false for whitespace-only string', () => {
+            expect(validateModelString('   ')).toBe(false);
+            expect(validateModelString('\t\n')).toBe(false);
+        });
+        it('should return false for non-string types', () => {
+            expect(validateModelString(null)).toBe(false);
+            expect(validateModelString(123)).toBe(false);
+            expect(validateModelString({})).toBe(false);
+            expect(validateModelString([])).toBe(false);
+        });
+    });
+    describe('integration with index.ts', () => {
+        it('should create command defaults compatible with OpenCode command config', () => {
+            const defaults = createCommandDefaults('anthropic/claude-3-5-sonnet');
+            const commandConfig = {
+                ...defaults,
+                template: 'Some prompt template',
+                description: 'Command description',
+            };
+            expect(commandConfig.agent).toBe('cdd');
+            expect(commandConfig.model).toBe('anthropic/claude-3-5-sonnet');
+            expect(commandConfig.template).toBe('Some prompt template');
+        });
+        it('should work with spread operator for command defaults', () => {
+            const defaults = createCommandDefaults('google/gemini-flash-1.5');
+            const command = {
+                ...defaults,
+                someOtherProperty: 'value',
+            };
+            expect(command.agent).toBe('cdd');
+            expect(command.model).toBe('google/gemini-flash-1.5');
+            expect(command.someOtherProperty).toBe('value');
+        });
+    });
+});

package/dist/utils/configDetection.d.ts

@@ -18,5 +18,21 @@ export interface ConfigDetectionResult {
     synergyFramework: SynergyFramework;
     /** Available agents from slim config (filtered by disabled_agents) */
     slimAgents?: string[];
+    /** Available agents from OMO config (filtered by disabled_agents) */
+    omoAgents?: string[];
 }
 export declare function detectCDDConfig(): ConfigDetectionResult;
+export declare function getAvailableOMOAgents(): string[];
+/**
+ * Get the configured model for a specific agent from synergy framework config.
+ *
+ * Priority Order:
+ * 1. oh-my-opencode-slim.json → agents.<agentName>.model
+ * 2. oh-my-opencode.json → agents.<agentName>.model
+ * 3. opencode.json → agent.<agentName>.model
+ * 4. undefined (no model configured)
+ *
+ * @param agentName - Name of the agent (e.g., 'explorer', 'designer', 'cdd')
+ * @returns Model string if configured, undefined otherwise
+ */
+export declare function getAgentModel(agentName: string): string | undefined;