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

package/dist/utils/interactiveMenu.test.js

@@ -0,0 +1,231 @@
+import { describe, it, expect } from 'vitest';
+import { renderMenu, validateSelection, parseSelection, formatQuestionWithOptions, } from './interactiveMenu.js';
+describe('interactiveMenu', () => {
+    describe('formatQuestionWithOptions', () => {
+        it('should format additive question with lettered options', () => {
+            const question = {
+                id: 'product-1',
+                text: 'What are the key features?',
+                type: 'additive',
+                section: 'product',
+                options: [
+                    'User authentication',
+                    'Real-time updates',
+                    'Data analytics',
+                    'Enter custom features',
+                    'Auto-generate from codebase',
+                ],
+            };
+            const result = formatQuestionWithOptions(question, 1);
+            expect(result).toContain('Question 1:');
+            expect(result).toContain('What are the key features? (Select all that apply)');
+            expect(result).toContain('A) User authentication');
+            expect(result).toContain('B) Real-time updates');
+            expect(result).toContain('C) Data analytics');
+            expect(result).toContain('D) Enter custom features');
+            expect(result).toContain('E) Auto-generate from codebase');
+        });
+        it('should format exclusive question without suffix', () => {
+            const question = {
+                id: 'product-2',
+                text: 'What is the primary platform?',
+                type: 'exclusive',
+                section: 'product',
+                options: ['Web', 'Mobile', 'Desktop', 'Custom', 'Auto-generate'],
+            };
+            const result = formatQuestionWithOptions(question, 2);
+            expect(result).toContain('Question 2:');
+            expect(result).toContain('What is the primary platform?');
+            expect(result).not.toContain('(Select all that apply)');
+            expect(result).toContain('A) Web');
+            expect(result).toContain('B) Mobile');
+        });
+        it('should truncate long options to 80 characters', () => {
+            const question = {
+                id: 'test-1',
+                text: 'Test question',
+                type: 'exclusive',
+                section: 'product',
+                options: [
+                    'This is a very long option text that exceeds the eighty character limit and should be truncated with ellipsis',
+                    'Short',
+                    'Custom',
+                    'Auto-generate',
+                    'Another option',
+                ],
+            };
+            const result = formatQuestionWithOptions(question, 1);
+            expect(result).toContain('A) This is a very long option text that exceeds the eighty character limit and...');
+            expect(result).toContain('B) Short');
+        });
+        it('should number questions starting from provided index', () => {
+            const question = {
+                id: 'test-1',
+                text: 'Test question',
+                type: 'exclusive',
+                section: 'product',
+                options: ['A', 'B', 'C', 'D', 'E'],
+            };
+            const result1 = formatQuestionWithOptions(question, 1);
+            const result5 = formatQuestionWithOptions(question, 5);
+            expect(result1).toContain('Question 1:');
+            expect(result5).toContain('Question 5:');
+        });
+    });
+    describe('validateSelection', () => {
+        it('should accept valid single letter for exclusive choice', () => {
+            expect(validateSelection('A', 'exclusive')).toBe(true);
+            expect(validateSelection('B', 'exclusive')).toBe(true);
+            expect(validateSelection('C', 'exclusive')).toBe(true);
+            expect(validateSelection('D', 'exclusive')).toBe(true);
+            expect(validateSelection('E', 'exclusive')).toBe(true);
+        });
+        it('should accept lowercase letters for exclusive choice', () => {
+            expect(validateSelection('a', 'exclusive')).toBe(true);
+            expect(validateSelection('e', 'exclusive')).toBe(true);
+        });
+        it('should reject invalid letters for exclusive choice', () => {
+            expect(validateSelection('F', 'exclusive')).toBe(false);
+            expect(validateSelection('Z', 'exclusive')).toBe(false);
+            expect(validateSelection('1', 'exclusive')).toBe(false);
+        });
+        it('should reject multiple selections for exclusive choice', () => {
+            expect(validateSelection('A,B', 'exclusive')).toBe(false);
+            expect(validateSelection('A,B,C', 'exclusive')).toBe(false);
+        });
+        it('should accept valid single letter for additive choice', () => {
+            expect(validateSelection('A', 'additive')).toBe(true);
+            expect(validateSelection('E', 'additive')).toBe(true);
+        });
+        it('should accept multiple comma-separated letters for additive choice', () => {
+            expect(validateSelection('A,B', 'additive')).toBe(true);
+            expect(validateSelection('A,B,C', 'additive')).toBe(true);
+            expect(validateSelection('A,C,D', 'additive')).toBe(true);
+        });
+        it('should accept multiple letters with spaces for additive choice', () => {
+            expect(validateSelection('A, B', 'additive')).toBe(true);
+            expect(validateSelection('A, B, C', 'additive')).toBe(true);
+            expect(validateSelection(' A , B , C ', 'additive')).toBe(true);
+        });
+        it('should reject if any letter is invalid in additive choice', () => {
+            expect(validateSelection('A,F', 'additive')).toBe(false);
+            expect(validateSelection('A,B,Z', 'additive')).toBe(false);
+            expect(validateSelection('A,1', 'additive')).toBe(false);
+        });
+        it('should reject duplicate selections in additive choice', () => {
+            expect(validateSelection('A,A', 'additive')).toBe(false);
+            expect(validateSelection('A,B,A', 'additive')).toBe(false);
+        });
+        it('should reject empty input', () => {
+            expect(validateSelection('', 'exclusive')).toBe(false);
+            expect(validateSelection('', 'additive')).toBe(false);
+            expect(validateSelection('   ', 'exclusive')).toBe(false);
+        });
+        it('should reject option E in combination with others for additive', () => {
+            expect(validateSelection('A,E', 'additive')).toBe(false);
+            expect(validateSelection('E,A', 'additive')).toBe(false);
+            expect(validateSelection('A,B,E', 'additive')).toBe(false);
+        });
+        it('should accept option E alone for additive', () => {
+            expect(validateSelection('E', 'additive')).toBe(true);
+        });
+    });
+    describe('parseSelection', () => {
+        it('should parse single exclusive selection', () => {
+            expect(parseSelection('A', 'exclusive')).toEqual(['A']);
+            expect(parseSelection('E', 'exclusive')).toEqual(['E']);
+        });
+        it('should normalize to uppercase', () => {
+            expect(parseSelection('a', 'exclusive')).toEqual(['A']);
+            expect(parseSelection('e', 'exclusive')).toEqual(['E']);
+        });
+        it('should parse single additive selection', () => {
+            expect(parseSelection('A', 'additive')).toEqual(['A']);
+        });
+        it('should parse multiple additive selections', () => {
+            expect(parseSelection('A,B', 'additive')).toEqual(['A', 'B']);
+            expect(parseSelection('A,B,C', 'additive')).toEqual(['A', 'B', 'C']);
+        });
+        it('should parse multiple selections with spaces', () => {
+            expect(parseSelection('A, B', 'additive')).toEqual(['A', 'B']);
+            expect(parseSelection(' A , B , C ', 'additive')).toEqual(['A', 'B', 'C']);
+        });
+        it('should parse lowercase multiple selections', () => {
+            expect(parseSelection('a,b,c', 'additive')).toEqual(['A', 'B', 'C']);
+        });
+        it('should return empty array for invalid input', () => {
+            expect(parseSelection('', 'exclusive')).toEqual([]);
+            expect(parseSelection('F', 'exclusive')).toEqual([]);
+            expect(parseSelection('A,F', 'additive')).toEqual([]);
+        });
+        it('should remove duplicates and sort for additive', () => {
+            expect(parseSelection('C,A,B', 'additive')).toEqual(['A', 'B', 'C']);
+            expect(parseSelection('B,A,C,A', 'additive')).toEqual(['A', 'B', 'C']);
+        });
+    });
+    describe('renderMenu', () => {
+        it('should render complete menu with instructions', () => {
+            const question = {
+                id: 'product-1',
+                text: 'What are the key features?',
+                type: 'additive',
+                section: 'product',
+                options: ['Auth', 'Real-time', 'Analytics', 'Custom', 'Auto-generate'],
+            };
+            const options = {
+                showInstructions: true,
+            };
+            const result = renderMenu(question, 1, options);
+            expect(result).toContain('Question 1:');
+            expect(result).toContain('What are the key features?');
+            expect(result).toContain('A) Auth');
+            expect(result).toContain('Instructions:');
+            expect(result).toContain('Enter your selection (e.g., "A,B,C" for multiple or "A" for single)');
+        });
+        it('should render menu without instructions when disabled', () => {
+            const question = {
+                id: 'product-1',
+                text: 'Test',
+                type: 'exclusive',
+                section: 'product',
+                options: ['A', 'B', 'C', 'D', 'E'],
+            };
+            const options = {
+                showInstructions: false,
+            };
+            const result = renderMenu(question, 1, options);
+            expect(result).not.toContain('Instructions:');
+        });
+        it('should include section-specific autogenerate text for option E', () => {
+            const productQuestion = {
+                id: 'product-1',
+                text: 'Test',
+                type: 'exclusive',
+                section: 'product',
+                options: ['A', 'B', 'C', 'D', 'Auto-generate product guide from codebase'],
+            };
+            const result = renderMenu(productQuestion, 1, { showInstructions: false });
+            expect(result).toContain('E) Auto-generate product guide from codebase');
+        });
+        it('should show different instructions for additive vs exclusive', () => {
+            const additiveQuestion = {
+                id: 'test-1',
+                text: 'Test additive',
+                type: 'additive',
+                section: 'product',
+                options: ['A', 'B', 'C', 'D', 'E'],
+            };
+            const exclusiveQuestion = {
+                id: 'test-2',
+                text: 'Test exclusive',
+                type: 'exclusive',
+                section: 'product',
+                options: ['A', 'B', 'C', 'D', 'E'],
+            };
+            const additiveResult = renderMenu(additiveQuestion, 1, { showInstructions: true });
+            const exclusiveResult = renderMenu(exclusiveQuestion, 1, { showInstructions: true });
+            expect(additiveResult).toContain('Select all that apply');
+            expect(exclusiveResult).not.toContain('Select all that apply');
+        });
+    });
+});

package/dist/utils/interactiveSetup.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Interactive Setup Command Handler
+ *
+ * This module provides the entry point for the interactive CDD setup experience.
+ * It replaces the static JSON-based setup prompt with a dynamic, code-driven workflow.
+ *
+ * Features:
+ * - Auto-detects project maturity (greenfield vs brownfield)
+ * - Generates context-aware questions based on codebase analysis
+ * - Interactive menu with 5 options per question (A-C contextual, D custom, E auto-generate)
+ * - Creates all 5 CDD documents: product.md, guidelines.md, tech-stack.md, styleguides.md, workflow.md
+ * - Resume functionality via setup_state.json checkpoints
+ * - Approval/revision loops for each document
+ */
+/**
+ * Interactive Setup Configuration
+ */
+export interface InteractiveSetupConfig {
+    projectPath: string;
+    outputDir?: string;
+    maxRevisions?: number;
+    resume?: boolean;
+    language?: 'en' | 'es';
+}
+/**
+ * Setup Result for API consumers
+ */
+export interface InteractiveSetupResult {
+    success: boolean;
+    message: string;
+    documentsCreated: string[];
+    errors?: string[];
+    resumed?: boolean;
+    resumedFrom?: string;
+}
+/**
+ * Main entry point for interactive setup
+ */
+export declare function executeInteractiveSetup(config: InteractiveSetupConfig): Promise<InteractiveSetupResult>;
+/**
+ * Generate setup summary message
+ */
+export declare function generateSetupSummary(result: InteractiveSetupResult): string;

package/dist/utils/interactiveSetup.js

@@ -0,0 +1,131 @@
+/**
+ * Interactive Setup Command Handler
+ *
+ * This module provides the entry point for the interactive CDD setup experience.
+ * It replaces the static JSON-based setup prompt with a dynamic, code-driven workflow.
+ *
+ * Features:
+ * - Auto-detects project maturity (greenfield vs brownfield)
+ * - Generates context-aware questions based on codebase analysis
+ * - Interactive menu with 5 options per question (A-C contextual, D custom, E auto-generate)
+ * - Creates all 5 CDD documents: product.md, guidelines.md, tech-stack.md, styleguides.md, workflow.md
+ * - Resume functionality via setup_state.json checkpoints
+ * - Approval/revision loops for each document
+ */
+import * as path from 'path';
+import { runFullSetup } from './setupIntegration.js';
+/**
+ * Default responder for interactive CLI
+ * This is a placeholder - the actual implementation should use
+ * the OpenCode CLI input tools for interactive prompts
+ *
+ * For testing: Returns option 'E' (auto-generate) to avoid hanging
+ */
+async function defaultResponder(question, questionNumber) {
+    // In production, this would use OpenCode CLI input
+    // For now, auto-select option E to enable testing
+    return ['E'];
+}
+/**
+ * Default approval flow for document review
+ * This is a placeholder - the actual implementation should use
+ * the OpenCode CLI input tools for approval prompts
+ */
+async function defaultApprovalFlow(draft) {
+    // TODO: Replace with actual OpenCode CLI approval prompt
+    console.log('\n[Document Draft Generated]');
+    console.log(`Word count: ${draft.wordCount}`);
+    console.log(`Sections included: ${draft.sectionsIncluded.length}`);
+    // For now, auto-approve
+    // This will be replaced when integrated with OpenCode CLI
+    return {
+        approved: true,
+    };
+}
+/**
+ * Main entry point for interactive setup
+ */
+export async function executeInteractiveSetup(config) {
+    try {
+        const outputDir = config.outputDir || path.join(config.projectPath, 'conductor-cdd');
+        const setupOptions = {
+            projectPath: config.projectPath,
+            outputDir,
+            responder: defaultResponder,
+            approvalFlow: defaultApprovalFlow,
+            maxRevisions: config.maxRevisions || 3,
+            resume: config.resume || false,
+        };
+        const result = await runFullSetup(setupOptions);
+        if (result.success) {
+            return {
+                success: true,
+                message: `Successfully created ${result.documentsCreated.length} CDD documents`,
+                documentsCreated: result.documentsCreated,
+                resumed: result.resumed,
+                resumedFrom: result.resumedFrom,
+            };
+        }
+        else {
+            return {
+                success: false,
+                message: result.error || 'Setup failed',
+                documentsCreated: result.documentsCreated || [],
+                errors: result.error ? [result.error] : [],
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: 'Interactive setup failed with an unexpected error',
+            documentsCreated: [],
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}
+/**
+ * Generate setup summary message
+ */
+export function generateSetupSummary(result) {
+    const lines = [];
+    if (result.success) {
+        lines.push('✅ CDD Setup Complete!');
+        lines.push('');
+        if (result.resumed) {
+            lines.push(`📋 Resumed from checkpoint: ${result.resumedFrom}`);
+            lines.push('');
+        }
+        lines.push('📄 Documents created:');
+        result.documentsCreated.forEach(doc => {
+            lines.push(`  • ${path.basename(doc)}`);
+        });
+        lines.push('');
+        lines.push('🎯 Next steps:');
+        lines.push('  1. Review the generated documents in conductor-cdd/');
+        lines.push('  2. Customize them to match your project needs');
+        lines.push('  3. Start your first track with: cdd:new-track');
+    }
+    else {
+        lines.push('❌ CDD Setup Failed');
+        lines.push('');
+        lines.push(`Error: ${result.message}`);
+        if (result.documentsCreated.length > 0) {
+            lines.push('');
+            lines.push('⚠️  Partially completed documents:');
+            result.documentsCreated.forEach(doc => {
+                lines.push(`  • ${path.basename(doc)}`);
+            });
+            lines.push('');
+            lines.push('💡 You can resume setup by running cdd:setup again');
+        }
+        if (result.errors && result.errors.length > 0) {
+            lines.push('');
+            lines.push('🔍 Error details:');
+            result.errors.forEach(err => {
+                lines.push(`  • ${err}`);
+            });
+        }
+    }
+    return lines.join('\n');
+}

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

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

package/dist/utils/interactiveSetup.test.js

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { executeInteractiveSetup, generateSetupSummary, } from './interactiveSetup.js';
+describe('interactiveSetup', () => {
+    let testOutputDir;
+    let testProjectDir;
+    beforeEach(() => {
+        testOutputDir = path.join(os.tmpdir(), 'cdd-interactive-setup-test');
+        testProjectDir = path.join(testOutputDir, 'test-project');
+        if (fs.existsSync(testOutputDir)) {
+            fs.rmSync(testOutputDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(testProjectDir, { recursive: true });
+    });
+    afterEach(() => {
+        if (fs.existsSync(testOutputDir)) {
+            fs.rmSync(testOutputDir, { recursive: true, force: true });
+        }
+    });
+    describe('executeInteractiveSetup', () => {
+        it('should return success result when setup completes', async () => {
+            // Mock runFullSetup to return success
+            const { executeInteractiveSetup } = await import('./interactiveSetup.js');
+            const config = {
+                projectPath: testProjectDir,
+            };
+            const result = await executeInteractiveSetup(config);
+            // Note: This will use default responder which returns empty arrays
+            // In actual implementation, we need to mock the responder properly
+            expect(result).toHaveProperty('success');
+            expect(result).toHaveProperty('message');
+            expect(result).toHaveProperty('documentsCreated');
+        });
+        it('should use custom outputDir when provided', async () => {
+            const customOutputDir = path.join(testProjectDir, 'custom-cdd');
+            const config = {
+                projectPath: testProjectDir,
+                outputDir: customOutputDir,
+            };
+            await executeInteractiveSetup(config);
+            // Verify outputDir was used (will be created by setupIntegration)
+            // This is just a smoke test - full integration tested in setupIntegration.test.ts
+            expect(true).toBe(true);
+        });
+        it('should handle resume flag', async () => {
+            const config = {
+                projectPath: testProjectDir,
+                resume: true,
+            };
+            const result = await executeInteractiveSetup(config);
+            expect(result).toHaveProperty('resumed');
+        });
+        it('should handle errors gracefully', async () => {
+            // Pass invalid projectPath to trigger error
+            const config = {
+                projectPath: '/nonexistent/path/that/does/not/exist',
+            };
+            const result = await executeInteractiveSetup(config);
+            expect(result.success).toBe(false);
+            expect(result.message).toBeTruthy();
+            expect(result.errors).toBeDefined();
+        });
+    });
+    describe('generateSetupSummary', () => {
+        it('should generate success summary with documents', () => {
+            const result = {
+                success: true,
+                message: 'Setup complete',
+                documentsCreated: [
+                    '/path/to/product.md',
+                    '/path/to/guidelines.md',
+                    '/path/to/tech-stack.md',
+                ],
+            };
+            const summary = generateSetupSummary(result);
+            expect(summary).toContain('✅ CDD Setup Complete!');
+            expect(summary).toContain('product.md');
+            expect(summary).toContain('guidelines.md');
+            expect(summary).toContain('tech-stack.md');
+            expect(summary).toContain('Next steps:');
+        });
+        it('should generate success summary with resume info', () => {
+            const result = {
+                success: true,
+                message: 'Setup complete',
+                documentsCreated: ['/path/to/guidelines.md'],
+                resumed: true,
+                resumedFrom: '2.1_product_guide',
+            };
+            const summary = generateSetupSummary(result);
+            expect(summary).toContain('Resumed from checkpoint');
+            expect(summary).toContain('2.1_product_guide');
+        });
+        it('should generate failure summary with partial completion', () => {
+            const result = {
+                success: false,
+                message: 'Setup failed at guidelines',
+                documentsCreated: ['/path/to/product.md'],
+                errors: ['Approval rejected 3 times'],
+            };
+            const summary = generateSetupSummary(result);
+            expect(summary).toContain('❌ CDD Setup Failed');
+            expect(summary).toContain('Setup failed at guidelines');
+            expect(summary).toContain('Partially completed');
+            expect(summary).toContain('product.md');
+            expect(summary).toContain('resume setup');
+            expect(summary).toContain('Approval rejected 3 times');
+        });
+        it('should generate failure summary with no documents', () => {
+            const result = {
+                success: false,
+                message: 'Project path does not exist',
+                documentsCreated: [],
+                errors: ['ENOENT: no such file or directory'],
+            };
+            const summary = generateSetupSummary(result);
+            expect(summary).toContain('❌ CDD Setup Failed');
+            expect(summary).toContain('Project path does not exist');
+            expect(summary).toContain('ENOENT');
+        });
+    });
+});

package/dist/utils/projectMaturity.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Project Maturity Detection Module
+ *
+ * Determines whether a project is brownfield (existing) or greenfield (new).
+ *
+ * Based on reference implementations:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+export type ProjectMaturity = 'brownfield' | 'greenfield';
+/**
+ * Detect project maturity (brownfield vs greenfield)
+ *
+ * A project is considered BROWNFIELD if ANY of:
+ * - Version control directory exists (.git, .svn, .hg)
+ * - Git repository is dirty (uncommitted changes)
+ * - Dependency manifests exist
+ * - Source directories contain code files
+ *
+ * A project is considered GREENFIELD only if NONE of the above are true.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns 'brownfield' or 'greenfield'
+ */
+export declare function detectProjectMaturity(projectPath: string): ProjectMaturity;
+/**
+ * Check if git repository has uncommitted changes
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns true if repository is dirty, false otherwise
+ */
+export declare function checkGitStatus(projectPath: string): boolean;
+/**
+ * Check for dependency manifest files
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Array of found manifest file names
+ */
+export declare function checkManifestFiles(projectPath: string): string[];
+/**
+ * Check for source directories containing code files
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Array of found source directory names
+ */
+export declare function checkSourceDirectories(projectPath: string): string[];
+/**
+ * Check for version control system directories
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Name of VCS directory found, or null if none found
+ */
+export declare function checkVersionControl(projectPath: string): string | null;