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

package/dist/utils/documentGeneration.test.js

@@ -0,0 +1,380 @@
+import { describe, it, expect, vi } from 'vitest';
+import { generateDocument, presentQuestionsSequentially, draftDocumentFromAnswers, saveDocumentState, } from './documentGeneration.js';
+describe('documentGeneration', () => {
+    const mockAnalysis = {
+        languages: {
+            'TypeScript': 60,
+            'JavaScript': 40,
+        },
+        frameworks: {
+            frontend: ['React', 'Next.js'],
+            backend: ['Express'],
+        },
+        databases: ['PostgreSQL'],
+        manifests: [{
+                type: 'package.json',
+                path: '/package.json',
+                metadata: { name: 'test-project', version: '1.0.0' },
+                dependencies: { 'react': '^18.0.0' },
+            }],
+        architecture: ['MVC'],
+        projectGoal: 'E-commerce platform',
+    };
+    const mockQuestions = [
+        {
+            id: 'product-1',
+            text: 'What is the primary purpose?',
+            type: 'exclusive',
+            section: 'product',
+            options: ['E-commerce', 'Social media', 'Dashboard', 'Custom', 'Auto-generate'],
+        },
+        {
+            id: 'product-2',
+            text: 'Who are the target users?',
+            type: 'exclusive',
+            section: 'product',
+            options: ['Developers', 'End users', 'Businesses', 'Custom', 'Auto-generate'],
+        },
+    ];
+    describe('presentQuestionsSequentially', () => {
+        it('should present questions one at a time up to max 5', async () => {
+            const questions = Array.from({ length: 7 }, (_, i) => ({
+                id: `q-${i}`,
+                text: `Question ${i}`,
+                type: 'exclusive',
+                section: 'product',
+                options: ['A', 'B', 'C', 'D', 'E'],
+            }));
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A'])
+                .mockResolvedValueOnce(['B'])
+                .mockResolvedValueOnce(['C'])
+                .mockResolvedValueOnce(['A'])
+                .mockResolvedValueOnce(['B']);
+            const session = await presentQuestionsSequentially(questions, mockResponder, { maxQuestions: 5 });
+            expect(session.questionsAsked).toHaveLength(5);
+            expect(session.answers).toHaveLength(5);
+            expect(mockResponder).toHaveBeenCalledTimes(5);
+        });
+        it('should stop early if user selects option E (auto-generate)', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A'])
+                .mockResolvedValueOnce(['E']); // Option E selected
+            const session = await presentQuestionsSequentially(mockQuestions, mockResponder);
+            expect(session.questionsAsked).toHaveLength(2);
+            expect(session.answers).toHaveLength(2);
+            expect(session.autoGenerateRequested).toBe(true);
+            expect(session.autoGenerateAtQuestion).toBe(1); // 0-based index
+        });
+        it('should handle option D (custom input) by prompting for text', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['D']); // Option D selected
+            const mockCustomInputPrompt = vi.fn()
+                .mockResolvedValueOnce('Custom purpose text');
+            const session = await presentQuestionsSequentially(mockQuestions.slice(0, 1), mockResponder, { customInputPrompt: mockCustomInputPrompt });
+            expect(session.answers[0].selections).toEqual(['D']);
+            expect(session.answers[0].customText).toBe('Custom purpose text');
+            expect(mockCustomInputPrompt).toHaveBeenCalledTimes(1);
+        });
+        it('should handle additive questions with multiple selections', async () => {
+            const additiveQuestion = {
+                id: 'features-1',
+                text: 'What features are needed?',
+                type: 'additive',
+                section: 'product',
+                options: ['Auth', 'Dashboard', 'API', 'Custom', 'Auto-generate'],
+            };
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A', 'B', 'C']); // Multiple selections
+            const session = await presentQuestionsSequentially([additiveQuestion], mockResponder);
+            expect(session.answers[0].selections).toEqual(['A', 'B', 'C']);
+            expect(session.answers[0].selectedOptions).toEqual(['Auth', 'Dashboard', 'API']);
+        });
+        it('should reject invalid selections and re-prompt', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['F']) // Invalid
+                .mockResolvedValueOnce(['A']); // Valid
+            const session = await presentQuestionsSequentially(mockQuestions.slice(0, 1), mockResponder);
+            expect(mockResponder).toHaveBeenCalledTimes(2);
+            expect(session.answers[0].selections).toEqual(['A']);
+        });
+        it('should track question history and timestamps', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A'])
+                .mockResolvedValueOnce(['B']);
+            const session = await presentQuestionsSequentially(mockQuestions, mockResponder);
+            expect(session.questionsAsked).toHaveLength(2);
+            expect(session.answers[0].timestamp).toBeDefined();
+            expect(session.answers[1].timestamp).toBeDefined();
+        });
+    });
+    describe('draftDocumentFromAnswers', () => {
+        it('should generate document content from selected answers only', () => {
+            const session = {
+                section: 'product',
+                questionsAsked: mockQuestions.slice(0, 2),
+                answers: [
+                    {
+                        questionId: 'product-1',
+                        selections: ['A'],
+                        selectedOptions: ['E-commerce'],
+                        timestamp: new Date().toISOString(),
+                    },
+                    {
+                        questionId: 'product-2',
+                        selections: ['B'],
+                        selectedOptions: ['End users'],
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+                autoGenerateRequested: false,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, mockAnalysis);
+            expect(draft.content).toContain('E-commerce');
+            expect(draft.content).toContain('End users');
+            expect(draft.content).not.toContain('Social media'); // Unselected option
+            expect(draft.content).not.toContain('Developers'); // Unselected option
+        });
+        it('should ignore unselected options from questions', () => {
+            const session = {
+                section: 'product',
+                questionsAsked: mockQuestions.slice(0, 1),
+                answers: [
+                    {
+                        questionId: 'product-1',
+                        selections: ['A'],
+                        selectedOptions: ['E-commerce'],
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+                autoGenerateRequested: false,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, mockAnalysis);
+            // Should NOT contain unselected options B, C
+            expect(draft.content).not.toContain('Social media');
+            expect(draft.content).not.toContain('Dashboard');
+            // Should NOT contain the option letters
+            expect(draft.content).not.toMatch(/\bA\)/);
+            expect(draft.content).not.toMatch(/\bB\)/);
+            expect(draft.content).not.toMatch(/\bC\)/);
+        });
+        it('should incorporate custom text from option D', () => {
+            const session = {
+                section: 'product',
+                questionsAsked: mockQuestions.slice(0, 1),
+                answers: [
+                    {
+                        questionId: 'product-1',
+                        selections: ['D'],
+                        selectedOptions: ['Custom'],
+                        customText: 'A platform for managing IoT devices',
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+                autoGenerateRequested: false,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, mockAnalysis);
+            expect(draft.content).toContain('A platform for managing IoT devices');
+        });
+        it('should infer additional content when auto-generate was requested', () => {
+            const session = {
+                section: 'product',
+                questionsAsked: mockQuestions.slice(0, 1),
+                answers: [
+                    {
+                        questionId: 'product-1',
+                        selections: ['A'],
+                        selectedOptions: ['E-commerce'],
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+                autoGenerateRequested: true,
+                autoGenerateAtQuestion: 0,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, mockAnalysis);
+            expect(draft.content).toContain('E-commerce');
+            // Should infer additional sections based on context
+            expect(draft.content.length).toBeGreaterThan(100);
+            expect(draft.inferredFromContext).toBe(true);
+        });
+        it('should use codebase analysis to enhance brownfield documents', () => {
+            const session = {
+                section: 'tech-stack',
+                questionsAsked: [],
+                answers: [],
+                autoGenerateRequested: true,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, mockAnalysis);
+            expect(draft.content).toContain('TypeScript');
+            expect(draft.content).toContain('React');
+            expect(draft.content).toContain('Next.js');
+            expect(draft.content).toContain('PostgreSQL');
+        });
+        it('should generate comprehensive content for greenfield projects', () => {
+            const greenfieldAnalysis = {
+                languages: {},
+                frameworks: { frontend: [], backend: [] },
+                databases: [],
+                manifests: [],
+                architecture: [],
+            };
+            const session = {
+                section: 'product',
+                questionsAsked: mockQuestions.slice(0, 1),
+                answers: [
+                    {
+                        questionId: 'product-1',
+                        selections: ['A'],
+                        selectedOptions: ['E-commerce'],
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+                autoGenerateRequested: false,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, greenfieldAnalysis);
+            expect(draft.content).toContain('E-commerce');
+            expect(draft.content.length).toBeGreaterThan(30);
+        });
+    });
+    describe('saveDocumentState', () => {
+        it('should create state file with correct checkpoint structure', async () => {
+            const result = await saveDocumentState({
+                section: 'product',
+                checkpoint: '2.1_product_guide',
+                content: '# Product Guide\n\nContent here',
+                filePath: 'conductor-cdd/product.md',
+            });
+            expect(result.success).toBe(true);
+            expect(result.stateFile).toContain('setup_state.json');
+            expect(result.checkpoint).toBe('2.1_product_guide');
+        });
+        it('should update existing state file without overwriting other checkpoints', async () => {
+            // First save
+            await saveDocumentState({
+                section: 'product',
+                checkpoint: '2.1_product_guide',
+                content: 'Content 1',
+                filePath: 'conductor-cdd/product.md',
+            });
+            // Second save
+            const result = await saveDocumentState({
+                section: 'guidelines',
+                checkpoint: '2.2_product_guidelines',
+                content: 'Content 2',
+                filePath: 'conductor-cdd/guidelines.md',
+            });
+            expect(result.success).toBe(true);
+            expect(result.previousCheckpoints).toContain('2.1_product_guide');
+        });
+        it('should save document to correct file path', async () => {
+            const result = await saveDocumentState({
+                section: 'product',
+                checkpoint: '2.1_product_guide',
+                content: '# Product Guide\n\nTest content',
+                filePath: 'conductor-cdd/product.md',
+            });
+            expect(result.success).toBe(true);
+            expect(result.filePath).toContain('product.md');
+        });
+        it('should handle file system errors gracefully', async () => {
+            const result = await saveDocumentState({
+                section: 'product',
+                checkpoint: '2.1_product_guide',
+                content: 'Content',
+                filePath: '/invalid/path/that/does/not/exist/file.md',
+            });
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+    describe('generateDocument', () => {
+        it('should orchestrate full document generation workflow', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A'])
+                .mockResolvedValueOnce(['B']);
+            const mockApprovalFlow = vi.fn()
+                .mockResolvedValueOnce({ approved: true, finalContent: '# Final content' });
+            const options = {
+                section: 'product',
+                questions: mockQuestions,
+                analysis: mockAnalysis,
+                responder: mockResponder,
+                approvalFlow: mockApprovalFlow,
+                outputPath: 'conductor-cdd/product.md',
+            };
+            const result = await generateDocument(options);
+            expect(result.success).toBe(true);
+            expect(result.checkpoint).toBe('2.1_product_guide');
+            expect(mockResponder).toHaveBeenCalled();
+            expect(mockApprovalFlow).toHaveBeenCalled();
+        });
+        it('should handle auto-generate early exit', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['E']); // Auto-generate immediately
+            const mockApprovalFlow = vi.fn()
+                .mockResolvedValueOnce({ approved: true, finalContent: '# Auto-generated content' });
+            const options = {
+                section: 'product',
+                questions: mockQuestions,
+                analysis: mockAnalysis,
+                responder: mockResponder,
+                approvalFlow: mockApprovalFlow,
+                outputPath: 'conductor-cdd/product.md',
+            };
+            const result = await generateDocument(options);
+            expect(result.success).toBe(true);
+            expect(result.autoGenerated).toBe(true);
+            expect(mockResponder).toHaveBeenCalledTimes(1); // Stopped after E
+        });
+        it('should handle approval rejection and revision loop', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A']);
+            const mockApprovalFlow = vi.fn()
+                .mockResolvedValueOnce({ approved: false, revisionGuidance: 'Add more details' })
+                .mockResolvedValueOnce({ approved: true, finalContent: '# Revised content' });
+            const options = {
+                section: 'product',
+                questions: mockQuestions.slice(0, 1),
+                analysis: mockAnalysis,
+                responder: mockResponder,
+                approvalFlow: mockApprovalFlow,
+                outputPath: 'conductor-cdd/product.md',
+            };
+            const result = await generateDocument(options);
+            expect(result.success).toBe(true);
+            expect(result.revisionCount).toBe(1);
+            expect(mockApprovalFlow).toHaveBeenCalledTimes(2);
+        });
+        it('should fail after max revision attempts', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A']);
+            const mockApprovalFlow = vi.fn()
+                .mockResolvedValue({ approved: false, revisionGuidance: 'Still not good' });
+            const options = {
+                section: 'product',
+                questions: mockQuestions.slice(0, 1),
+                analysis: mockAnalysis,
+                responder: mockResponder,
+                approvalFlow: mockApprovalFlow,
+                outputPath: 'conductor-cdd/product.md',
+                maxRevisions: 3,
+            };
+            const result = await generateDocument(options);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('revision');
+            expect(mockApprovalFlow).toHaveBeenCalledTimes(3);
+        });
+    });
+});

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