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

package/dist/utils/configDetection.js

@@ -2,6 +2,38 @@ import { join } from "path";
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 export function detectCDDConfig() {
+    /**
+     * Detects and resolves CDD model configuration from synergy framework config files.
+     *
+     * Priority Order (highest to lowest):
+     * 1. oh-my-opencode-slim.json → agents.cdd.model
+     * 2. oh-my-opencode.json → agents.cdd.model
+     * 3. opencode.json → agent.cdd.model
+     * 4. No model (undefined)
+     *
+     * Synergy Framework Selection:
+     * - If oh-my-opencode-slim is present with cdd agent → use slim (highest priority)
+     * - Else if oh-my-opencode is present with cdd agent → use OMO
+     * - Else → no synergy (manual mode)
+     *
+     * Important: Synergy only activates if the selected framework explicitly
+     * has a "cdd" agent configured. File presence alone is insufficient.
+     *
+     * Example Config (oh-my-opencode-slim.json):
+     * {
+     *   "agents": {
+     *     "cdd": {
+     *       "model": "anthropic/claude-3-5-sonnet"
+     *     },
+     *     "explorer": {
+     *       "model": "google/gemini-flash-1.5"
+     *     }
+     *   },
+     *   "disabled_agents": ["librarian"]
+     * }
+     *
+     * @returns ConfigDetectionResult with framework info and model string
+     */
     const opencodeConfigDir = join(homedir(), ".config", "opencode");
     const opencodeJsonPath = join(opencodeConfigDir, "opencode.json");
     const omoJsonPath = join(opencodeConfigDir, "oh-my-opencode.json");
@@ -12,6 +44,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 +71,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 +84,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 +118,71 @@ 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 [];
+}
+/**
+ * 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 function getAgentModel(agentName) {
+    const opencodeConfigDir = join(homedir(), ".config", "opencode");
+    const opencodeJsonPath = join(opencodeConfigDir, "opencode.json");
+    const omoJsonPath = join(opencodeConfigDir, "oh-my-opencode.json");
+    const slimJsonPath = join(opencodeConfigDir, "oh-my-opencode-slim.json");
+    // Check oh-my-opencode-slim.json first (highest priority)
+    if (existsSync(slimJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(slimJsonPath, "utf-8"));
+            if (config?.agents?.[agentName]?.model) {
+                return config.agents[agentName].model;
+            }
+        }
+        catch (e) {
+            // Silently fail on parse errors
+        }
+    }
+    // Check oh-my-opencode.json (second priority)
+    if (existsSync(omoJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(omoJsonPath, "utf-8"));
+            if (config?.agents?.[agentName]?.model) {
+                return config.agents[agentName].model;
+            }
+        }
+        catch (e) {
+            // Silently fail on parse errors
+        }
+    }
+    // Check opencode.json (fallback)
+    if (existsSync(opencodeJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(opencodeJsonPath, "utf-8"));
+            if (config?.agent?.[agentName]?.model) {
+                return config.agent[agentName].model;
+            }
+        }
+        catch (e) {
+            // Silently fail on parse errors
+        }
+    }
+    return undefined;
+}

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 {};