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

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

package/dist/utils/languageSupport.test.js

@@ -0,0 +1,158 @@
+import { describe, it, expect } from 'vitest';
+import { detectLanguage, translateQuestion, translateInstruction, } from './languageSupport.js';
+describe('languageSupport', () => {
+    describe('detectLanguage', () => {
+        it('should detect Spanish from common Spanish words', () => {
+            expect(detectLanguage('¿Cuál es el objetivo principal?')).toBe('es');
+            expect(detectLanguage('Los usuarios principales son')).toBe('es');
+            expect(detectLanguage('Necesito crear una aplicación')).toBe('es');
+        });
+        it('should detect Spanish from Spanish-specific characters', () => {
+            expect(detectLanguage('Añadir funcionalidad')).toBe('es');
+            expect(detectLanguage('Configuración básica')).toBe('es');
+        });
+        it('should detect English from common English words', () => {
+            expect(detectLanguage('What is the primary goal?')).toBe('en');
+            expect(detectLanguage('The main users are')).toBe('en');
+            expect(detectLanguage('I need to create an application')).toBe('en');
+        });
+        it('should default to English for ambiguous input', () => {
+            expect(detectLanguage('123')).toBe('en');
+            expect(detectLanguage('React TypeScript')).toBe('en');
+            expect(detectLanguage('')).toBe('en');
+        });
+        it('should handle mixed language input', () => {
+            // Should detect based on predominant language
+            expect(detectLanguage('Create a proyecto nuevo')).toBe('en');
+            expect(detectLanguage('Necesito create something')).toBe('es');
+        });
+    });
+    describe('translateQuestion', () => {
+        const englishQuestion = {
+            id: 'product-1',
+            text: 'What is the primary purpose of this project?',
+            type: 'exclusive',
+            section: 'product',
+            options: [
+                'Build a web application',
+                'Build a CLI tool',
+                'Create a library',
+                'Enter custom text',
+                'Auto-generate from context',
+            ],
+        };
+        it('should translate question text to Spanish', () => {
+            const translated = translateQuestion(englishQuestion, 'es');
+            expect(translated.text).toContain('propósito');
+            expect(translated.text).toContain('proyecto');
+        });
+        it('should translate options to Spanish', () => {
+            const translated = translateQuestion(englishQuestion, 'es');
+            expect(translated.options[0]).toContain('aplicación web');
+            expect(translated.options[3]).toContain('texto personalizado');
+            expect(translated.options[4]).toContain('Auto-generar');
+        });
+        it('should keep English text when language is English', () => {
+            const translated = translateQuestion(englishQuestion, 'en');
+            expect(translated.text).toBe(englishQuestion.text);
+            expect(translated.options).toEqual(englishQuestion.options);
+        });
+        it('should preserve question metadata (id, type, section)', () => {
+            const translated = translateQuestion(englishQuestion, 'es');
+            expect(translated.id).toBe(englishQuestion.id);
+            expect(translated.type).toBe(englishQuestion.type);
+            expect(translated.section).toBe(englishQuestion.section);
+        });
+        it('should use fallback translation for target users question', () => {
+            const question = {
+                id: 'users-1',
+                text: 'Who are the target users?',
+                type: 'exclusive',
+                section: 'product',
+                options: ['Developers', 'End users', 'Businesses'],
+            };
+            const translated = translateQuestion(question, 'es');
+            expect(translated.text).toContain('usuarios objetivo');
+            expect(translated.options[0]).toBe('Desarrolladores');
+            expect(translated.options[1]).toContain('Usuarios finales');
+            expect(translated.options[2]).toBe('Empresas');
+        });
+        it('should use fallback translation for key features question', () => {
+            const question = {
+                id: 'features-1',
+                text: 'What are the key features?',
+                type: 'exclusive',
+                section: 'product',
+                options: ['Feature 1', 'Feature 2'],
+            };
+            const translated = translateQuestion(question, 'es');
+            expect(translated.text).toContain('características principales');
+        });
+        it('should use fallback translation for programming language question', () => {
+            const question = {
+                id: 'tech-1',
+                text: 'What programming language will you use?',
+                type: 'exclusive',
+                section: 'tech-stack',
+                options: ['TypeScript', 'Python', 'JavaScript'],
+            };
+            const translated = translateQuestion(question, 'es');
+            expect(translated.text).toContain('lenguajes de programación');
+            expect(translated.options[0]).toBe('TypeScript');
+            expect(translated.options[1]).toBe('Python');
+            expect(translated.options[2]).toBe('JavaScript');
+        });
+        it('should use fallback translation for framework question', () => {
+            const question = {
+                id: 'tech-2',
+                text: 'What framework will you use?',
+                type: 'exclusive',
+                section: 'tech-stack',
+                options: ['React', 'Vue', 'Angular'],
+            };
+            const translated = translateQuestion(question, 'es');
+            expect(translated.text).toContain('frameworks');
+        });
+        it('should return original text if no translation matches', () => {
+            const question = {
+                id: 'custom-question',
+                text: 'Some custom question text without matches',
+                type: 'exclusive',
+                section: 'product',
+                options: ['Option A', 'Option B'],
+            };
+            const translated = translateQuestion(question, 'es');
+            expect(translated.text).toBe(question.text);
+            expect(translated.options).toEqual(question.options);
+        });
+    });
+    describe('translateInstruction', () => {
+        it('should translate menu instructions to Spanish', () => {
+            const key = 'menu.select_option';
+            const translated = translateInstruction(key, 'es');
+            expect(translated).toContain('Selecciona');
+            expect(translated).toContain('opción');
+        });
+        it('should translate menu instructions to English', () => {
+            const key = 'menu.select_option';
+            const translated = translateInstruction(key, 'en');
+            expect(translated).toContain('Select');
+            expect(translated).toContain('option');
+        });
+        it('should handle approval instructions in Spanish', () => {
+            const key = 'approval.approve';
+            const translated = translateInstruction(key, 'es');
+            expect(translated.toLowerCase()).toContain('aprobar');
+        });
+        it('should handle approval instructions in English', () => {
+            const key = 'approval.approve';
+            const translated = translateInstruction(key, 'en');
+            expect(translated.toLowerCase()).toContain('approve');
+        });
+        it('should return key if translation not found', () => {
+            const key = 'unknown.key';
+            const translated = translateInstruction(key, 'es');
+            expect(translated).toBe(key);
+        });
+    });
+});

package/dist/utils/synergyState.test.js

@@ -15,6 +15,7 @@ describe("synergyState", () => {
             vi.mocked(detectCDDConfig).mockReturnValue({
                 hasCDDInOpenCode: false,
                 hasCDDInOMO: false,
+                hasCDDInSlim: true,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode-slim',
                 slimAgents: ['explorer', 'librarian', 'oracle', 'designer'],
@@ -28,6 +29,7 @@ describe("synergyState", () => {
             vi.mocked(detectCDDConfig).mockReturnValue({
                 hasCDDInOpenCode: false,
                 hasCDDInOMO: false,
+                hasCDDInSlim: true,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode-slim',
                 slimAgents: ['explorer', 'librarian'],
@@ -42,6 +44,7 @@ describe("synergyState", () => {
                 .mockReturnValueOnce({
                 hasCDDInOpenCode: false,
                 hasCDDInOMO: false,
+                hasCDDInSlim: true,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode-slim',
                 slimAgents: ['explorer'],
@@ -49,6 +52,7 @@ describe("synergyState", () => {
                 .mockReturnValueOnce({
                 hasCDDInOpenCode: false,
                 hasCDDInOMO: true,
+                hasCDDInSlim: false,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode',
                 cddModel: 'model-1',
@@ -64,13 +68,15 @@ describe("synergyState", () => {
                 .mockReturnValueOnce({
                 hasCDDInOpenCode: false,
                 hasCDDInOMO: false,
+                hasCDDInSlim: true,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode-slim',
                 slimAgents: ['explorer'],
             })
                 .mockReturnValueOnce({
                 hasCDDInOpenCode: false,
-                hasCDDInOMO: false,
+                hasCDDInOMO: true,
+                hasCDDInSlim: false,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode',
                 cddModel: 'model-changed',
@@ -85,6 +91,7 @@ describe("synergyState", () => {
             vi.mocked(detectCDDConfig).mockReturnValue({
                 hasCDDInOpenCode: true,
                 hasCDDInOMO: false,
+                hasCDDInSlim: false,
                 synergyActive: false,
                 synergyFramework: 'none',
                 cddModel: 'model-1',
@@ -99,13 +106,15 @@ describe("synergyState", () => {
                 .mockReturnValueOnce({
                 hasCDDInOpenCode: false,
                 hasCDDInOMO: false,
+                hasCDDInSlim: true,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode-slim',
                 slimAgents: ['explorer'],
             })
                 .mockReturnValueOnce({
                 hasCDDInOpenCode: false,
-                hasCDDInOMO: false,
+                hasCDDInOMO: true,
+                hasCDDInSlim: false,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode',
                 cddModel: 'model-1',
@@ -124,6 +133,7 @@ describe("synergyState", () => {
             vi.mocked(detectCDDConfig).mockReturnValue({
                 hasCDDInOpenCode: false,
                 hasCDDInOMO: false,
+                hasCDDInSlim: false,
                 synergyActive: false,
                 synergyFramework: 'none',
             });
@@ -136,6 +146,7 @@ describe("synergyState", () => {
             vi.mocked(detectCDDConfig).mockReturnValue({
                 hasCDDInOpenCode: false,
                 hasCDDInOMO: false,
+                hasCDDInSlim: true,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode-slim',
                 slimAgents: ['explorer', 'oracle'],
@@ -147,6 +158,7 @@ describe("synergyState", () => {
             vi.mocked(detectCDDConfig).mockReturnValue({
                 hasCDDInOpenCode: false,
                 hasCDDInOMO: true,
+                hasCDDInSlim: false,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode',
                 cddModel: 'model-1',
@@ -163,13 +175,15 @@ describe("synergyState", () => {
                 .mockReturnValueOnce({
                 hasCDDInOpenCode: false,
                 hasCDDInOMO: false,
+                hasCDDInSlim: true,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode-slim',
                 slimAgents: ['explorer'],
             })
                 .mockReturnValueOnce({
                 hasCDDInOpenCode: false,
-                hasCDDInOMO: false,
+                hasCDDInOMO: true,
+                hasCDDInSlim: false,
                 synergyActive: true,
                 synergyFramework: 'oh-my-opencode',
                 cddModel: 'changed',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-conductor-cdd-plugin",
-  "version": "1.0.0-beta.19",
+  "version": "1.0.0-beta.21",
   "description": "Context-Driven Development (CDD) plugin for OpenCode - Transform your AI coding workflow with structured specifications, plans, and implementation tracking",
   "type": "module",
   "repository": {
@@ -42,7 +42,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "1.0.223",
+    "@opencode-ai/plugin": "^1.1.27",
     "smol-toml": "^1.6.0"
   },
   "devDependencies": {
@@ -53,6 +53,7 @@
     "@semantic-release/npm": "^12.0.1",
     "@semantic-release/release-notes-generator": "^14.0.0",
     "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^4.0.17",
     "semantic-release": "^24.2.1",
     "typescript": "^5.0.0",
     "vitest": "^4.0.16"