opencode-conductor-cdd-plugin 1.0.0-beta.17 → 1.0.0-beta.19

package/dist/utils/interactiveMenu.d.ts

@@ -0,0 +1,56 @@
+import { Question, QuestionType } from './questionGenerator.js';
+/**
+ * Interactive Menu System
+ *
+ * Provides menu rendering and input validation for the CDD setup process.
+ * Adapts to LLM-based interaction pattern (no terminal UI library required).
+ *
+ * Features:
+ * - Format questions with lettered options (A-E)
+ * - Validate single/multiple selections
+ * - Parse user input into selection arrays
+ * - Render complete menus with instructions
+ *
+ * Based on reference implementations:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+export interface MenuOptions {
+    showInstructions?: boolean;
+}
+/**
+ * Format a question with numbered display and lettered options
+ *
+ * Example output:
+ * Question 1: What are the key features? (Select all that apply)
+ * A) User authentication
+ * B) Real-time updates
+ * C) Data analytics
+ * D) Enter custom features
+ * E) Auto-generate from codebase
+ */
+export declare function formatQuestionWithOptions(question: Question, questionNumber: number): string;
+/**
+ * Validate user selection input
+ *
+ * Rules:
+ * - Exclusive: Single letter A-E
+ * - Additive: Single letter or comma-separated (A,B,C)
+ * - Option E cannot be combined with others in additive
+ * - No duplicates allowed
+ * - Case insensitive
+ */
+export declare function validateSelection(input: string, questionType: QuestionType): boolean;
+/**
+ * Parse user selection input into array of letters
+ *
+ * Returns empty array if invalid
+ * Normalizes to uppercase, removes duplicates, and sorts for additive
+ */
+export declare function parseSelection(input: string, questionType: QuestionType): string[];
+/**
+ * Render complete interactive menu with question and instructions
+ *
+ * Generates LLM-compatible menu display suitable for text-based interaction
+ */
+export declare function renderMenu(question: Question, questionNumber: number, options?: MenuOptions): string;

package/dist/utils/interactiveMenu.js

@@ -0,0 +1,144 @@
+const VALID_OPTIONS = ['A', 'B', 'C', 'D', 'E'];
+const MAX_OPTION_LENGTH = 80;
+/**
+ * Format a question with numbered display and lettered options
+ *
+ * Example output:
+ * Question 1: What are the key features? (Select all that apply)
+ * A) User authentication
+ * B) Real-time updates
+ * C) Data analytics
+ * D) Enter custom features
+ * E) Auto-generate from codebase
+ */
+export function formatQuestionWithOptions(question, questionNumber) {
+    const lines = [];
+    // Question header with number
+    const suffix = question.type === 'additive' ? ' (Select all that apply)' : '';
+    lines.push(`Question ${questionNumber}: ${question.text}${suffix}`);
+    lines.push('');
+    // Format options A-E
+    question.options.forEach((option, index) => {
+        const letter = VALID_OPTIONS[index];
+        // Truncate option text: if > 80, cut to fit "..." within 80 char limit
+        // Target: 80 max, so truncate to 75 + "..." (3) = 78 total
+        const truncated = option.length > MAX_OPTION_LENGTH
+            ? option.substring(0, 75) + '...'
+            : option;
+        lines.push(`${letter}) ${truncated}`);
+    });
+    return lines.join('\n');
+}
+/**
+ * Validate user selection input
+ *
+ * Rules:
+ * - Exclusive: Single letter A-E
+ * - Additive: Single letter or comma-separated (A,B,C)
+ * - Option E cannot be combined with others in additive
+ * - No duplicates allowed
+ * - Case insensitive
+ */
+export function validateSelection(input, questionType) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return false;
+    }
+    // Parse selections
+    const selections = trimmed
+        .split(',')
+        .map(s => s.trim().toUpperCase())
+        .filter(s => s.length > 0);
+    // Check for empty selections after split
+    if (selections.length === 0) {
+        return false;
+    }
+    // All selections must be valid letters (A-E)
+    for (const selection of selections) {
+        if (!VALID_OPTIONS.includes(selection)) {
+            return false;
+        }
+    }
+    // Check for duplicates using Set
+    const uniqueSelections = new Set(selections);
+    if (uniqueSelections.size !== selections.length) {
+        return false;
+    }
+    // Exclusive: Only one selection allowed
+    if (questionType === 'exclusive' && uniqueSelections.size > 1) {
+        return false;
+    }
+    // Option E (auto-generate) cannot be combined with others in additive
+    if (questionType === 'additive' && uniqueSelections.size > 1 && uniqueSelections.has('E')) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Parse user selection input into array of letters
+ *
+ * Returns empty array if invalid
+ * Normalizes to uppercase, removes duplicates, and sorts for additive
+ */
+export function parseSelection(input, questionType) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return [];
+    }
+    // Parse and normalize
+    const selections = trimmed
+        .split(',')
+        .map(s => s.trim().toUpperCase())
+        .filter(s => s.length > 0);
+    // Remove duplicates
+    const uniqueSelections = [...new Set(selections)];
+    // Now validate the unique selections
+    const validationInput = uniqueSelections.join(',');
+    if (!validateSelection(validationInput, questionType)) {
+        return [];
+    }
+    // Sort additive selections for consistency
+    if (questionType === 'additive') {
+        return uniqueSelections.sort();
+    }
+    return uniqueSelections;
+}
+/**
+ * Get section-specific instruction text for the menu
+ */
+function getSectionInstructions(question) {
+    const instructions = [];
+    if (question.type === 'additive') {
+        instructions.push('- You can select multiple options by separating them with commas (e.g., "A,B,C")');
+        instructions.push('- Or select a single option (e.g., "A")');
+    }
+    else {
+        instructions.push('- Select one option (e.g., "A")');
+    }
+    instructions.push('- Option D: Enter custom text when prompted');
+    instructions.push(`- Option E: Auto-generate this section from your codebase`);
+    if (question.type === 'additive') {
+        instructions.push('- Note: Option E cannot be combined with other options');
+    }
+    return instructions.join('\n');
+}
+/**
+ * Render complete interactive menu with question and instructions
+ *
+ * Generates LLM-compatible menu display suitable for text-based interaction
+ */
+export function renderMenu(question, questionNumber, options = {}) {
+    const { showInstructions = true } = options;
+    const lines = [];
+    // Add formatted question with options
+    lines.push(formatQuestionWithOptions(question, questionNumber));
+    // Add instructions if enabled
+    if (showInstructions) {
+        lines.push('');
+        lines.push('Instructions:');
+        lines.push('Enter your selection (e.g., "A,B,C" for multiple or "A" for single)');
+        lines.push('');
+        lines.push(getSectionInstructions(question));
+    }
+    return lines.join('\n');
+}

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

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

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 {};