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

package/dist/tools/delegate.js

@@ -1,45 +1,94 @@
 import { tool } from "@opencode-ai/plugin/tool";
+import { detectCDDConfig, getAvailableOMOAgents } 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;
+                await ctx.client.session.prompt({
+                    path: { id: sessionID },
+                    body: {
+                        agent: resolvedAgentName,
+                        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/configDetection.d.ts

@@ -18,5 +18,8 @@ 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[];

package/dist/utils/configDetection.js

@@ -12,6 +12,7 @@ export function detectCDDConfig() {
     let cddModel;
     let synergyFramework = 'none';
     let slimAgents;
+    let omoAgents;
     // Check oh-my-opencode-slim.json first (highest priority for synergy)
     if (existsSync(slimJsonPath)) {
         try {
@@ -38,7 +39,6 @@ export function detectCDDConfig() {
         }
     }
     // Check oh-my-opencode.json (only if slim doesn't have CDD)
-    // NOTE: We still check OMO to set hasCDDInOMO flag even if slim has priority
     if (existsSync(omoJsonPath)) {
         try {
             const config = JSON.parse(readFileSync(omoJsonPath, "utf-8"));
@@ -52,6 +52,10 @@ export function detectCDDConfig() {
                 if (!cddModel && config.agents.cdd.model) {
                     cddModel = config.agents.cdd.model;
                 }
+                // Extract available OMO agents (filter out disabled ones)
+                const allConfiguredAgents = Object.keys(config.agents || {});
+                const disabledAgents = new Set(config.disabled_agents ?? []);
+                omoAgents = allConfiguredAgents.filter(agent => !disabledAgents.has(agent));
             }
         }
         catch (e) {
@@ -82,5 +86,16 @@ export function detectCDDConfig() {
         cddModel,
         synergyFramework,
         slimAgents,
+        omoAgents,
     };
 }
+export function getAvailableOMOAgents() {
+    const config = detectCDDConfig();
+    if (config.synergyFramework === 'oh-my-opencode-slim' && config.slimAgents) {
+        return config.slimAgents;
+    }
+    if (config.synergyFramework === 'oh-my-opencode' && config.omoAgents) {
+        return config.omoAgents;
+    }
+    return [];
+}

package/dist/utils/configDetection.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { existsSync, readFileSync } from "fs";
-import { detectCDDConfig } from "./configDetection.js";
+import { detectCDDConfig, getAvailableOMOAgents } from "./configDetection.js";
 vi.mock("fs", () => ({
     existsSync: vi.fn(),
     readFileSync: vi.fn(),
@@ -400,4 +400,119 @@ describe("configDetection", () => {
             expect(result.synergyActive).toBe(false);
         });
     });
+    describe("OMO agent availability detection", () => {
+        it("should extract available agents from oh-my-opencode config", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-sonnet" },
+                            sisyphus: { model: "anthropic/claude-3-5-sonnet" },
+                            explore: { model: "google/gemini-3-flash" },
+                            oracle: { model: "anthropic/claude-3-5-sonnet" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.omoAgents).toEqual(['cdd', 'sisyphus', 'explore', 'oracle']);
+        });
+        it("should filter out disabled agents from oh-my-opencode config", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-sonnet" },
+                            sisyphus: { model: "anthropic/claude-3-5-sonnet" },
+                            explore: { model: "google/gemini-3-flash" },
+                            oracle: { model: "anthropic/claude-3-5-sonnet" }
+                        },
+                        disabled_agents: ['explore', 'oracle']
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.omoAgents).toEqual(['cdd', 'sisyphus']);
+        });
+        it("should handle empty agents object in oh-my-opencode config", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {}
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.omoAgents).toBeUndefined();
+        });
+    });
+    describe("getAvailableOMOAgents", () => {
+        it("should return slim agents when slim framework is active", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-sonnet" }
+                        },
+                        disabled_agents: ['oracle']
+                    });
+                }
+                return "";
+            });
+            const agents = getAvailableOMOAgents();
+            expect(agents).toEqual(['explorer', 'librarian', 'designer']);
+        });
+        it("should return omo agents when oh-my-opencode framework is active", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-sonnet" },
+                            sisyphus: { model: "anthropic/claude-3-5-sonnet" },
+                            explore: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const agents = getAvailableOMOAgents();
+            expect(agents).toEqual(['cdd', 'sisyphus', 'explore']);
+        });
+        it("should return empty array when no synergy framework is active", () => {
+            vi.mocked(existsSync).mockReturnValue(false);
+            const agents = getAvailableOMOAgents();
+            expect(agents).toEqual([]);
+        });
+        it("should prioritize slim agents over omo agents when both configs exist", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-slim" }
+                        }
+                    });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-omo" },
+                            sisyphus: { model: "model" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const agents = getAvailableOMOAgents();
+            expect(agents).toEqual(['explorer', 'librarian', 'oracle', 'designer']);
+        });
+    });
 });

package/dist/utils/documentGeneration.d.ts

@@ -1,5 +1,6 @@
 import { Question, Section } from './questionGenerator.js';
 import { CodebaseAnalysis } from './codebaseAnalysis.js';
+import { Language } from './languageSupport.js';
 /**
  * Document Generation Module
  *
@@ -65,6 +66,7 @@ export interface DocumentGenerationOptions {
     outputPath: string;
     maxRevisions?: number;
     customInputPrompt?: (question: Question) => Promise<string>;
+    language?: Language;
 }
 export interface DocumentGenerationResult {
     success: boolean;
@@ -76,6 +78,7 @@ export interface DocumentGenerationResult {
 export interface PresentQuestionsOptions {
     maxQuestions?: number;
     customInputPrompt?: (question: Question) => Promise<string>;
+    language?: Language;
 }
 /**
  * Present questions sequentially to the user

package/dist/utils/documentGeneration.js

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { validateSelection, parseSelection } from './interactiveMenu.js';
+import { translateQuestion, detectLanguage } from './languageSupport.js';
 // Constants
 const MAX_QUESTIONS = 5;
 const MAX_REVISION_ATTEMPTS = 3;
@@ -18,6 +19,7 @@ const CHECKPOINT_MAP = {
  */
 export async function presentQuestionsSequentially(questions, responder, options = {}) {
     const { maxQuestions = MAX_QUESTIONS, customInputPrompt } = options;
+    let { language = 'en' } = options;
     const session = {
         section: questions[0]?.section || 'product',
         questionsAsked: [],
@@ -28,30 +30,47 @@ export async function presentQuestionsSequentially(questions, responder, options
     };
     for (let i = 0; i < Math.min(questions.length, maxQuestions); i++) {
         const question = questions[i];
-        session.questionsAsked.push(question);
+        // Translate question if language is Spanish
+        const translatedQuestion = language === 'es' ? translateQuestion(question, 'es') : question;
+        session.questionsAsked.push(translatedQuestion);
         // Get user response
-        let selections;
+        let selections = [];
         let isValid = false;
         // Keep asking until valid response
         while (!isValid) {
-            selections = await responder(question, i + 1);
-            isValid = validateSelection(selections.join(','), question.type);
+            selections = await responder(translatedQuestion, i + 1);
+            isValid = validateSelection(selections.join(','), translatedQuestion.type);
         }
-        const parsedSelections = parseSelection(selections.join(','), question.type);
-        // Map selections to actual option text
+        // Auto-detect language from first user response if custom input provided
+        if (i === 0 && selections.length > 0 && selections[0].length > 5) {
+            const detectedLang = detectLanguage(selections.join(' '));
+            if (detectedLang !== language) {
+                language = detectedLang;
+            }
+        }
+        const parsedSelections = parseSelection(selections.join(','), translatedQuestion.type);
+        // Map selections to actual option text (from translated question)
         const selectedOptions = parsedSelections.map(letter => {
             const index = letter.charCodeAt(0) - 'A'.charCodeAt(0);
-            return question.options[index];
+            return translatedQuestion.options[index];
         });
         const answer = {
-            questionId: question.id,
+            questionId: translatedQuestion.id,
             selections: parsedSelections,
             selectedOptions,
             timestamp: new Date().toISOString(),
         };
         // Handle option D (custom input)
         if (parsedSelections.includes('D') && customInputPrompt) {
-            answer.customText = await customInputPrompt(question);
+            const customInput = await customInputPrompt(translatedQuestion);
+            answer.customText = customInput;
+            // Detect language from custom text input
+            if (customInput && customInput.length > 5) {
+                const detectedLang = detectLanguage(customInput);
+                if (detectedLang !== language) {
+                    language = detectedLang;
+                }
+            }
         }
         session.answers.push(answer);
         // Handle option E (auto-generate) - stop asking questions
@@ -242,6 +261,7 @@ export async function generateDocument(options) {
         // Step 1: Present questions sequentially
         const session = await presentQuestionsSequentially(questions, responder, {
             customInputPrompt,
+            language: options.language || 'en',
         });
         // Step 2: Draft document from answers
         let draft = draftDocumentFromAnswers(session, analysis);

package/dist/utils/interactiveMenu.test.js

@@ -121,6 +121,11 @@ describe('interactiveMenu', () => {
             expect(validateSelection('', 'additive')).toBe(false);
             expect(validateSelection('   ', 'exclusive')).toBe(false);
         });
+        it('should reject input with only commas or whitespace', () => {
+            expect(validateSelection(',,,', 'exclusive')).toBe(false);
+            expect(validateSelection(', , ,', 'additive')).toBe(false);
+            expect(validateSelection('  ,  ', 'exclusive')).toBe(false);
+        });
         it('should reject option E in combination with others for additive', () => {
             expect(validateSelection('A,E', 'additive')).toBe(false);
             expect(validateSelection('E,A', 'additive')).toBe(false);

package/dist/utils/languageSupport.d.ts

@@ -0,0 +1,5 @@
+import { Question } from './questionGenerator.js';
+export type Language = 'en' | 'es';
+export declare function detectLanguage(text: string): Language;
+export declare function translateQuestion(question: Question, language: Language): Question;
+export declare function translateInstruction(key: string, language: Language): string;

package/dist/utils/languageSupport.js

@@ -0,0 +1,163 @@
+const SPANISH_INDICATORS = [
+    '¿', '¡', 'á', 'é', 'í', 'ó', 'ú', 'ñ', 'ü',
+    'cuál', 'qué', 'cómo', 'dónde', 'cuándo', 'quién',
+    'los', 'las', 'una', 'del', 'con', 'para', 'por',
+    'necesito', 'quiero', 'aplicación', 'proyecto', 'crear',
+    'objetivo', 'principal', 'usuarios', 'principales',
+    'añadir', 'configuración', 'nuevo', 'algo',
+];
+const ENGLISH_INDICATORS = [
+    'what', 'how', 'where', 'when', 'who', 'which',
+    'the', 'a', 'an', 'of', 'with', 'for', 'by',
+    'need', 'want', 'application', 'project', 'create',
+    'main', 'primary', 'users', 'add', 'something', 'new',
+];
+const TRANSLATIONS = {
+    'menu.select_option': {
+        en: 'Select your option (e.g., "A", "B", "C")',
+        es: 'Selecciona tu opción (ej: "A", "B", "C")',
+    },
+    'menu.custom_input': {
+        en: 'Enter custom text',
+        es: 'Ingresa texto personalizado',
+    },
+    'menu.auto_generate': {
+        en: 'Auto-generate from context',
+        es: 'Auto-generar desde contexto',
+    },
+    'approval.approve': {
+        en: 'Approve this document',
+        es: 'Aprobar este documento',
+    },
+    'approval.revise': {
+        en: 'Request revisions',
+        es: 'Solicitar revisiones',
+    },
+    'question.primary_purpose': {
+        en: 'What is the primary purpose of this project?',
+        es: '¿Cuál es el propósito principal de este proyecto?',
+    },
+    'option.web_application': {
+        en: 'Build a web application',
+        es: 'Construir una aplicación web',
+    },
+    'option.cli_tool': {
+        en: 'Build a CLI tool',
+        es: 'Construir una herramienta CLI',
+    },
+    'option.library': {
+        en: 'Create a library',
+        es: 'Crear una biblioteca',
+    },
+    'option.custom': {
+        en: 'Enter custom text',
+        es: 'Ingresar texto personalizado',
+    },
+    'option.auto_generate': {
+        en: 'Auto-generate from context',
+        es: 'Auto-generar desde contexto',
+    },
+};
+export function detectLanguage(text) {
+    if (!text || text.trim().length === 0) {
+        return 'en';
+    }
+    const lowerText = text.toLowerCase();
+    const words = lowerText.split(/\s+/);
+    let spanishScore = 0;
+    let englishScore = 0;
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        // First word gets significantly more weight (10x) to dominate language detection
+        const weight = i === 0 ? 10 : 1;
+        if (SPANISH_INDICATORS.includes(word)) {
+            spanishScore += weight;
+        }
+        if (ENGLISH_INDICATORS.includes(word)) {
+            englishScore += weight;
+        }
+    }
+    // Special characters strongly indicate Spanish
+    for (const char of ['¿', '¡', 'á', 'é', 'í', 'ó', 'ú', 'ñ', 'ü']) {
+        if (lowerText.includes(char)) {
+            spanishScore += 5;
+        }
+    }
+    return spanishScore > englishScore ? 'es' : 'en';
+}
+export function translateQuestion(question, language) {
+    if (language === 'en') {
+        return question;
+    }
+    const translated = {
+        ...question,
+        text: translateQuestionText(question.text, question.id),
+        options: question.options.map((opt, idx) => translateOption(opt, idx)),
+    };
+    return translated;
+}
+function translateQuestionText(text, questionId) {
+    const translationKey = `question.${questionId}`;
+    if (TRANSLATIONS[translationKey]) {
+        return TRANSLATIONS[translationKey].es;
+    }
+    if (text.includes('primary purpose')) {
+        return '¿Cuál es el propósito principal de este proyecto?';
+    }
+    if (text.includes('target users')) {
+        return '¿Quiénes son los usuarios objetivo?';
+    }
+    if (text.includes('key features')) {
+        return '¿Cuáles son las características principales?';
+    }
+    if (text.includes('programming language')) {
+        return '¿Qué lenguajes de programación usarás?';
+    }
+    if (text.includes('framework')) {
+        return '¿Qué frameworks usarás?';
+    }
+    return text;
+}
+function translateOption(option, index) {
+    const optionLower = option.toLowerCase();
+    if (optionLower.includes('web application')) {
+        return 'Construir una aplicación web';
+    }
+    if (optionLower.includes('cli tool')) {
+        return 'Construir una herramienta CLI';
+    }
+    if (optionLower.includes('library')) {
+        return 'Crear una biblioteca';
+    }
+    if (optionLower.includes('enter custom') || optionLower.includes('custom text')) {
+        return 'Ingresar texto personalizado';
+    }
+    if (optionLower.includes('auto-generate')) {
+        return 'Auto-generar desde contexto';
+    }
+    if (optionLower.includes('developers')) {
+        return 'Desarrolladores';
+    }
+    if (optionLower.includes('end users')) {
+        return 'Usuarios finales';
+    }
+    if (optionLower.includes('businesses')) {
+        return 'Empresas';
+    }
+    if (optionLower.includes('typescript')) {
+        return 'TypeScript';
+    }
+    if (optionLower.includes('python')) {
+        return 'Python';
+    }
+    if (optionLower.includes('javascript')) {
+        return 'JavaScript';
+    }
+    return option;
+}
+export function translateInstruction(key, language) {
+    if (TRANSLATIONS[key] && TRANSLATIONS[key][language]) {
+        return TRANSLATIONS[key][language];
+    }
+    return key;
+}

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

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