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

package/dist/utils/autogenerateFlow.test.js

@@ -0,0 +1,610 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createInitialState, generateContentForSection, validateContent, handleAccept, handleEdit, handleRegenerate, formatPresentationPrompt, formatEditPrompt, formatRegeneratePrompt, formatMaxAttemptsPrompt, parseUserChoice, isCancel, MAX_REGENERATION_ATTEMPTS, MIN_CONTEXT_SIGNALS, evaluateContextSufficiency, evaluateAmbiguity, formatFallbackPrompt, formatAutogenerationFailure, parseFallbackChoice, resolveFallbackAction, handleFallbackManual, handleFallbackAcceptPartial, handleFallbackRegenerate, } from './autogenerateFlow.js';
+describe('autogenerateFlow', () => {
+    let mockContext;
+    let initialState;
+    beforeEach(() => {
+        mockContext = {
+            raw: {
+                manifests: [
+                    {
+                        type: 'npm',
+                        dependencies: ['express'],
+                        devDependencies: ['jest'],
+                        scripts: { test: 'jest' },
+                    },
+                ],
+                docs: [
+                    {
+                        filename: 'README.md',
+                        content: 'Test project for unit testing',
+                    },
+                ],
+                git: {
+                    commitCount: 50,
+                    conventionalCommits: 45,
+                    patterns: ['feat:', 'fix:'],
+                    warnings: [],
+                },
+                structure: {
+                    structure: ['src/', 'src/index.ts'],
+                    fileExtensions: ['.ts', '.js'],
+                    warnings: [],
+                },
+                ignores: { patterns: ['node_modules/', '*.log'] },
+                cicd: [],
+            },
+            insights: {
+                techStack: {
+                    languages: [{ name: 'JavaScript', confidence: 0.9, percentage: 100 }],
+                    frameworks: [{ name: 'Express', version: '^4.18.0', confidence: 0.9 }],
+                    databases: [],
+                    infrastructure: [],
+                    testing: [{ framework: 'Jest', confidence: 0.9 }],
+                },
+                product: {
+                    targetUsers: ['developers'],
+                    coreProblems: ['testing'],
+                    keyFeatures: ['testing framework'],
+                    confidence: 0.8,
+                },
+                workflow: {
+                    commitConvention: 'conventional',
+                    testingStrategy: 'TDD with Jest',
+                    branchStrategy: 'git-flow',
+                    confidence: 0.85,
+                },
+                projectType: 'application',
+                maturity: 'active',
+            },
+            meta: {
+                analyzedAt: new Date().toISOString(),
+                analysisTimeMs: 100,
+                filesAnalyzed: 10,
+                categoriesCompleted: ['manifests', 'docs', 'git'],
+                warnings: [],
+            },
+        };
+        initialState = createInitialState('2.1_product_guide');
+    });
+    describe('createInitialState', () => {
+        it('should create initial state with correct defaults', () => {
+            const state = createInitialState('test_question');
+            expect(state.questionId).toBe('test_question');
+            expect(state.attemptNumber).toBe(1);
+            expect(state.status).toBe('generating');
+            expect(state.content).toBe('');
+            expect(state.userChoice).toBeNull();
+            expect(state.guidanceHistory).toEqual([]);
+            expect(state.editHistory).toEqual([]);
+            expect(state.timestamp).toBeTruthy();
+        });
+    });
+    describe('generateContentForSection', () => {
+        it('should generate content for product_guide section', () => {
+            const result = generateContentForSection('product_guide', mockContext);
+            expect(result.success).toBe(true);
+            expect(result.content).toBeTruthy();
+            expect(result.error).toBeUndefined();
+        });
+        it('should report failure when confidence below threshold', () => {
+            const lowConfidenceContext = {
+                ...mockContext,
+                insights: {
+                    ...mockContext.insights,
+                    techStack: {
+                        ...mockContext.insights.techStack,
+                        frameworks: [],
+                        testing: [],
+                    },
+                    workflow: {
+                        ...mockContext.insights.workflow,
+                        testingStrategy: 'unknown',
+                        commitConvention: 'none',
+                    },
+                },
+                raw: {
+                    ...mockContext.raw,
+                    docs: [],
+                    cicd: [],
+                    manifests: [],
+                    git: {
+                        commitCount: 0,
+                        conventionalCommits: 0,
+                        patterns: [],
+                        warnings: [],
+                    },
+                    structure: {
+                        structure: [],
+                        fileExtensions: [],
+                        warnings: [],
+                    },
+                },
+            };
+            const result = generateContentForSection('workflow', lowConfidenceContext);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('Insufficient context');
+            expect(result.failureSummary).toContain('Autogeneration failed');
+            expect(result.fallbackPrompt).toContain('Continue with manual Q&A');
+            expect(result.fallbackState?.sufficient).toBe(false);
+        });
+        it('should generate content for product_guidelines section', () => {
+            const result = generateContentForSection('product_guidelines', mockContext);
+            expect(result.success).toBe(true);
+            expect(result.content).toBeTruthy();
+        });
+        it('should generate content for tech_stack section', () => {
+            const result = generateContentForSection('tech_stack', mockContext);
+            expect(result.success).toBe(true);
+            expect(result.content).toBeTruthy();
+            expect(result.content).toContain('JavaScript');
+        });
+        it('should generate content for workflow section', () => {
+            const result = generateContentForSection('workflow', mockContext);
+            expect(result.success).toBe(true);
+            expect(result.content).toBeTruthy();
+        });
+        it('should reject low confidence context during generation', () => {
+            const lowConfidenceContext = {
+                ...mockContext,
+                insights: {
+                    ...mockContext.insights,
+                    product: {
+                        ...mockContext.insights.product,
+                        confidence: 0.3,
+                    },
+                    workflow: {
+                        ...mockContext.insights.workflow,
+                        confidence: 0.3,
+                    },
+                    techStack: {
+                        ...mockContext.insights.techStack,
+                        frameworks: [],
+                        languages: [],
+                    },
+                },
+                raw: {
+                    ...mockContext.raw,
+                    docs: [],
+                    cicd: [],
+                    manifests: [],
+                    git: {
+                        commitCount: 0,
+                        conventionalCommits: 0,
+                        patterns: [],
+                        warnings: [],
+                    },
+                    structure: {
+                        structure: [],
+                        fileExtensions: [],
+                        warnings: [],
+                    },
+                },
+            };
+            const result = generateContentForSection('product_guide', lowConfidenceContext);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('Insufficient context');
+            expect(result.fallbackPrompt).toContain('Provide more context');
+            expect(result.ambiguityState?.ambiguous).toBe(true);
+        });
+    });
+    describe('validateContent', () => {
+        describe('product_guide validation', () => {
+            it('should accept valid product guide content', () => {
+                const result = validateContent('This is a developer tool for managing project specifications', 'product_guide');
+                expect(result.valid).toBe(true);
+            });
+            it('should reject empty content', () => {
+                const result = validateContent('', 'product_guide');
+                expect(result.valid).toBe(false);
+                expect(result.error).toContain('cannot be empty');
+            });
+            it('should reject content shorter than 20 characters', () => {
+                const result = validateContent('Too short', 'product_guide');
+                expect(result.valid).toBe(false);
+                expect(result.error).toContain('at least 20 characters');
+            });
+            it('should reject incoherent content', () => {
+                const result = validateContent('xx yy zz aa bb cc dd ee', 'product_guide');
+                expect(result.valid).toBe(false);
+                expect(result.error).toContain('coherent text');
+            });
+        });
+        describe('tech_stack validation', () => {
+            it('should accept valid tech stack', () => {
+                const result = validateContent('Node.js, TypeScript, Express', 'tech_stack');
+                expect(result.valid).toBe(true);
+            });
+            it('should reject very short tech stack', () => {
+                const result = validateContent('JS', 'tech_stack');
+                expect(result.valid).toBe(false);
+            });
+        });
+        describe('workflow validation', () => {
+            it('should accept valid workflow', () => {
+                const result = validateContent('We use TDD with Jest and conventional commits', 'workflow');
+                expect(result.valid).toBe(true);
+            });
+            it('should reject workflow shorter than 30 characters', () => {
+                const result = validateContent('We use TDD', 'workflow');
+                expect(result.valid).toBe(false);
+                expect(result.error).toContain('at least 30 characters');
+            });
+        });
+    });
+    describe('handleAccept', () => {
+        it('should accept valid content', () => {
+            const state = {
+                ...initialState,
+                content: 'A valid product guide description with sufficient length',
+            };
+            const result = handleAccept(state, 'product_guide');
+            expect(result.success).toBe(true);
+            expect(result.content).toBe(state.content);
+            expect(result.state?.status).toBe('accepted');
+            expect(result.state?.userChoice).toBe('A');
+        });
+        it('should reject invalid content', () => {
+            const state = {
+                ...initialState,
+                content: 'Too short',
+            };
+            const result = handleAccept(state, 'product_guide');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeTruthy();
+        });
+    });
+    describe('handleEdit', () => {
+        it('should accept valid edited content', () => {
+            const editedContent = 'This is the user edited version with enough length';
+            const result = handleEdit(initialState, editedContent, 'product_guide');
+            expect(result.success).toBe(true);
+            expect(result.content).toBe(editedContent);
+            expect(result.state?.status).toBe('edited');
+            expect(result.state?.userChoice).toBe('B');
+            expect(result.state?.editHistory).toContain(editedContent);
+        });
+        it('should reject invalid edited content', () => {
+            const result = handleEdit(initialState, 'Short', 'product_guide');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeTruthy();
+        });
+        it('should track edit history', () => {
+            const edit1 = 'First edit with sufficient length for validation';
+            const edit2 = 'Second edit also with sufficient length for validation';
+            const result1 = handleEdit(initialState, edit1, 'product_guide');
+            expect(result1.success).toBe(true);
+            const result2 = handleEdit(result1.state, edit2, 'product_guide');
+            expect(result2.success).toBe(true);
+            expect(result2.state?.editHistory).toEqual([edit1, edit2]);
+        });
+    });
+    describe('handleRegenerate', () => {
+        it('should regenerate content with valid guidance', () => {
+            const state = {
+                ...initialState,
+                content: 'Original content',
+            };
+            const result = handleRegenerate(state, 'Focus more on developers', 'product_guide', mockContext);
+            expect(result.success).toBe(true);
+            expect(result.content).toBeTruthy();
+            expect(result.state?.status).toBe('presented');
+            expect(result.state?.userChoice).toBe('C');
+            expect(result.state?.attemptNumber).toBe(2);
+            expect(result.state?.guidanceHistory).toContain('Focus more on developers');
+        });
+        it('should reject guidance that is too short', () => {
+            const result = handleRegenerate(initialState, 'ok', 'product_guide', mockContext);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('at least 5 characters');
+        });
+        it('should enforce maximum regeneration attempts', () => {
+            let state = initialState;
+            state.attemptNumber = MAX_REGENERATION_ATTEMPTS;
+            const result = handleRegenerate(state, 'Some valid guidance', 'product_guide', mockContext);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('Maximum regeneration attempts');
+        });
+        it('should track guidance history', () => {
+            let state = initialState;
+            const guidance1 = 'Focus on developers';
+            const result1 = handleRegenerate(state, guidance1, 'product_guide', mockContext);
+            expect(result1.success).toBe(true);
+            state = result1.state;
+            const guidance2 = 'Be more specific';
+            const result2 = handleRegenerate(state, guidance2, 'product_guide', mockContext);
+            expect(result2.success).toBe(true);
+            expect(result2.state?.guidanceHistory).toEqual([guidance1, guidance2]);
+        });
+    });
+    describe('formatPresentationPrompt', () => {
+        it('should format presentation prompt correctly', () => {
+            const content = 'Test content';
+            const prompt = formatPresentationPrompt(content);
+            expect(prompt).toContain('autogenerated the following content');
+            expect(prompt).toContain(content);
+            expect(prompt).toContain('A) Accept');
+            expect(prompt).toContain('B) Edit');
+            expect(prompt).toContain('C) Regenerate');
+        });
+    });
+    describe('formatEditPrompt', () => {
+        it('should format edit prompt correctly', () => {
+            const content = 'Original content';
+            const prompt = formatEditPrompt(content);
+            expect(prompt).toContain('You selected Edit');
+            expect(prompt).toContain(content);
+            expect(prompt).toContain('cancel');
+        });
+    });
+    describe('formatRegeneratePrompt', () => {
+        it('should format regenerate prompt correctly', () => {
+            const prompt = formatRegeneratePrompt();
+            expect(prompt).toContain('You selected Regenerate');
+            expect(prompt).toContain('provide guidance');
+            expect(prompt).toContain('cancel');
+        });
+    });
+    describe('formatMaxAttemptsPrompt', () => {
+        it('should format max attempts prompt correctly', () => {
+            const prompt = formatMaxAttemptsPrompt();
+            expect(prompt).toContain('regenerated content 3 times');
+            expect(prompt).toContain('A) Accept');
+            expect(prompt).toContain('B) Edit');
+            expect(prompt).toContain('C) Switch to manual Q&A');
+        });
+    });
+    describe('evaluateContextSufficiency', () => {
+        it('should report sufficient context with multiple signals', () => {
+            const result = evaluateContextSufficiency(mockContext);
+            expect(result.sufficient).toBe(true);
+            expect(result.reason).toContain('context sources');
+            expect(result.missing.length).toBeLessThan(6);
+        });
+        it('should report insufficient context with minimal signals', () => {
+            const minimalContext = {
+                ...mockContext,
+                raw: {
+                    ...mockContext.raw,
+                    manifests: [],
+                    docs: [],
+                    git: { ...mockContext.raw.git, commitCount: 0 },
+                    structure: { ...mockContext.raw.structure, structure: [] },
+                    ignores: { patterns: [] },
+                    cicd: [],
+                },
+                meta: {
+                    ...mockContext.meta,
+                    warnings: [
+                        'No manifest files found',
+                        'No README found',
+                        'Not a git repository',
+                    ],
+                },
+            };
+            const result = evaluateContextSufficiency(minimalContext);
+            expect(result.sufficient).toBe(false);
+            expect(result.reason).toContain('Not enough project context');
+            expect(result.missing.length).toBeGreaterThanOrEqual(MIN_CONTEXT_SIGNALS);
+        });
+    });
+    describe('evaluateAmbiguity', () => {
+        it('should detect ambiguous contexts', () => {
+            const ambiguousContext = {
+                ...mockContext,
+                insights: {
+                    ...mockContext.insights,
+                    projectType: 'unknown',
+                    techStack: { ...mockContext.insights.techStack, languages: [] },
+                },
+                meta: {
+                    ...mockContext.meta,
+                    filesAnalyzed: 0,
+                    warnings: ['No manifest files found', 'No README found'],
+                },
+            };
+            const result = evaluateAmbiguity(ambiguousContext);
+            expect(result.ambiguous).toBe(true);
+            expect(result.signals.length).toBeGreaterThan(0);
+        });
+    });
+    describe('formatFallbackPrompt', () => {
+        it('should include reason and missing data', () => {
+            const prompt = formatFallbackPrompt('Insufficient context', ['manifests']);
+            expect(prompt).toContain('Insufficient context');
+            expect(prompt).toContain('Missing: manifests');
+            expect(prompt).toContain('A) Continue with manual Q&A');
+        });
+    });
+    describe('formatAutogenerationFailure', () => {
+        it('should format a detailed failure summary', () => {
+            const sufficiency = {
+                sufficient: false,
+                reason: 'Not enough project context sources',
+                missing: ['docs'],
+            };
+            const ambiguity = {
+                ambiguous: true,
+                reason: 'Context ambiguous',
+                signals: ['Missing README'],
+            };
+            const message = formatAutogenerationFailure('product_guide', 'Insufficient context', sufficiency, ambiguity);
+            expect(message).toContain('Autogeneration failed');
+            expect(message).toContain('Insufficient context');
+            expect(message).toContain('Missing: docs');
+            expect(message).toContain('Ambiguity signals');
+        });
+    });
+    describe('parseFallbackChoice', () => {
+        it('should parse manual choice', () => {
+            expect(parseFallbackChoice('A')).toBe('A');
+            expect(parseFallbackChoice('manual')).toBe('A');
+            expect(parseFallbackChoice('m')).toBe('A');
+        });
+        it('should parse regenerate choice', () => {
+            expect(parseFallbackChoice('B')).toBe('B');
+            expect(parseFallbackChoice('regenerate')).toBe('B');
+            expect(parseFallbackChoice('context')).toBe('B');
+        });
+        it('should parse accept partial choice', () => {
+            expect(parseFallbackChoice('C')).toBe('C');
+            expect(parseFallbackChoice('partial')).toBe('C');
+            expect(parseFallbackChoice('accept')).toBe('C');
+        });
+        it('should reject invalid fallback choices', () => {
+            expect(parseFallbackChoice('D')).toBeNull();
+            expect(parseFallbackChoice('')).toBeNull();
+        });
+    });
+    describe('resolveFallbackAction', () => {
+        it('should resolve manual action', () => {
+            expect(resolveFallbackAction('A')).toBe('manual');
+            expect(resolveFallbackAction(null)).toBe('manual');
+        });
+        it('should resolve regenerate action', () => {
+            expect(resolveFallbackAction('B')).toBe('regenerate');
+        });
+        it('should resolve accept partial action', () => {
+            expect(resolveFallbackAction('C')).toBe('accept_partial');
+        });
+    });
+    describe('parseUserChoice', () => {
+        it('should parse Accept choices', () => {
+            expect(parseUserChoice('A')).toBe('A');
+            expect(parseUserChoice('a')).toBe('A');
+            expect(parseUserChoice('Accept')).toBe('A');
+            expect(parseUserChoice('accept')).toBe('A');
+            expect(parseUserChoice('yes')).toBe('A');
+            expect(parseUserChoice('y')).toBe('A');
+            expect(parseUserChoice(' A ')).toBe('A');
+        });
+        it('should parse Edit choices', () => {
+            expect(parseUserChoice('B')).toBe('B');
+            expect(parseUserChoice('b')).toBe('B');
+            expect(parseUserChoice('Edit')).toBe('B');
+            expect(parseUserChoice('edit')).toBe('B');
+            expect(parseUserChoice('e')).toBe('B');
+        });
+        it('should parse Regenerate choices', () => {
+            expect(parseUserChoice('C')).toBe('C');
+            expect(parseUserChoice('c')).toBe('C');
+            expect(parseUserChoice('Regenerate')).toBe('C');
+            expect(parseUserChoice('regenerate')).toBe('C');
+            expect(parseUserChoice('r')).toBe('C');
+        });
+        it('should return null for invalid choices', () => {
+            expect(parseUserChoice('D')).toBeNull();
+            expect(parseUserChoice('invalid')).toBeNull();
+            expect(parseUserChoice('123')).toBeNull();
+            expect(parseUserChoice('')).toBeNull();
+        });
+    });
+    describe('isCancel', () => {
+        it('should detect cancel command', () => {
+            expect(isCancel('cancel')).toBe(true);
+            expect(isCancel('Cancel')).toBe(true);
+            expect(isCancel('CANCEL')).toBe(true);
+            expect(isCancel(' cancel ')).toBe(true);
+        });
+        it('should return false for non-cancel input', () => {
+            expect(isCancel('A')).toBe(false);
+            expect(isCancel('no')).toBe(false);
+            expect(isCancel('back')).toBe(false);
+            expect(isCancel('')).toBe(false);
+        });
+    });
+    describe('Fallback Handlers', () => {
+        describe('handleFallbackManual', () => {
+            it('should return failure with manual fallback action', () => {
+                const result = handleFallbackManual('product_guide', 'Insufficient context');
+                expect(result.success).toBe(false);
+                expect(result.error).toContain('Fallback to manual Q&A');
+                expect(result.error).toContain('Insufficient context');
+                expect(result.fallbackAction).toBe('manual');
+            });
+        });
+        describe('handleFallbackAcceptPartial', () => {
+            it('should accept valid partial content', () => {
+                const partialContent = 'This is a partial product description with limited details';
+                const result = handleFallbackAcceptPartial(partialContent, 'product_guide', 'Low confidence generation');
+                expect(result.success).toBe(true);
+                expect(result.content).toBe(partialContent);
+                expect(result.fallbackAction).toBe('accept_partial');
+            });
+            it('should reject invalid partial content and fall back to manual', () => {
+                const invalidContent = 'xyz';
+                const result = handleFallbackAcceptPartial(invalidContent, 'product_guide', 'Low confidence');
+                expect(result.success).toBe(false);
+                expect(result.error).toContain('Partial content is invalid');
+                expect(result.fallbackAction).toBe('manual');
+            });
+            it('should reject empty partial content', () => {
+                const result = handleFallbackAcceptPartial('', 'product_guide', 'Empty generation');
+                expect(result.success).toBe(false);
+                expect(result.error).toContain('Partial content is invalid');
+                expect(result.fallbackAction).toBe('manual');
+            });
+        });
+        describe('handleFallbackRegenerate', () => {
+            it('should regenerate content with updated context', () => {
+                const result = handleFallbackRegenerate('product_guide', mockContext, 'Focus on developer tooling aspect');
+                expect(result.success).toBe(true);
+                expect(result.content).toBeTruthy();
+            });
+            it('should fail regeneration with insufficient context', () => {
+                const minimalContext = {
+                    raw: {
+                        manifests: [],
+                        docs: [],
+                        cicd: [],
+                        ignores: { patterns: [] },
+                        git: {
+                            commitCount: 0,
+                            conventionalCommits: 0,
+                            patterns: [],
+                            warnings: [],
+                        },
+                        structure: {
+                            structure: [],
+                            fileExtensions: [],
+                            warnings: [],
+                        },
+                    },
+                    insights: {
+                        techStack: {
+                            languages: [],
+                            frameworks: [],
+                            databases: [],
+                            infrastructure: [],
+                            testing: [],
+                        },
+                        product: {
+                            targetUsers: [],
+                            coreProblems: [],
+                            keyFeatures: [],
+                            confidence: 0.0,
+                        },
+                        workflow: {
+                            commitConvention: 'none',
+                            testingStrategy: 'unknown',
+                            branchStrategy: 'unknown',
+                            confidence: 0.0,
+                        },
+                        projectType: 'unknown',
+                        maturity: 'early',
+                    },
+                    meta: {
+                        analyzedAt: new Date().toISOString(),
+                        analysisTimeMs: 0,
+                        filesAnalyzed: 0,
+                        categoriesCompleted: [],
+                        warnings: [],
+                    },
+                };
+                const result = handleFallbackRegenerate('workflow', minimalContext, 'Please add more workflow details');
+                expect(result.success).toBe(false);
+                expect(result.error).toContain('Insufficient context');
+            });
+        });
+    });
+});

package/dist/utils/bootstrap.d.ts

@@ -0,0 +1 @@
+export declare function bootstrap(ctx: any): Promise<void>;

package/dist/utils/bootstrap.js

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, copyFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function bootstrap(ctx) {
+    const opencodeConfigDir = join(homedir(), ".config", "opencode");
+    const targetAgentDir = join(opencodeConfigDir, "agent");
+    const targetCommandDir = join(opencodeConfigDir, "command");
+    const sourcePromptsDir = join(__dirname, "../prompts");
+    const sourceAgentFile = join(sourcePromptsDir, "agent/cdd.md");
+    const sourceCommandsDir = join(sourcePromptsDir, "commands");
+    let installedAnything = false;
+    // 1. Ensure directories exist
+    if (!existsSync(targetAgentDir))
+        mkdirSync(targetAgentDir, { recursive: true });
+    if (!existsSync(targetCommandDir))
+        mkdirSync(targetCommandDir, { recursive: true });
+    // 2. Install/Update Agent
+    const targetAgentFile = join(targetAgentDir, "cdd.md");
+    if (existsSync(sourceAgentFile)) {
+        copyFileSync(sourceAgentFile, targetAgentFile);
+        installedAnything = true;
+    }
+    // 3. Install/Update Commands
+    if (existsSync(sourceCommandsDir)) {
+        const commands = readdirSync(sourceCommandsDir);
+        for (const cmdFile of commands) {
+            const targetCmdFile = join(targetCommandDir, cmdFile);
+            copyFileSync(join(sourceCommandsDir, cmdFile), targetCmdFile);
+            installedAnything = true;
+        }
+    }
+    if (installedAnything) {
+        // Do not await toasts during bootstrapping as the TUI might not be ready
+        ctx.client.tui.showToast({
+            body: {
+                title: "Conductor CDD",
+                message: "First-run setup: CDD agent and commands installed globally. Please restart OpenCode to enable slash commands.",
+                variant: "info",
+                duration: 5000
+            }
+        }).catch(() => { });
+    }
+}

package/dist/utils/commandFactory.d.ts

@@ -0,0 +1,11 @@
+import { type PluginInput } from "@opencode-ai/plugin";
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+interface CDDCommandConfig {
+    name: string;
+    description: string;
+    args: Record<string, any>;
+    requiresSetup?: boolean;
+    additionalContext?: (ctx: PluginInput, args: any) => Promise<Record<string, string>>;
+}
+export declare function createCDDCommand(config: CDDCommandConfig): (ctx: PluginInput) => ToolDefinition;
+export {};