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

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/modelConfigInjection.test.d.ts

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

package/dist/utils/modelConfigInjection.test.js

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+vi.mock("fs");
+vi.mock("os");
+describe("Model Configuration Injection in Plugin Initialization", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.resetModules();
+    });
+    it("should inject model into command defaults when oh-my-opencode.json has model", async () => {
+        const { existsSync: mockExistsSync, readFileSync: mockReadFileSync, readdirSync: mockReaddirSync, statSync: mockStatSync } = await import("fs");
+        const { homedir: mockHomedir } = await import("os");
+        vi.mocked(mockHomedir).mockReturnValue("/home/testuser");
+        vi.mocked(mockExistsSync).mockImplementation((path) => {
+            return String(path).includes("oh-my-opencode.json");
+        });
+        vi.mocked(mockReaddirSync).mockReturnValue([]);
+        vi.mocked(mockStatSync).mockReturnValue({ isDirectory: () => false });
+        vi.mocked(mockReadFileSync).mockImplementation((path) => {
+            if (String(path).includes("oh-my-opencode.json")) {
+                return JSON.stringify({
+                    agents: {
+                        cdd: { model: "anthropic/claude-3-5-sonnet" },
+                    },
+                });
+            }
+            return "";
+        });
+        const { MyPlugin } = await import("../index.js");
+        const plugin = await MyPlugin({
+            directory: "/test/project",
+            client: {},
+            project: {},
+            worktree: {},
+            serverUrl: new URL("http://localhost"),
+            $: {},
+        });
+        const config = { command: {} };
+        await plugin.config?.(config);
+        const setupCmd = config.command["cdd:setup"];
+        expect(setupCmd.model).toBe("anthropic/claude-3-5-sonnet");
+        expect(setupCmd.agent).toBe("cdd");
+    });
+    it("should inject model into ALL CDD commands", async () => {
+        const { existsSync: mockExistsSync, readFileSync: mockReadFileSync, readdirSync: mockReaddirSync, statSync: mockStatSync } = await import("fs");
+        const { homedir: mockHomedir } = await import("os");
+        vi.mocked(mockHomedir).mockReturnValue("/home/testuser");
+        vi.mocked(mockExistsSync).mockImplementation((path) => {
+            const pathStr = String(path);
+            return pathStr.includes("opencode.json") && !pathStr.includes("oh-my");
+        });
+        vi.mocked(mockReaddirSync).mockReturnValue([]);
+        vi.mocked(mockStatSync).mockReturnValue({ isDirectory: () => false });
+        vi.mocked(mockReadFileSync).mockImplementation((path) => {
+            const pathStr = String(path);
+            if (pathStr.includes("opencode.json") && !pathStr.includes("oh-my")) {
+                return JSON.stringify({
+                    agent: {
+                        cdd: { model: "anthropic/claude-3-5-haiku" },
+                    },
+                });
+            }
+            return "";
+        });
+        const { MyPlugin } = await import("../index.js");
+        const plugin = await MyPlugin({
+            directory: "/test/project",
+            client: {},
+            project: {},
+            worktree: {},
+            serverUrl: new URL("http://localhost"),
+            $: {},
+        });
+        const config = { command: {} };
+        await plugin.config?.(config);
+        const cmdConfig = config.command;
+        ["cdd:setup", "cdd:newTrack", "cdd:implement", "cdd:status", "cdd:revert"].forEach((cmd) => {
+            expect(cmdConfig[cmd].model).toBe("anthropic/claude-3-5-haiku");
+            expect(cmdConfig[cmd].agent).toBe("cdd");
+        });
+    });
+    it("should prioritize oh-my-opencode-slim > oh-my-opencode > opencode.json", async () => {
+        const { existsSync: mockExistsSync, readFileSync: mockReadFileSync, readdirSync: mockReaddirSync, statSync: mockStatSync } = await import("fs");
+        const { homedir: mockHomedir } = await import("os");
+        vi.mocked(mockHomedir).mockReturnValue("/home/testuser");
+        vi.mocked(mockExistsSync).mockReturnValue(true);
+        vi.mocked(mockReaddirSync).mockReturnValue([]);
+        vi.mocked(mockStatSync).mockReturnValue({ isDirectory: () => false });
+        vi.mocked(mockReadFileSync).mockImplementation((path) => {
+            const pathStr = String(path);
+            if (pathStr.includes("oh-my-opencode-slim.json")) {
+                return JSON.stringify({ agents: { cdd: { model: "google/gemini-2-flash" } } });
+            }
+            if (pathStr.includes("oh-my-opencode.json")) {
+                return JSON.stringify({ agents: { cdd: { model: "anthropic/claude-3-5-sonnet" } } });
+            }
+            if (pathStr.includes("opencode.json")) {
+                return JSON.stringify({ agent: { cdd: { model: "anthropic/claude-3-5-haiku" } } });
+            }
+            return "";
+        });
+        const { MyPlugin } = await import("../index.js");
+        const plugin = await MyPlugin({
+            directory: "/test/project",
+            client: {},
+            project: {},
+            worktree: {},
+            serverUrl: new URL("http://localhost"),
+            $: {},
+        });
+        const config = { command: {} };
+        await plugin.config?.(config);
+        expect(config.command["cdd:setup"].model).toBe("google/gemini-2-flash");
+    });
+    it("should handle missing model config gracefully", async () => {
+        const { existsSync: mockExistsSync, readdirSync: mockReaddirSync, statSync: mockStatSync } = await import("fs");
+        const { homedir: mockHomedir } = await import("os");
+        vi.mocked(mockHomedir).mockReturnValue("/home/testuser");
+        vi.mocked(mockExistsSync).mockReturnValue(false);
+        vi.mocked(mockReaddirSync).mockReturnValue([]);
+        vi.mocked(mockStatSync).mockReturnValue({ isDirectory: () => false });
+        const { MyPlugin } = await import("../index.js");
+        const plugin = await MyPlugin({
+            directory: "/test/project",
+            client: {},
+            project: {},
+            worktree: {},
+            serverUrl: new URL("http://localhost"),
+            $: {},
+        });
+        const config = { command: {} };
+        await plugin.config?.(config);
+        expect(config.command["cdd:setup"].model).toBeUndefined();
+        expect(config.command["cdd:setup"].agent).toBe("cdd");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-conductor-cdd-plugin",
-  "version": "1.0.0-beta.20",
+  "version": "1.0.0-beta.22",
   "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": {