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

package/dist/utils/codebaseAnalysis.test.js

@@ -0,0 +1,556 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import { parseIgnoreFiles, detectManifests, inferArchitecture, detectLanguages, detectFrameworks, analyzeCodebase, } from './codebaseAnalysis.js';
+/**
+ * Codebase Analysis Module Tests
+ *
+ * This module is responsible for analyzing existing codebases to extract:
+ * - Ignore patterns from .ignore, .geminiignore, .gitignore
+ * - Dependency manifests with versions and metadata
+ * - Architecture patterns (Monorepo, Microservices, MVC, etc.)
+ * - Programming languages and frameworks
+ *
+ * Based on reference implementations from:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+// Mock file system and child_process
+vi.mock('fs');
+vi.mock('child_process');
+describe('Codebase Analysis', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('parseIgnoreFiles', () => {
+        it('should parse .geminiignore with precedence over .gitignore', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.geminiignore');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('node_modules/\n*.log\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(2);
+            expect(result[0].pattern).toBe('node_modules/');
+            expect(result[0].negated).toBe(false);
+        });
+        it('should parse .gitignore if .geminiignore does not exist', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.gitignore');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('dist/\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].pattern).toBe('dist/');
+        });
+        it('should parse .ignore file', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.endsWith('.ignore') && !pathStr.endsWith('.geminiignore');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('temp/\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(1);
+        });
+        it('should handle negation patterns with !', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('*.log\n!important.log\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(2);
+            expect(result[1].pattern).toBe('important.log');
+            expect(result[1].negated).toBe(true);
+        });
+        it('should ignore comment lines starting with #', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('# Comment\nnode_modules/\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].pattern).toBe('node_modules/');
+        });
+        it('should ignore empty lines', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('node_modules/\n\n\ndist/\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(2);
+        });
+        it('should return empty array when no ignore files exist', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toEqual([]);
+        });
+        it('should handle patterns with wildcards (* and **)', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('*.log\n**/node_modules\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(2);
+            expect(result[0].pattern).toBe('*.log');
+            expect(result[1].pattern).toBe('**/node_modules');
+        });
+        it('should handle directory patterns ending with /', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('dist/\nnode_modules/\n');
+            const result = parseIgnoreFiles('/test/project');
+            expect(result).toHaveLength(2);
+            expect(result[0].pattern).toBe('dist/');
+        });
+    });
+    describe('detectManifests', () => {
+        it('should detect package.json with name and version', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+                name: 'test-project',
+                version: '1.0.0',
+                description: 'Test project',
+            }));
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('package.json');
+            expect(result[0].metadata.name).toBe('test-project');
+            expect(result[0].metadata.version).toBe('1.0.0');
+        });
+        it('should detect package.json dependencies and devDependencies', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+                name: 'test',
+                dependencies: { react: '^18.0.0' },
+                devDependencies: { vitest: '^4.0.0' },
+            }));
+            const result = detectManifests('/test/project');
+            expect(result[0].dependencies).toEqual({
+                react: '^18.0.0',
+                vitest: '^4.0.0',
+            });
+        });
+        it('should detect pom.xml with Maven metadata', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('pom.xml');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('<project><groupId>com.example</groupId><artifactId>demo</artifactId><version>1.0</version></project>');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('pom.xml');
+            expect(result[0].metadata.groupId).toBe('com.example');
+            expect(result[0].metadata.artifactId).toBe('demo');
+        });
+        it('should detect requirements.txt with Python packages', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('requirements.txt');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('django==4.0.0\nflask>=2.0.0\n');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('requirements.txt');
+            expect(result[0].dependencies).toEqual({
+                django: '4.0.0',
+                flask: '2.0.0',
+            });
+        });
+        it('should detect go.mod with Go module information', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('go.mod');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('module github.com/example/project\n');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('go.mod');
+            expect(result[0].metadata.module).toBe('github.com/example/project');
+        });
+        it('should detect Cargo.toml with Rust metadata', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('Cargo.toml');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('[package]\nname = "test"\nversion = "0.1.0"\n');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('Cargo.toml');
+            expect(result[0].metadata.name).toBe('test');
+            expect(result[0].metadata.version).toBe('0.1.0');
+        });
+        it('should detect Gemfile with Ruby gems', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('Gemfile');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('gem "rails", "7.0.0"\ngem "pg"\n');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].type).toBe('Gemfile');
+            expect(result[0].dependencies).toEqual({
+                rails: '7.0.0',
+                pg: '*',
+            });
+        });
+        it('should return empty array when no manifests found', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = detectManifests('/test/project');
+            expect(result).toEqual([]);
+        });
+        it('should handle malformed JSON in package.json gracefully', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue('{ invalid json');
+            const result = detectManifests('/test/project');
+            expect(result).toHaveLength(1);
+            expect(result[0].metadata.error).toBe('Malformed JSON');
+        });
+        it('should detect multiple manifests in same project', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                if (pathStr.endsWith('package.json')) {
+                    return JSON.stringify({ name: 'test' });
+                }
+                if (pathStr.endsWith('requirements.txt')) {
+                    return 'django==4.0.0';
+                }
+                return '';
+            });
+            const result = detectManifests('/test/project');
+            expect(result.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe('inferArchitecture', () => {
+        it('should detect monorepo with packages/ directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('packages');
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('monorepo');
+        });
+        it('should detect monorepo with workspaces in package.json', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+                name: 'test',
+                workspaces: ['packages/*'],
+            }));
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('monorepo');
+        });
+        it('should detect monorepo with lerna.json', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('lerna.json');
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('monorepo');
+        });
+        it('should detect microservices with multiple service directories', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.includes('user-service') || pathStr.includes('auth-service') || pathStr.endsWith('package.json');
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'user-service', isDirectory: () => true },
+                { name: 'auth-service', isDirectory: () => true },
+            ]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('microservices');
+        });
+        it('should detect MVC pattern with models/, views/, controllers/ directories', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.endsWith('models') || pathStr.endsWith('views') || pathStr.endsWith('controllers');
+            });
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('mvc');
+        });
+        it('should detect Clean Architecture with domain/, application/, infrastructure/ directories', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.endsWith('domain') || pathStr.endsWith('application') || pathStr.endsWith('infrastructure');
+            });
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('clean-architecture');
+        });
+        it('should detect Hexagonal Architecture with adapters/, ports/ directories', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.endsWith('adapters') || pathStr.endsWith('ports');
+            });
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('hexagonal-architecture');
+        });
+        it('should detect layered architecture with src/api/, src/services/, src/data/ directories', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                // Must return true for src/ directory AND its subdirectories
+                if (pathStr.endsWith('/src'))
+                    return true;
+                if (pathStr.endsWith('/src/api'))
+                    return true;
+                if (pathStr.endsWith('/src/services'))
+                    return true;
+                if (pathStr.endsWith('/src/data'))
+                    return true;
+                return false;
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('layered-architecture');
+        });
+        it('should return "unknown" when no pattern matches', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = inferArchitecture('/test/project');
+            expect(result).toContain('unknown');
+        });
+        it('should return multiple patterns if project uses hybrid architecture', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                const pathStr = p.toString();
+                return pathStr.endsWith('packages') || pathStr.endsWith('models') || pathStr.endsWith('views') || pathStr.endsWith('controllers');
+            });
+            const result = inferArchitecture('/test/project');
+            expect(result.length).toBeGreaterThan(1);
+            expect(result).toContain('monorepo');
+            expect(result).toContain('mvc');
+        });
+    });
+    describe('detectLanguages', () => {
+        it('should detect TypeScript from .ts files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.TypeScript).toBeDefined();
+        });
+        it('should detect JavaScript from .js files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'app.js', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.JavaScript).toBeDefined();
+        });
+        it('should detect Python from .py files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'main.py', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.Python).toBeDefined();
+        });
+        it('should detect Go from .go files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'main.go', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.Go).toBeDefined();
+        });
+        it('should detect Rust from .rs files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'main.rs', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.Rust).toBeDefined();
+        });
+        it('should detect Ruby from .rb files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'app.rb', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.Ruby).toBeDefined();
+        });
+        it('should detect Java from .java files', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'Main.java', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.Java).toBeDefined();
+        });
+        it('should detect multiple languages in polyglot projects', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+                { name: 'main.py', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(Object.keys(result).length).toBeGreaterThan(1);
+        });
+        it('should return language usage percentage', () => {
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+                { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+                { name: 'main.py', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectLanguages('/test/project');
+            expect(result.TypeScript).toBeGreaterThan(0);
+            expect(result.TypeScript).toBeLessThanOrEqual(100);
+        });
+    });
+    describe('detectFrameworks', () => {
+        it('should detect React from package.json dependencies', () => {
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { react: '^18.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.frontend).toContain('React');
+        });
+        it('should detect Next.js from package.json dependencies', () => {
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { next: '^13.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.frontend).toContain('Next.js');
+        });
+        it('should detect Vue from package.json dependencies', () => {
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { vue: '^3.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.frontend).toContain('Vue');
+        });
+        it('should detect Express from package.json dependencies', () => {
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { express: '^4.18.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.backend).toContain('Express');
+        });
+        it('should detect Django from requirements.txt', () => {
+            const manifests = [{
+                    type: 'requirements.txt',
+                    path: '/test/requirements.txt',
+                    metadata: {},
+                    dependencies: { django: '4.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.backend).toContain('Django');
+        });
+        it('should detect Flask from requirements.txt', () => {
+            const manifests = [{
+                    type: 'requirements.txt',
+                    path: '/test/requirements.txt',
+                    metadata: {},
+                    dependencies: { flask: '2.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.backend).toContain('Flask');
+        });
+        it('should detect Spring Boot from pom.xml dependencies', () => {
+            const manifests = [{
+                    type: 'pom.xml',
+                    path: '/test/pom.xml',
+                    metadata: {},
+                    dependencies: { 'spring-boot-starter': '2.7.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.backend).toContain('Spring Boot');
+        });
+        it('should categorize frameworks as frontend or backend', () => {
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { react: '^18.0.0', express: '^4.18.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result.frontend).toContain('React');
+            expect(result.backend).toContain('Express');
+        });
+        it('should detect database drivers', () => {
+            // This test is for databases, which is handled separately in analyzeCodebase
+            // Just verify the function doesn't crash
+            const manifests = [{
+                    type: 'package.json',
+                    path: '/test/package.json',
+                    metadata: {},
+                    dependencies: { mongoose: '^6.0.0' },
+                }];
+            const result = detectFrameworks(manifests);
+            expect(result).toBeDefined();
+        });
+    });
+    describe('analyzeCodebase', () => {
+        it('should perform comprehensive analysis with all sub-functions', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ name: 'test' }));
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = analyzeCodebase('/test/project');
+            expect(result).toHaveProperty('languages');
+            expect(result).toHaveProperty('frameworks');
+            expect(result).toHaveProperty('databases');
+            expect(result).toHaveProperty('architecture');
+            expect(result).toHaveProperty('manifests');
+        });
+        it('should respect ignore files during analysis', () => {
+            // This would be tested by integration tests
+            // Unit test just verifies function exists
+            expect(analyzeCodebase).toBeDefined();
+        });
+        it('should use git ls-files when available for efficiency', () => {
+            // This would be tested by integration tests
+            expect(analyzeCodebase).toBeDefined();
+        });
+        it('should fallback to manual directory scanning when git not available', () => {
+            vi.mocked(execSync).mockImplementation(() => {
+                throw new Error('Git not available');
+            });
+            expect(analyzeCodebase).toBeDefined();
+        });
+        it('should handle large files (>1MB) by reading only first/last 20 lines', () => {
+            // This would be tested by integration tests with actual large files
+            expect(analyzeCodebase).toBeDefined();
+        });
+        it('should prioritize README.md analysis', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('README.md');
+            });
+            vi.mocked(fs.readFileSync).mockImplementation((p) => {
+                if (p.toString().endsWith('README.md')) {
+                    return '# Test Project\n\nThis is a test project description';
+                }
+                return '';
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = analyzeCodebase('/test/project');
+            expect(result.projectGoal).toContain('test project');
+        });
+        it('should extract project goal from README or package.json description', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+                name: 'test',
+                description: 'A wonderful test project',
+            }));
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = analyzeCodebase('/test/project');
+            expect(result.projectGoal).toBe('A wonderful test project');
+        });
+        it('should return comprehensive analysis object', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
+                name: 'test',
+                dependencies: { react: '^18.0.0' },
+            }));
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = analyzeCodebase('/test/project');
+            expect(result.languages).toBeDefined();
+            expect(result.frameworks.frontend).toBeDefined();
+            expect(result.frameworks.backend).toBeDefined();
+            expect(result.databases).toBeDefined();
+            expect(result.architecture).toBeDefined();
+            expect(result.manifests).toBeDefined();
+        });
+    });
+});

package/dist/utils/configDetection.d.ts

@@ -1,10 +1,22 @@
 export type SynergyFramework = 'none' | 'oh-my-opencode' | 'oh-my-opencode-slim';
+/**
+ * Result of CDD configuration detection across multiple config files.
+ * Checks ~/.config/opencode/{opencode.json, oh-my-opencode.json, oh-my-opencode-slim.json}
+ */
 export interface ConfigDetectionResult {
+    /** Whether CDD agent is configured in opencode.json */
     hasCDDInOpenCode: boolean;
+    /** Whether CDD agent is configured in oh-my-opencode.json */
     hasCDDInOMO: boolean;
+    /** Whether CDD agent is configured in oh-my-opencode-slim.json */
+    hasCDDInSlim: boolean;
+    /** Whether synergy mode should be activated (true if any synergy framework detected) */
     synergyActive: boolean;
+    /** The CDD model string extracted from configs (priority: slim > OMO > opencode) */
     cddModel?: string;
+    /** Which synergy framework to use (priority: slim > OMO > none) */
     synergyFramework: SynergyFramework;
+    /** Available agents from slim config (filtered by disabled_agents) */
     slimAgents?: string[];
 }
 export declare function detectCDDConfig(): ConfigDetectionResult;

package/dist/utils/configDetection.js

@@ -8,6 +8,7 @@ export function detectCDDConfig() {
     const slimJsonPath = join(opencodeConfigDir, "oh-my-opencode-slim.json");
     let hasCDDInOpenCode = false;
     let hasCDDInOMO = false;
+    let hasCDDInSlim = false;
     let cddModel;
     let synergyFramework = 'none';
     let slimAgents;
@@ -17,8 +18,16 @@ export function detectCDDConfig() {
             const config = JSON.parse(readFileSync(slimJsonPath, "utf-8"));
             // Check if config is not empty and has actual content
             if (config && Object.keys(config).length > 0) {
-                synergyFramework = 'oh-my-opencode-slim';
-                // Extract available agents (filter out disabled ones)
+                // Check for CDD agent in slim config (strict detection)
+                if (config.agents && config.agents.cdd) {
+                    hasCDDInSlim = true;
+                    synergyFramework = 'oh-my-opencode-slim';
+                    // Extract model from slim config (priority over OMO and opencode.json)
+                    if (config.agents.cdd.model) {
+                        cddModel = config.agents.cdd.model;
+                    }
+                }
+                // Extract available agents (filter out disabled ones) regardless of CDD presence
                 const coreAgents = ['explorer', 'librarian', 'oracle', 'designer'];
                 const disabledAgents = new Set(config.disabled_agents ?? []);
                 slimAgents = coreAgents.filter(agent => !disabledAgents.has(agent));
@@ -28,15 +37,19 @@ export function detectCDDConfig() {
             // Silently fail on parse errors
         }
     }
-    // Check oh-my-opencode.json (only if slim is not active)
-    if (synergyFramework === 'none' && existsSync(omoJsonPath)) {
+    // 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"));
             if (config.agents && config.agents.cdd) {
                 hasCDDInOMO = true;
-                synergyFramework = 'oh-my-opencode';
-                // Extract model from oh-my-opencode.json
-                if (config.agents.cdd.model) {
+                // Only activate OMO synergy if slim doesn't have CDD (slim takes priority)
+                if (synergyFramework === 'none') {
+                    synergyFramework = 'oh-my-opencode';
+                }
+                // Extract model from oh-my-opencode.json (only if not already set by slim)
+                if (!cddModel && config.agents.cdd.model) {
                     cddModel = config.agents.cdd.model;
                 }
             }
@@ -45,13 +58,13 @@ export function detectCDDConfig() {
             // Silently fail on parse errors
         }
     }
-    // Check opencode.json (fallback if model not found in OMO)
+    // Check opencode.json (fallback if model not found in slim or OMO)
     if (existsSync(opencodeJsonPath)) {
         try {
             const config = JSON.parse(readFileSync(opencodeJsonPath, "utf-8"));
             if (config.agent && config.agent.cdd) {
                 hasCDDInOpenCode = true;
-                // Only use this model if we didn't find one in oh-my-opencode.json
+                // Only use this model if we didn't find one in slim or oh-my-opencode.json
                 if (!cddModel && config.agent.cdd.model) {
                     cddModel = config.agent.cdd.model;
                 }
@@ -64,6 +77,7 @@ export function detectCDDConfig() {
     return {
         hasCDDInOpenCode,
         hasCDDInOMO,
+        hasCDDInSlim,
         synergyActive: synergyFramework !== 'none',
         cddModel,
         synergyFramework,