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

package/dist/utils/synergyState.test.js

@@ -0,0 +1,185 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { getSynergyState, clearSynergyCache } from "./synergyState.js";
+// Mock the configDetection module
+vi.mock("./configDetection.js", () => ({
+    detectCDDConfig: vi.fn(),
+}));
+import { detectCDDConfig } from "./configDetection.js";
+describe("synergyState", () => {
+    beforeEach(() => {
+        clearSynergyCache();
+        vi.clearAllMocks();
+    });
+    describe("getSynergyState", () => {
+        it("should detect and cache synergy state on first call", () => {
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer', 'librarian', 'oracle', 'designer'],
+            });
+            const state = getSynergyState("/test/dir");
+            expect(state.framework).toBe('oh-my-opencode-slim');
+            expect(state.availableAgents).toEqual(['explorer', 'librarian', 'oracle', 'designer']);
+            expect(detectCDDConfig).toHaveBeenCalledTimes(1);
+        });
+        it("should return cached state on subsequent calls with same directory", () => {
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer', 'librarian'],
+            });
+            const state1 = getSynergyState("/test/dir");
+            const state2 = getSynergyState("/test/dir");
+            expect(state1).toBe(state2); // Same object reference
+            expect(detectCDDConfig).toHaveBeenCalledTimes(1); // Only called once
+        });
+        it("should refresh state when working directory changes", () => {
+            vi.mocked(detectCDDConfig)
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer'],
+            })
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: true,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode',
+                cddModel: 'model-1',
+            });
+            const state1 = getSynergyState("/dir1");
+            const state2 = getSynergyState("/dir2");
+            expect(state1.framework).toBe('oh-my-opencode-slim');
+            expect(state2.framework).toBe('oh-my-opencode');
+            expect(detectCDDConfig).toHaveBeenCalledTimes(2);
+        });
+        it("should force refresh when forceRefresh is true", () => {
+            vi.mocked(detectCDDConfig)
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer'],
+            })
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode',
+                cddModel: 'model-changed',
+            });
+            const state1 = getSynergyState("/test/dir");
+            const state2 = getSynergyState("/test/dir", true); // Force refresh
+            expect(state1.framework).toBe('oh-my-opencode-slim');
+            expect(state2.framework).toBe('oh-my-opencode');
+            expect(detectCDDConfig).toHaveBeenCalledTimes(2);
+        });
+        it("should handle no synergy active", () => {
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: true,
+                hasCDDInOMO: false,
+                synergyActive: false,
+                synergyFramework: 'none',
+                cddModel: 'model-1',
+            });
+            const state = getSynergyState("/test/dir");
+            expect(state.framework).toBe('none');
+            expect(state.availableAgents).toEqual([]);
+        });
+        it("should refresh cache after TTL expires", () => {
+            vi.useFakeTimers();
+            vi.mocked(detectCDDConfig)
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer'],
+            })
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode',
+                cddModel: 'model-1',
+            });
+            const state1 = getSynergyState("/test/dir");
+            // Advance time by 61 seconds (TTL is 60 seconds)
+            vi.advanceTimersByTime(61000);
+            const state2 = getSynergyState("/test/dir");
+            expect(state1.framework).toBe('oh-my-opencode-slim');
+            expect(state2.framework).toBe('oh-my-opencode');
+            expect(detectCDDConfig).toHaveBeenCalledTimes(2);
+            vi.useRealTimers();
+        });
+        it("should include detection timestamp", () => {
+            const beforeTime = Date.now();
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: false,
+                synergyFramework: 'none',
+            });
+            const state = getSynergyState("/test/dir");
+            const afterTime = Date.now();
+            expect(state.detectedAt.getTime()).toBeGreaterThanOrEqual(beforeTime);
+            expect(state.detectedAt.getTime()).toBeLessThanOrEqual(afterTime);
+        });
+        it("should extract agents from oh-my-opencode-slim", () => {
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer', 'oracle'],
+            });
+            const state = getSynergyState("/test/dir");
+            expect(state.availableAgents).toEqual(['explorer', 'oracle']);
+        });
+        it("should handle oh-my-opencode framework", () => {
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: true,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode',
+                cddModel: 'model-1',
+            });
+            const state = getSynergyState("/test/dir");
+            expect(state.framework).toBe('oh-my-opencode');
+            // oh-my-opencode doesn't expose agent list through config, so availableAgents should be empty
+            expect(state.availableAgents).toEqual([]);
+        });
+    });
+    describe("clearSynergyCache", () => {
+        it("should clear the cache and force re-detection", () => {
+            vi.mocked(detectCDDConfig)
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer'],
+            })
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode',
+                cddModel: 'changed',
+            });
+            const state1 = getSynergyState("/test/dir");
+            clearSynergyCache();
+            const state2 = getSynergyState("/test/dir");
+            expect(state1.framework).toBe('oh-my-opencode-slim');
+            expect(state2.framework).toBe('oh-my-opencode');
+            expect(detectCDDConfig).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/dist/utils/synergyStatus.d.ts

@@ -0,0 +1,27 @@
+import type { SynergyFramework } from './configDetection.js';
+import type { SynergyState } from './synergyState.js';
+/**
+ * Synergy status information for display
+ */
+export interface SynergyStatus {
+    framework: SynergyFramework;
+    isActive: boolean;
+    availableAgents: string[];
+    workingDir: string;
+    detectedAt: Date;
+}
+/**
+ * Get synergy status for display
+ *
+ * @param workingDir - Current working directory
+ * @param state - Current synergy state
+ * @returns Status information
+ */
+export declare function getSynergyStatus(workingDir: string, state: SynergyState): SynergyStatus;
+/**
+ * Format synergy status for display
+ *
+ * @param status - Synergy status to format
+ * @returns Formatted status string
+ */
+export declare function formatSynergyStatus(status: SynergyStatus): string;

package/dist/utils/synergyStatus.js

@@ -0,0 +1,54 @@
+/**
+ * Get synergy status for display
+ *
+ * @param workingDir - Current working directory
+ * @param state - Current synergy state
+ * @returns Status information
+ */
+export function getSynergyStatus(workingDir, state) {
+    return {
+        framework: state.framework,
+        isActive: state.framework !== 'none',
+        availableAgents: state.availableAgents,
+        workingDir,
+        detectedAt: state.detectedAt,
+    };
+}
+/**
+ * Format synergy status for display
+ *
+ * @param status - Synergy status to format
+ * @returns Formatted status string
+ */
+export function formatSynergyStatus(status) {
+    const lines = [];
+    lines.push('='.repeat(60));
+    lines.push('Synergy Framework Status');
+    lines.push('='.repeat(60));
+    lines.push('');
+    // Framework and status
+    lines.push(`Synergy Framework: ${status.framework}`);
+    lines.push(`Status: ${status.isActive ? 'Active' : 'Inactive'}`);
+    lines.push('');
+    // Working directory
+    lines.push(`Working Directory: ${status.workingDir}`);
+    lines.push('');
+    // Detection timestamp
+    lines.push(`Detected At: ${status.detectedAt.toISOString()}`);
+    lines.push('');
+    // Available agents (only if active and has agents)
+    if (status.isActive && status.availableAgents.length > 0) {
+        lines.push(`Available Agents (${status.availableAgents.length}):`);
+        status.availableAgents.forEach(agent => {
+            lines.push(`  - ${agent}`);
+        });
+        lines.push('');
+    }
+    else if (!status.isActive) {
+        lines.push('No synergy framework detected.');
+        lines.push('Configure oh-my-opencode or oh-my-opencode-slim to enable synergy.');
+        lines.push('');
+    }
+    lines.push('='.repeat(60));
+    return lines.join('\n');
+}

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

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

package/dist/utils/synergyStatus.test.js

@@ -0,0 +1,143 @@
+import { describe, it, expect } from 'vitest';
+import { getSynergyStatus, formatSynergyStatus } from './synergyStatus.js';
+describe('Synergy Status', () => {
+    describe('getSynergyStatus', () => {
+        it('should return status with oh-my-opencode framework', () => {
+            const status = getSynergyStatus('/fake/dir', {
+                framework: 'oh-my-opencode',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+                availableAgents: [],
+                lastCheck: new Date('2026-01-19T14:00:00Z'),
+            });
+            expect(status.framework).toBe('oh-my-opencode');
+            expect(status.isActive).toBe(true);
+            expect(status.availableAgents).toEqual([]);
+            expect(status.detectedAt).toBeInstanceOf(Date);
+        });
+        it('should return status with oh-my-opencode-slim framework', () => {
+            const status = getSynergyStatus('/fake/dir', {
+                framework: 'oh-my-opencode-slim',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+                availableAgents: ['explorer', 'designer', 'librarian'],
+                lastCheck: new Date('2026-01-19T14:00:00Z'),
+            });
+            expect(status.framework).toBe('oh-my-opencode-slim');
+            expect(status.isActive).toBe(true);
+            expect(status.availableAgents).toHaveLength(3);
+            expect(status.availableAgents).toContain('explorer');
+        });
+        it('should return inactive status when no framework', () => {
+            const status = getSynergyStatus('/fake/dir', {
+                framework: 'none',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+                availableAgents: [],
+                lastCheck: new Date('2026-01-19T14:00:00Z'),
+            });
+            expect(status.framework).toBe('none');
+            expect(status.isActive).toBe(false);
+            expect(status.availableAgents).toEqual([]);
+        });
+        it('should include working directory in status', () => {
+            const workingDir = '/test/project';
+            const status = getSynergyStatus(workingDir, {
+                framework: 'oh-my-opencode-slim',
+                detectedAt: new Date(),
+                availableAgents: [],
+                lastCheck: new Date(),
+            });
+            expect(status.workingDir).toBe(workingDir);
+        });
+        it('should include detection timestamp', () => {
+            const detectedAt = new Date('2026-01-19T14:30:00Z');
+            const status = getSynergyStatus('/fake/dir', {
+                framework: 'oh-my-opencode',
+                detectedAt,
+                availableAgents: [],
+                lastCheck: new Date(),
+            });
+            expect(status.detectedAt).toBe(detectedAt);
+        });
+    });
+    describe('formatSynergyStatus', () => {
+        it('should format status for oh-my-opencode', () => {
+            const status = {
+                framework: 'oh-my-opencode',
+                isActive: true,
+                availableAgents: [],
+                workingDir: '/test/project',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('Synergy Framework: oh-my-opencode');
+            expect(formatted).toContain('Status: Active');
+            expect(formatted).toContain('Working Directory: /test/project');
+            expect(formatted).toContain('Detected At:');
+        });
+        it('should format status for oh-my-opencode-slim with agents', () => {
+            const status = {
+                framework: 'oh-my-opencode-slim',
+                isActive: true,
+                availableAgents: ['explorer', 'designer', 'librarian'],
+                workingDir: '/test/project',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('Synergy Framework: oh-my-opencode-slim');
+            expect(formatted).toContain('Status: Active');
+            expect(formatted).toContain('Available Agents (3):');
+            expect(formatted).toContain('- explorer');
+            expect(formatted).toContain('- designer');
+            expect(formatted).toContain('- librarian');
+        });
+        it('should format inactive status', () => {
+            const status = {
+                framework: 'none',
+                isActive: false,
+                availableAgents: [],
+                workingDir: '/test/project',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('Synergy Framework: none');
+            expect(formatted).toContain('Status: Inactive');
+            expect(formatted).toContain('No synergy framework detected');
+        });
+        it('should handle empty agents list for active framework', () => {
+            const status = {
+                framework: 'oh-my-opencode',
+                isActive: true,
+                availableAgents: [],
+                workingDir: '/test/project',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('oh-my-opencode');
+            expect(formatted).toContain('Active');
+            // Should not show agent list for oh-my-opencode (doesn't expose agents)
+            expect(formatted).not.toContain('Available Agents');
+        });
+        it('should format timestamps in readable format', () => {
+            const status = {
+                framework: 'oh-my-opencode-slim',
+                isActive: true,
+                availableAgents: [],
+                workingDir: '/test/project',
+                detectedAt: new Date('2026-01-19T14:30:45.123Z'),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('Detected At:');
+            expect(formatted).toMatch(/\d{4}-\d{2}-\d{2}/); // Should contain date
+        });
+        it('should show agent count correctly', () => {
+            const status = {
+                framework: 'oh-my-opencode-slim',
+                isActive: true,
+                availableAgents: ['explorer'],
+                workingDir: '/test/project',
+                detectedAt: new Date(),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('Available Agents (1):');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-conductor-cdd-plugin",
-  "version": "1.0.0-beta.13",
+  "version": "1.0.0-beta.16",
   "description": "Context-Driven Development (CDD) plugin for OpenCode - Transform your AI coding workflow with structured specifications, plans, and implementation tracking",
   "type": "module",
   "repository": {

package/scripts/postinstall.cjs

@@ -8,7 +8,7 @@ const targetAgentDir = path.join(opencodeConfigDir, 'agent');
 const targetCommandDir = path.join(opencodeConfigDir, 'command');
 
 const sourcePromptsDir = path.join(__dirname, '..', 'dist', 'prompts');
-const sourceAgentFile = path.join(sourcePromptsDir, 'agent', 'orchestrator.md');
+const sourceAgentFile = path.join(sourcePromptsDir, 'agent', 'cdd.md');
 const sourceCommandsDir = path.join(sourcePromptsDir, 'commands');
 
 function ensureDir(dir) {
@@ -22,8 +22,8 @@ try {
   ensureDir(targetCommandDir);
 
   if (fs.existsSync(sourceAgentFile)) {
-    fs.copyFileSync(sourceAgentFile, path.join(targetAgentDir, 'orchestrator.md'));
-    console.log('[Orchestrator] Installed agent definition.');
+    fs.copyFileSync(sourceAgentFile, path.join(targetAgentDir, 'cdd.md'));
+    console.log('[CDD] Installed agent definition.');
   }
 
   if (fs.existsSync(sourceCommandsDir)) {
@@ -31,8 +31,8 @@ try {
     for (const cmdFile of commands) {
       fs.copyFileSync(path.join(sourceCommandsDir, cmdFile), path.join(targetCommandDir, cmdFile));
     }
-    console.log('[Orchestrator] Installed slash commands.');
+    console.log('[CDD] Installed slash commands.');
   }
 } catch (err) {
-  console.error('[Orchestrator] Setup failed:', err.message);
+  console.error('[CDD] Setup failed:', err.message);
 }