opencode-conductor-cdd-plugin 1.0.0-beta.13 → 1.0.0-beta.16

package/dist/utils/agentMapping.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest';
+import { resolveAgentName, getAgentMapping, isAgentAvailable } from './agentMapping.js';
+describe('Agent Mapping', () => {
+    describe('resolveAgentName', () => {
+        it('should map generic agent names to oh-my-opencode-slim agents', () => {
+            expect(resolveAgentName('explore', 'oh-my-opencode-slim')).toBe('explorer');
+            expect(resolveAgentName('frontend-ui-ux-engineer', 'oh-my-opencode-slim')).toBe('designer');
+            expect(resolveAgentName('document-writer', 'oh-my-opencode-slim')).toBe('librarian');
+            expect(resolveAgentName('oracle', 'oh-my-opencode-slim')).toBe('oracle');
+        });
+        it('should pass through oh-my-opencode-slim native agent names', () => {
+            expect(resolveAgentName('explorer', 'oh-my-opencode-slim')).toBe('explorer');
+            expect(resolveAgentName('designer', 'oh-my-opencode-slim')).toBe('designer');
+            expect(resolveAgentName('librarian', 'oh-my-opencode-slim')).toBe('librarian');
+        });
+        it('should return null for agents without slim equivalent', () => {
+            expect(resolveAgentName('sisyphus', 'oh-my-opencode-slim')).toBe(null);
+        });
+        it('should return null for unknown agent names in slim framework', () => {
+            expect(resolveAgentName('unknown-agent', 'oh-my-opencode-slim')).toBe(null);
+        });
+        it('should pass through agent names for oh-my-opencode framework', () => {
+            expect(resolveAgentName('sisyphus', 'oh-my-opencode')).toBe('sisyphus');
+            expect(resolveAgentName('oracle', 'oh-my-opencode')).toBe('oracle');
+            expect(resolveAgentName('explore', 'oh-my-opencode')).toBe('explore');
+        });
+        it('should return null when framework is none', () => {
+            expect(resolveAgentName('explore', 'none')).toBe(null);
+            expect(resolveAgentName('oracle', 'none')).toBe(null);
+        });
+    });
+    describe('getAgentMapping', () => {
+        it('should return the complete mapping for oh-my-opencode-slim', () => {
+            const mapping = getAgentMapping('oh-my-opencode-slim');
+            expect(mapping).toHaveProperty('explore', 'explorer');
+            expect(mapping).toHaveProperty('explorer', 'explorer');
+            expect(mapping).toHaveProperty('frontend-ui-ux-engineer', 'designer');
+            expect(mapping).toHaveProperty('designer', 'designer');
+            expect(mapping).toHaveProperty('document-writer', 'librarian');
+            expect(mapping).toHaveProperty('librarian', 'librarian');
+            expect(mapping).toHaveProperty('oracle', 'oracle');
+            expect(mapping).toHaveProperty('sisyphus', null);
+        });
+        it('should return identity mapping for oh-my-opencode', () => {
+            const mapping = getAgentMapping('oh-my-opencode');
+            // For oh-my-opencode, agent names pass through unchanged
+            expect(mapping).toEqual({});
+        });
+        it('should return empty mapping when framework is none', () => {
+            const mapping = getAgentMapping('none');
+            expect(mapping).toEqual({});
+        });
+    });
+    describe('isAgentAvailable', () => {
+        it('should return true if agent is in available list', () => {
+            const availableAgents = ['explorer', 'designer', 'librarian'];
+            expect(isAgentAvailable('explorer', availableAgents)).toBe(true);
+            expect(isAgentAvailable('designer', availableAgents)).toBe(true);
+        });
+        it('should return false if agent is not in available list', () => {
+            const availableAgents = ['explorer', 'designer'];
+            expect(isAgentAvailable('librarian', availableAgents)).toBe(false);
+            expect(isAgentAvailable('oracle', availableAgents)).toBe(false);
+        });
+        it('should return false for null agent name', () => {
+            const availableAgents = ['explorer', 'designer'];
+            expect(isAgentAvailable(null, availableAgents)).toBe(false);
+        });
+        it('should return false when available agents list is empty', () => {
+            expect(isAgentAvailable('explorer', [])).toBe(false);
+        });
+        it('should handle case-sensitive matching', () => {
+            const availableAgents = ['explorer', 'Designer'];
+            expect(isAgentAvailable('explorer', availableAgents)).toBe(true);
+            expect(isAgentAvailable('Explorer', availableAgents)).toBe(false);
+            expect(isAgentAvailable('Designer', availableAgents)).toBe(true);
+            expect(isAgentAvailable('designer', availableAgents)).toBe(false);
+        });
+    });
+});

package/dist/utils/configDetection.d.ts

@@ -1,7 +1,10 @@
+export type SynergyFramework = 'none' | 'oh-my-opencode' | 'oh-my-opencode-slim';
 export interface ConfigDetectionResult {
     hasCDDInOpenCode: boolean;
     hasCDDInOMO: boolean;
     synergyActive: boolean;
     cddModel?: string;
+    synergyFramework: SynergyFramework;
+    slimAgents?: string[];
 }
 export declare function detectCDDConfig(): ConfigDetectionResult;

package/dist/utils/configDetection.js

@@ -5,15 +5,36 @@ export function detectCDDConfig() {
     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");
     let hasCDDInOpenCode = false;
     let hasCDDInOMO = false;
     let cddModel;
-    // Check oh-my-opencode.json first (higher priority)
-    if (existsSync(omoJsonPath)) {
+    let synergyFramework = 'none';
+    let slimAgents;
+    // Check oh-my-opencode-slim.json first (highest priority for synergy)
+    if (existsSync(slimJsonPath)) {
+        try {
+            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)
+                const coreAgents = ['explorer', 'librarian', 'oracle', 'designer'];
+                const disabledAgents = new Set(config.disabled_agents ?? []);
+                slimAgents = coreAgents.filter(agent => !disabledAgents.has(agent));
+            }
+        }
+        catch (e) {
+            // Silently fail on parse errors
+        }
+    }
+    // Check oh-my-opencode.json (only if slim is not active)
+    if (synergyFramework === 'none' && 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) {
                     cddModel = config.agents.cdd.model;
@@ -43,7 +64,9 @@ export function detectCDDConfig() {
     return {
         hasCDDInOpenCode,
         hasCDDInOMO,
-        synergyActive: hasCDDInOMO,
+        synergyActive: synergyFramework !== 'none',
         cddModel,
+        synergyFramework,
+        slimAgents,
     };
 }

package/dist/utils/configDetection.test.js

@@ -11,6 +11,7 @@ vi.mock("os", () => ({
 describe("configDetection", () => {
     const opencodeJsonPath = "/home/user/.config/opencode/opencode.json";
     const omoJsonPath = "/home/user/.config/opencode/oh-my-opencode.json";
+    const slimJsonPath = "/home/user/.config/opencode/oh-my-opencode-slim.json";
     beforeEach(() => {
         vi.clearAllMocks();
     });
@@ -116,4 +117,90 @@ describe("configDetection", () => {
         expect(result.hasCDDInOMO).toBe(true);
         expect(result.cddModel).toBeUndefined();
     });
+    // New tests for oh-my-opencode-slim detection
+    describe("oh-my-opencode-slim detection", () => {
+        it("should detect oh-my-opencode-slim when only slim config is present", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: { designer: { model: "google/gemini-3-flash" } }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyActive).toBe(true);
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.slimAgents).toEqual(['explorer', 'librarian', 'oracle', 'designer']);
+        });
+        it("should prioritize oh-my-opencode-slim over oh-my-opencode when both present", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({ agents: {} });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({ agents: { cdd: { model: "model-from-omo" } } });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.synergyActive).toBe(true);
+        });
+        it("should filter out disabled agents from slim config", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        disabled_agents: ['oracle', 'designer']
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.slimAgents).toEqual(['explorer', 'librarian']);
+        });
+        it("should handle empty oh-my-opencode-slim config", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({});
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+        it("should fallback to oh-my-opencode when slim config is invalid", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return "invalid json";
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({ agents: { cdd: { model: "model-from-omo" } } });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyFramework).toBe('oh-my-opencode');
+            expect(result.hasCDDInOMO).toBe(true);
+        });
+        it("should handle malformed slim config gracefully", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    throw new Error("File read error");
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+    });
 });

package/dist/utils/synergyDelegation.d.ts

@@ -0,0 +1,33 @@
+import type { SynergyFramework } from './configDetection.js';
+/**
+ * Result of agent resolution for delegation
+ */
+export interface DelegationResult {
+    success: boolean;
+    resolvedAgent: string | null;
+    shouldFallback: boolean;
+    reason?: string;
+}
+/**
+ * Determine if delegation to synergy framework should occur
+ *
+ * @param framework - The active synergy framework
+ * @returns True if delegation should occur
+ */
+export declare function shouldDelegateToSynergy(framework: SynergyFramework): boolean;
+/**
+ * Get the delegation strategy file name based on active framework
+ *
+ * @param framework - The active synergy framework
+ * @returns Strategy file name ('delegate' or 'manual')
+ */
+export declare function getDelegationStrategy(framework: SynergyFramework): 'delegate' | 'manual';
+/**
+ * Resolve an agent name for delegation, handling mapping and availability
+ *
+ * @param requestedAgent - The agent name requested
+ * @param framework - The active synergy framework
+ * @param availableAgents - List of available agents in the framework
+ * @returns Delegation result with resolved agent or fallback info
+ */
+export declare function resolveAgentForDelegation(requestedAgent: string, framework: SynergyFramework, availableAgents: string[]): DelegationResult;

package/dist/utils/synergyDelegation.js

@@ -0,0 +1,65 @@
+import { resolveAgentName, isAgentAvailable } from './agentMapping.js';
+/**
+ * Determine if delegation to synergy framework should occur
+ *
+ * @param framework - The active synergy framework
+ * @returns True if delegation should occur
+ */
+export function shouldDelegateToSynergy(framework) {
+    return framework !== 'none';
+}
+/**
+ * Get the delegation strategy file name based on active framework
+ *
+ * @param framework - The active synergy framework
+ * @returns Strategy file name ('delegate' or 'manual')
+ */
+export function getDelegationStrategy(framework) {
+    return shouldDelegateToSynergy(framework) ? 'delegate' : 'manual';
+}
+/**
+ * Resolve an agent name for delegation, handling mapping and availability
+ *
+ * @param requestedAgent - The agent name requested
+ * @param framework - The active synergy framework
+ * @param availableAgents - List of available agents in the framework
+ * @returns Delegation result with resolved agent or fallback info
+ */
+export function resolveAgentForDelegation(requestedAgent, framework, availableAgents) {
+    // If no synergy framework active, must fallback
+    if (framework === 'none') {
+        return {
+            success: false,
+            resolvedAgent: null,
+            shouldFallback: true,
+            reason: 'No synergy framework active',
+        };
+    }
+    // Resolve the agent name through mapping
+    const resolvedAgent = resolveAgentName(requestedAgent, framework);
+    // If agent maps to null (no equivalent), must fallback
+    if (resolvedAgent === null) {
+        return {
+            success: false,
+            resolvedAgent: null,
+            shouldFallback: true,
+            reason: `Agent '${requestedAgent}' is not available in ${framework}`,
+        };
+    }
+    // Check if the resolved agent is actually available
+    const available = isAgentAvailable(resolvedAgent, availableAgents);
+    if (!available) {
+        return {
+            success: false,
+            resolvedAgent,
+            shouldFallback: true,
+            reason: `Agent '${resolvedAgent}' is disabled or not available in ${framework}`,
+        };
+    }
+    // Success! Agent can be delegated to
+    return {
+        success: true,
+        resolvedAgent,
+        shouldFallback: false,
+    };
+}

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

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

package/dist/utils/synergyDelegation.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { shouldDelegateToSynergy, getDelegationStrategy, resolveAgentForDelegation } from './synergyDelegation.js';
+describe('Synergy Delegation', () => {
+    beforeEach(() => {
+        // Clear any mocks
+        vi.clearAllMocks();
+    });
+    describe('shouldDelegateToSynergy', () => {
+        it('should return true when oh-my-opencode is active', () => {
+            const result = shouldDelegateToSynergy('oh-my-opencode');
+            expect(result).toBe(true);
+        });
+        it('should return true when oh-my-opencode-slim is active', () => {
+            const result = shouldDelegateToSynergy('oh-my-opencode-slim');
+            expect(result).toBe(true);
+        });
+        it('should return false when no synergy framework is active', () => {
+            const result = shouldDelegateToSynergy('none');
+            expect(result).toBe(false);
+        });
+    });
+    describe('getDelegationStrategy', () => {
+        it('should return delegate strategy for oh-my-opencode', () => {
+            const strategy = getDelegationStrategy('oh-my-opencode');
+            expect(strategy).toBe('delegate');
+        });
+        it('should return delegate strategy for oh-my-opencode-slim', () => {
+            const strategy = getDelegationStrategy('oh-my-opencode-slim');
+            expect(strategy).toBe('delegate');
+        });
+        it('should return manual strategy when no framework active', () => {
+            const strategy = getDelegationStrategy('none');
+            expect(strategy).toBe('manual');
+        });
+    });
+    describe('resolveAgentForDelegation', () => {
+        it('should resolve sisyphus to sisyphus for oh-my-opencode', () => {
+            const result = resolveAgentForDelegation('sisyphus', 'oh-my-opencode', ['sisyphus', 'oracle']);
+            expect(result.success).toBe(true);
+            expect(result.resolvedAgent).toBe('sisyphus');
+            expect(result.shouldFallback).toBe(false);
+        });
+        it('should resolve explore to explorer for oh-my-opencode-slim', () => {
+            const result = resolveAgentForDelegation('explore', 'oh-my-opencode-slim', ['explorer', 'designer']);
+            expect(result.success).toBe(true);
+            expect(result.resolvedAgent).toBe('explorer');
+            expect(result.shouldFallback).toBe(false);
+        });
+        it('should handle sisyphus mapping to null for slim (not available)', () => {
+            const result = resolveAgentForDelegation('sisyphus', 'oh-my-opencode-slim', ['explorer', 'designer']);
+            expect(result.success).toBe(false);
+            expect(result.resolvedAgent).toBe(null);
+            expect(result.shouldFallback).toBe(true);
+            expect(result.reason).toContain('not available');
+        });
+        it('should fallback when agent not in available list', () => {
+            const result = resolveAgentForDelegation('oracle', 'oh-my-opencode-slim', ['explorer', 'designer'] // oracle not in list
+            );
+            expect(result.success).toBe(false);
+            expect(result.shouldFallback).toBe(true);
+            expect(result.reason).toContain('disabled or not available');
+        });
+        it('should handle unknown agent names', () => {
+            const result = resolveAgentForDelegation('unknown-agent', 'oh-my-opencode-slim', ['explorer']);
+            expect(result.success).toBe(false);
+            expect(result.shouldFallback).toBe(true);
+        });
+        it('should return fallback when framework is none', () => {
+            const result = resolveAgentForDelegation('explore', 'none', []);
+            expect(result.success).toBe(false);
+            expect(result.shouldFallback).toBe(true);
+            expect(result.reason).toContain('No synergy framework');
+        });
+        it('should handle frontend-ui-ux-engineer mapping to designer', () => {
+            const result = resolveAgentForDelegation('frontend-ui-ux-engineer', 'oh-my-opencode-slim', ['designer', 'explorer']);
+            expect(result.success).toBe(true);
+            expect(result.resolvedAgent).toBe('designer');
+            expect(result.shouldFallback).toBe(false);
+        });
+        it('should pass through agent names for oh-my-opencode', () => {
+            const result = resolveAgentForDelegation('explore', // not a standard omo agent, but should pass through
+            'oh-my-opencode', ['explore', 'sisyphus']);
+            expect(result.success).toBe(true);
+            expect(result.resolvedAgent).toBe('explore');
+            expect(result.shouldFallback).toBe(false);
+        });
+    });
+});

package/dist/utils/synergyState.d.ts

@@ -0,0 +1,18 @@
+import { type SynergyFramework } from "./configDetection.js";
+export interface SynergyState {
+    framework: SynergyFramework;
+    detectedAt: Date;
+    availableAgents: string[];
+    lastCheck: Date;
+}
+/**
+ * Get the current synergy state, with caching
+ * @param workingDir - Current working directory
+ * @param forceRefresh - Force re-detection even if cache is valid
+ * @returns Current synergy state
+ */
+export declare function getSynergyState(workingDir: string, forceRefresh?: boolean): SynergyState;
+/**
+ * Clear the synergy state cache, forcing re-detection on next call
+ */
+export declare function clearSynergyCache(): void;

package/dist/utils/synergyState.js

@@ -0,0 +1,52 @@
+import { detectCDDConfig } from "./configDetection.js";
+// In-memory cache
+let synergyStateCache = null;
+let lastWorkingDir = null;
+// Cache TTL: 60 seconds
+const CACHE_TTL_MS = 60000;
+/**
+ * Get the current synergy state, with caching
+ * @param workingDir - Current working directory
+ * @param forceRefresh - Force re-detection even if cache is valid
+ * @returns Current synergy state
+ */
+export function getSynergyState(workingDir, forceRefresh = false) {
+    const now = Date.now();
+    // Return cached state if:
+    // 1. Not forcing refresh
+    // 2. Cache exists
+    // 3. Same working directory
+    // 4. Cache is still fresh (within TTL)
+    if (!forceRefresh &&
+        synergyStateCache &&
+        lastWorkingDir === workingDir &&
+        now - synergyStateCache.lastCheck.getTime() < CACHE_TTL_MS) {
+        return synergyStateCache;
+    }
+    // Perform detection
+    const detection = detectCDDConfig();
+    // Extract available agents based on framework
+    let availableAgents = [];
+    if (detection.synergyFramework === 'oh-my-opencode-slim' && detection.slimAgents) {
+        availableAgents = detection.slimAgents;
+    }
+    // Note: oh-my-opencode doesn't expose agent list through config detection,
+    // so we leave availableAgents empty for that framework
+    const state = {
+        framework: detection.synergyFramework,
+        detectedAt: new Date(),
+        availableAgents,
+        lastCheck: new Date(),
+    };
+    // Update cache
+    synergyStateCache = state;
+    lastWorkingDir = workingDir;
+    return state;
+}
+/**
+ * Clear the synergy state cache, forcing re-detection on next call
+ */
+export function clearSynergyCache() {
+    synergyStateCache = null;
+    lastWorkingDir = null;
+}

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

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