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

package/dist/utils/questionGenerator.test.js

@@ -0,0 +1,328 @@
+import { describe, it, expect } from 'vitest';
+import { classifyQuestionType, addQuestionSuffix, generateBrownfieldQuestions, generateGreenfieldQuestions, generateAnswerOptions, formatQuestion, generateQuestionsForSection, } from './questionGenerator.js';
+/**
+ * Question Generation Engine Tests
+ *
+ * This module is responsible for generating context-aware questions for setup:
+ * - Classification: Additive (multiple answers) vs Exclusive Choice (single answer)
+ * - Context-aware generation for brownfield projects (based on codebase analysis)
+ * - Pattern-based generation for greenfield projects (common best practices)
+ * - Answer option generation (3 contextual options + D/E standard options)
+ *
+ * Based on reference implementations from:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+const mockBrownfieldAnalysis = {
+    languages: { TypeScript: 70, JavaScript: 30 },
+    frameworks: {
+        frontend: ['React', 'Next.js'],
+        backend: ['Express'],
+    },
+    databases: ['PostgreSQL', 'Redis'],
+    architecture: ['monorepo', 'layered-architecture'],
+    manifests: [
+        {
+            type: 'package.json',
+            path: '/test/package.json',
+            metadata: { name: 'test-app', version: '1.0.0', description: 'A test application' },
+            dependencies: { react: '^18.0.0', express: '^4.18.0' },
+        },
+    ],
+    projectGoal: 'A test application for demonstrating brownfield analysis',
+};
+describe('Question Generation Engine', () => {
+    describe('classifyQuestionType', () => {
+        it('should classify as additive when question asks for multiple selections', () => {
+            const result = classifyQuestionType('What are the key features?');
+            expect(result).toBe('additive');
+        });
+        it('should classify as exclusive when question asks for single choice', () => {
+            const result = classifyQuestionType('What is the primary goal?');
+            expect(result).toBe('exclusive');
+        });
+        it('should add "(Select all that apply)" suffix for additive questions', () => {
+            const result = addQuestionSuffix('What are the features?', 'additive');
+            expect(result).toContain('(Select all that apply)');
+        });
+        it('should NOT add suffix for exclusive questions', () => {
+            const result = addQuestionSuffix('What is the goal?', 'exclusive');
+            expect(result).not.toContain('(Select all that apply)');
+        });
+        it('should handle edge case: questions with "or" are exclusive', () => {
+            const result = classifyQuestionType('Is this A or B?');
+            expect(result).toBe('exclusive');
+        });
+        it('should handle edge case: questions with "and" might be additive', () => {
+            const result = classifyQuestionType('What features and capabilities do you need?');
+            expect(result).toBe('additive');
+        });
+    });
+    describe('generateBrownfieldQuestions', () => {
+        it('should generate product questions based on project goal from README', () => {
+            const questions = generateBrownfieldQuestions('product', mockBrownfieldAnalysis);
+            expect(questions.length).toBeGreaterThan(0);
+            expect(questions[0].section).toBe('product');
+            expect(questions[0].text).toContain('goal');
+        });
+        it('should generate tech-stack questions based on detected languages', () => {
+            const questions = generateBrownfieldQuestions('tech-stack', mockBrownfieldAnalysis);
+            const langQuestion = questions.find(q => q.id === 'techstack_languages');
+            expect(langQuestion).toBeDefined();
+            expect(langQuestion?.options).toContain('TypeScript');
+        });
+        it('should generate tech-stack questions based on detected frameworks', () => {
+            const questions = generateBrownfieldQuestions('tech-stack', mockBrownfieldAnalysis);
+            const fwQuestion = questions.find(q => q.id === 'techstack_frameworks');
+            expect(fwQuestion).toBeDefined();
+            expect(fwQuestion?.options).toContain('React');
+        });
+        it('should generate questions based on detected architecture', () => {
+            const questions = generateBrownfieldQuestions('tech-stack', mockBrownfieldAnalysis);
+            const archQuestion = questions.find(q => q.id === 'techstack_architecture');
+            expect(archQuestion).toBeDefined();
+        });
+        it('should generate 3 contextual answer options from codebase analysis', () => {
+            const questions = generateBrownfieldQuestions('product', mockBrownfieldAnalysis);
+            questions.forEach(q => {
+                expect(q.options.length).toBe(5); // A-C contextual + D (Custom) + E (Auto-generate)
+            });
+        });
+        it('should always include "Type your own answer" as option D', () => {
+            const questions = generateBrownfieldQuestions('product', mockBrownfieldAnalysis);
+            const options = generateAnswerOptions(questions[0].options, 'product');
+            expect(options[3]).toBe('Type your own answer');
+        });
+        it('should always include "Autogenerate and review [section].md" as option E', () => {
+            const questions = generateBrownfieldQuestions('product', mockBrownfieldAnalysis);
+            const options = generateAnswerOptions(questions[0].options, 'product');
+            expect(options[4]).toBe('Autogenerate and review product.md');
+        });
+        it('should limit to max 5 questions per section', () => {
+            const questions = generateBrownfieldQuestions('tech-stack', mockBrownfieldAnalysis);
+            expect(questions.length).toBeLessThanOrEqual(5);
+        });
+        it('should prioritize questions based on project complexity', () => {
+            const questions = generateBrownfieldQuestions('tech-stack', mockBrownfieldAnalysis);
+            // Complex projects should have more specific questions
+            expect(questions.length).toBeGreaterThan(0);
+        });
+    });
+    describe('generateGreenfieldQuestions', () => {
+        it('should generate product questions using common patterns', () => {
+            const questions = generateGreenfieldQuestions('product');
+            expect(questions.length).toBeGreaterThan(0);
+            expect(questions[0].section).toBe('product');
+        });
+        it('should generate tech-stack questions with popular framework options', () => {
+            const questions = generateGreenfieldQuestions('tech-stack');
+            const frontendQ = questions.find(q => q.id === 'techstack_frontend');
+            expect(frontendQ?.options).toContain('React');
+            expect(frontendQ?.options).toContain('Vue');
+        });
+        it('should generate 3 pattern-based answer options', () => {
+            const questions = generateGreenfieldQuestions('product');
+            questions.forEach(q => {
+                expect(q.options.length).toBe(5); // A-C contextual + D (Custom) + E (Auto-generate)
+            });
+        });
+        it('should always include "Type your own answer" as option D', () => {
+            const questions = generateGreenfieldQuestions('product');
+            const options = generateAnswerOptions(questions[0].options, 'product');
+            expect(options[3]).toBe('Type your own answer');
+        });
+        it('should always include "Autogenerate and review [section].md" as option E', () => {
+            const questions = generateGreenfieldQuestions('product');
+            const options = generateAnswerOptions(questions[0].options, 'product');
+            expect(options[4]).toBe('Autogenerate and review product.md');
+        });
+        it('should limit to max 5 questions per section', () => {
+            const questions = generateGreenfieldQuestions('tech-stack');
+            expect(questions.length).toBeLessThanOrEqual(5);
+        });
+        it('should cover all major decision points for new projects', () => {
+            const sections = ['product', 'guidelines', 'tech-stack', 'styleguides', 'workflow'];
+            sections.forEach(section => {
+                const questions = generateGreenfieldQuestions(section);
+                expect(questions.length).toBeGreaterThan(0);
+            });
+        });
+    });
+    describe('generateAnswerOptions', () => {
+        it('should generate 3 contextual options for brownfield projects', () => {
+            const options = generateAnswerOptions(['Option 1', 'Option 2', 'Option 3'], 'product');
+            expect(options.slice(0, 3)).toEqual(['Option 1', 'Option 2', 'Option 3']);
+        });
+        it('should generate 3 pattern-based options for greenfield projects', () => {
+            const options = generateAnswerOptions(['Pattern A', 'Pattern B', 'Pattern C'], 'product');
+            expect(options.slice(0, 3)).toEqual(['Pattern A', 'Pattern B', 'Pattern C']);
+        });
+        it('should make options mutually exclusive for exclusive questions', () => {
+            // This is enforced by question design, not by code
+            const options = generateAnswerOptions(['Option 1', 'Option 2', 'Option 3'], 'product');
+            expect(options.length).toBe(5);
+        });
+        it('should make options complementary for additive questions', () => {
+            // This is enforced by question design, not by code
+            const options = generateAnswerOptions(['Feature 1', 'Feature 2', 'Feature 3'], 'product');
+            expect(options.length).toBe(5);
+        });
+        it('should keep options concise (max 80 characters)', () => {
+            const longOption = 'This is a very long option that exceeds eighty characters and should be truncated automatically';
+            const options = generateAnswerOptions([longOption, 'Short', 'Another'], 'product');
+            expect(options[0].length).toBeLessThanOrEqual(80);
+        });
+        it('should order options by relevance/popularity', () => {
+            // Options are already ordered by caller
+            const options = generateAnswerOptions(['Most relevant', 'Second', 'Third'], 'product');
+            expect(options[0]).toBe('Most relevant');
+        });
+    });
+    describe('formatQuestion', () => {
+        it('should format question with lettered options (A, B, C, D, E)', () => {
+            const question = {
+                id: 'test',
+                text: 'What is your choice?',
+                type: 'exclusive',
+                section: 'product',
+                options: ['Option 1', 'Option 2', 'Option 3'],
+            };
+            const formatted = formatQuestion(question, 1);
+            expect(formatted).toContain('A)');
+            expect(formatted).toContain('B)');
+            expect(formatted).toContain('C)');
+            expect(formatted).toContain('D)');
+            expect(formatted).toContain('E)');
+        });
+        it('should include additive suffix when type is additive', () => {
+            const question = {
+                id: 'test',
+                text: 'What are your choices?',
+                type: 'additive',
+                section: 'product',
+                options: ['Option 1', 'Option 2', 'Option 3'],
+            };
+            const formatted = formatQuestion(question, 1);
+            expect(formatted).toContain('(Select all that apply)');
+        });
+        it('should format option D as "Type your own answer"', () => {
+            const question = {
+                id: 'test',
+                text: 'Test question',
+                type: 'exclusive',
+                section: 'product',
+                options: ['A', 'B', 'C'],
+            };
+            const formatted = formatQuestion(question, 1);
+            expect(formatted).toContain('D) Type your own answer');
+        });
+        it('should format option E with section-specific document name', () => {
+            const question = {
+                id: 'test',
+                text: 'Test question',
+                type: 'exclusive',
+                section: 'product',
+                options: ['A', 'B', 'C'],
+            };
+            const formatted = formatQuestion(question, 1);
+            expect(formatted).toContain('E) Autogenerate and review product.md');
+        });
+        it('should number questions sequentially within section', () => {
+            const question = {
+                id: 'test',
+                text: 'Test question',
+                type: 'exclusive',
+                section: 'product',
+                options: ['A', 'B', 'C'],
+            };
+            const formatted = formatQuestion(question, 3);
+            expect(formatted).toContain('Question 3:');
+        });
+    });
+    describe('generateQuestionsForSection', () => {
+        it('should generate questions for product.md section', () => {
+            const questions = generateQuestionsForSection('product', 'greenfield');
+            expect(questions.length).toBeGreaterThan(0);
+            expect(questions[0].section).toBe('product');
+        });
+        it('should generate questions for guidelines.md section', () => {
+            const questions = generateQuestionsForSection('guidelines', 'greenfield');
+            expect(questions.length).toBeGreaterThan(0);
+            expect(questions[0].section).toBe('guidelines');
+        });
+        it('should generate questions for tech-stack.md section', () => {
+            const questions = generateQuestionsForSection('tech-stack', 'greenfield');
+            expect(questions.length).toBeGreaterThan(0);
+            expect(questions[0].section).toBe('tech-stack');
+        });
+        it('should generate questions for styleguides.md section', () => {
+            const questions = generateQuestionsForSection('styleguides', 'greenfield');
+            expect(questions.length).toBeGreaterThan(0);
+            expect(questions[0].section).toBe('styleguides');
+        });
+        it('should generate questions for workflow.md section', () => {
+            const questions = generateQuestionsForSection('workflow', 'greenfield');
+            expect(questions.length).toBeGreaterThan(0);
+            expect(questions[0].section).toBe('workflow');
+        });
+        it('should adapt questions based on project maturity', () => {
+            const greenfieldQuestions = generateQuestionsForSection('product', 'greenfield');
+            const brownfieldQuestions = generateQuestionsForSection('product', 'brownfield', mockBrownfieldAnalysis);
+            // Both should generate questions, but content may differ
+            expect(greenfieldQuestions.length).toBeGreaterThan(0);
+            expect(brownfieldQuestions.length).toBeGreaterThan(0);
+        });
+        it('should respect max 5 questions per section', () => {
+            const questions = generateQuestionsForSection('tech-stack', 'greenfield');
+            expect(questions.length).toBeLessThanOrEqual(5);
+        });
+    });
+    describe('Integration: Question Generation Flow', () => {
+        it('should generate complete question set for brownfield project', () => {
+            const sections = ['product', 'guidelines', 'tech-stack', 'styleguides', 'workflow'];
+            sections.forEach(section => {
+                const questions = generateQuestionsForSection(section, 'brownfield', mockBrownfieldAnalysis);
+                expect(questions.length).toBeGreaterThan(0);
+                expect(questions.length).toBeLessThanOrEqual(5);
+                questions.forEach(q => {
+                    expect(q.section).toBe(section);
+                    expect(q.options.length).toBe(5); // A-C contextual + D (Custom) + E (Auto-generate)
+                    expect(['additive', 'exclusive']).toContain(q.type);
+                    const fullOptions = generateAnswerOptions(q.options, section);
+                    expect(fullOptions[3]).toBe('Type your own answer');
+                    expect(fullOptions[4]).toBe(`Autogenerate and review ${section}.md`);
+                });
+            });
+        });
+        it('should generate complete question set for greenfield project', () => {
+            const sections = ['product', 'guidelines', 'tech-stack', 'styleguides', 'workflow'];
+            sections.forEach(section => {
+                const questions = generateQuestionsForSection(section, 'greenfield');
+                expect(questions.length).toBeGreaterThan(0);
+                expect(questions.length).toBeLessThanOrEqual(5);
+                questions.forEach(q => {
+                    expect(q.section).toBe(section);
+                    expect(q.options.length).toBe(5); // A-C contextual + D (Custom) + E (Auto-generate)
+                    expect(['additive', 'exclusive']).toContain(q.type);
+                });
+            });
+        });
+        it('should maintain consistency across all sections', () => {
+            const sections = ['product', 'guidelines', 'tech-stack', 'styleguides', 'workflow'];
+            const allQuestions = [];
+            sections.forEach(section => {
+                const questions = generateQuestionsForSection(section, 'greenfield');
+                allQuestions.push(...questions);
+            });
+            // All questions should have consistent structure
+            allQuestions.forEach(q => {
+                expect(q.id).toBeTruthy();
+                expect(q.text).toBeTruthy();
+                expect(q.type).toBeTruthy();
+                expect(q.section).toBeTruthy();
+                expect(Array.isArray(q.options)).toBe(true);
+                expect(q.options.length).toBe(5); // A-C contextual + D (Custom) + E (Auto-generate)
+            });
+        });
+    });
+});

package/dist/utils/setupIntegration.d.ts

@@ -0,0 +1,72 @@
+import { Question } from './questionGenerator.js';
+import { ApprovalResult, DocumentDraft } from './documentGeneration.js';
+/**
+ * Setup Integration Module
+ *
+ * Orchestrates the complete setup workflow by integrating:
+ * - Project maturity detection (Phase 2)
+ * - Codebase analysis (Phase 2)
+ * - Question generation (Phase 3)
+ * - Interactive menu (Phase 4)
+ * - Document generation (Phase 5)
+ *
+ * Provides high-level functions for setting up each section:
+ * - setupProductGuide()
+ * - setupGuidelines()
+ * - setupTechStack()
+ * - setupStyleguides()
+ * - setupWorkflow()
+ * - runFullSetup() - All 5 documents in sequence
+ */
+export interface SetupOptions {
+    projectPath: string;
+    outputDir: string;
+    responder: (question: Question, questionNumber: number) => Promise<string[]>;
+    approvalFlow: (draft: DocumentDraft) => Promise<ApprovalResult>;
+    customInputPrompt?: (question: Question) => Promise<string>;
+    maxRevisions?: number;
+    resume?: boolean;
+}
+export interface SetupResult {
+    success: boolean;
+    checkpoint?: string;
+    filePath?: string;
+    isBrownfield?: boolean;
+    autoGenerated?: boolean;
+    revisionCount?: number;
+    error?: string;
+    resumed?: boolean;
+    resumedFrom?: string;
+}
+export interface FullSetupResult {
+    success: boolean;
+    documentsCreated: string[];
+    finalCheckpoint?: string;
+    error?: string;
+    resumed?: boolean;
+    resumedFrom?: string;
+}
+/**
+ * Setup product.md
+ */
+export declare function setupProductGuide(options: SetupOptions): Promise<SetupResult>;
+/**
+ * Setup guidelines.md
+ */
+export declare function setupGuidelines(options: SetupOptions): Promise<SetupResult>;
+/**
+ * Setup tech-stack.md
+ */
+export declare function setupTechStack(options: SetupOptions): Promise<SetupResult>;
+/**
+ * Setup styleguides.md
+ */
+export declare function setupStyleguides(options: SetupOptions): Promise<SetupResult>;
+/**
+ * Setup workflow.md
+ */
+export declare function setupWorkflow(options: SetupOptions): Promise<SetupResult>;
+/**
+ * Run full setup - generate all 5 documents in sequence
+ */
+export declare function runFullSetup(options: SetupOptions): Promise<FullSetupResult>;

package/dist/utils/setupIntegration.js

@@ -0,0 +1,179 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { detectProjectMaturity } from './projectMaturity.js';
+import { analyzeCodebase } from './codebaseAnalysis.js';
+import { generateBrownfieldQuestions, generateGreenfieldQuestions, } from './questionGenerator.js';
+import { generateDocument, } from './documentGeneration.js';
+const SECTION_ORDER = ['product', 'guidelines', 'tech-stack', 'styleguides', 'workflow'];
+const CHECKPOINT_TO_SECTION = {
+    '2.1_product_guide': 'product',
+    '2.2_product_guidelines': 'guidelines',
+    '2.3_tech_stack': 'tech-stack',
+    '2.4_code_styleguides': 'styleguides',
+    '2.5_workflow': 'workflow',
+};
+const SECTION_TO_FILENAME = {
+    'product': 'product.md',
+    'guidelines': 'guidelines.md',
+    'tech-stack': 'tech-stack.md',
+    'styleguides': 'styleguides.md',
+    'workflow': 'workflow.md',
+};
+/**
+ * Get current setup state from state file
+ */
+function getSetupState(outputDir) {
+    const statePath = path.join(outputDir, 'setup_state.json');
+    if (fs.existsSync(statePath)) {
+        const content = fs.readFileSync(statePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    return null;
+}
+/**
+ * Determine which sections need to be completed
+ */
+function getSectionsToComplete(state, resume) {
+    if (!resume || !state || !state.last_successful_step) {
+        return SECTION_ORDER;
+    }
+    const lastCheckpoint = state.last_successful_step;
+    const lastSection = CHECKPOINT_TO_SECTION[lastCheckpoint];
+    if (!lastSection) {
+        return SECTION_ORDER;
+    }
+    const lastIndex = SECTION_ORDER.indexOf(lastSection);
+    return SECTION_ORDER.slice(lastIndex + 1);
+}
+/**
+ * Setup a single section
+ */
+async function setupSection(section, options, maturity, analysis) {
+    try {
+        const isBrownfield = maturity === 'brownfield';
+        // Generate questions based on project maturity
+        const questions = isBrownfield
+            ? generateBrownfieldQuestions(section, analysis)
+            : generateGreenfieldQuestions(section);
+        // Prepare document generation options
+        const docOptions = {
+            section,
+            questions,
+            analysis,
+            responder: options.responder,
+            approvalFlow: options.approvalFlow,
+            outputPath: path.join(options.outputDir, SECTION_TO_FILENAME[section]),
+            maxRevisions: options.maxRevisions,
+            customInputPrompt: options.customInputPrompt,
+        };
+        // Generate document
+        const result = await generateDocument(docOptions);
+        return {
+            success: result.success,
+            checkpoint: result.checkpoint,
+            filePath: docOptions.outputPath,
+            isBrownfield,
+            autoGenerated: result.autoGenerated,
+            revisionCount: result.revisionCount,
+            error: result.error,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Setup product.md
+ */
+export async function setupProductGuide(options) {
+    const maturity = detectProjectMaturity(options.projectPath);
+    const analysis = analyzeCodebase(options.projectPath);
+    return setupSection('product', options, maturity, analysis);
+}
+/**
+ * Setup guidelines.md
+ */
+export async function setupGuidelines(options) {
+    const maturity = detectProjectMaturity(options.projectPath);
+    const analysis = analyzeCodebase(options.projectPath);
+    return setupSection('guidelines', options, maturity, analysis);
+}
+/**
+ * Setup tech-stack.md
+ */
+export async function setupTechStack(options) {
+    const maturity = detectProjectMaturity(options.projectPath);
+    const analysis = analyzeCodebase(options.projectPath);
+    return setupSection('tech-stack', options, maturity, analysis);
+}
+/**
+ * Setup styleguides.md
+ */
+export async function setupStyleguides(options) {
+    const maturity = detectProjectMaturity(options.projectPath);
+    const analysis = analyzeCodebase(options.projectPath);
+    return setupSection('styleguides', options, maturity, analysis);
+}
+/**
+ * Setup workflow.md
+ */
+export async function setupWorkflow(options) {
+    const maturity = detectProjectMaturity(options.projectPath);
+    const analysis = analyzeCodebase(options.projectPath);
+    return setupSection('workflow', options, maturity, analysis);
+}
+/**
+ * Run full setup - generate all 5 documents in sequence
+ */
+export async function runFullSetup(options) {
+    try {
+        // Ensure output directory exists
+        if (!fs.existsSync(options.outputDir)) {
+            fs.mkdirSync(options.outputDir, { recursive: true });
+        }
+        // Detect project maturity once
+        const maturity = detectProjectMaturity(options.projectPath);
+        const analysis = analyzeCodebase(options.projectPath);
+        // Check for resume
+        const state = getSetupState(options.outputDir);
+        const sectionsToComplete = getSectionsToComplete(state, options.resume || false);
+        const resumed = options.resume && state && sectionsToComplete.length < SECTION_ORDER.length;
+        const resumedFrom = resumed ? state.last_successful_step : undefined;
+        const documentsCreated = [];
+        let finalCheckpoint;
+        // Setup each section in order
+        for (const section of sectionsToComplete) {
+            const result = await setupSection(section, options, maturity, analysis);
+            if (!result.success) {
+                return {
+                    success: false,
+                    documentsCreated,
+                    error: result.error || `Failed to setup ${section}`,
+                    resumed,
+                    resumedFrom,
+                };
+            }
+            if (result.filePath) {
+                documentsCreated.push(result.filePath);
+            }
+            finalCheckpoint = result.checkpoint;
+        }
+        return {
+            success: true,
+            documentsCreated,
+            finalCheckpoint,
+            resumed,
+            resumedFrom,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            documentsCreated: [],
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}

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

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