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

package/dist/utils/questionGenerator.d.ts

@@ -0,0 +1,51 @@
+import { CodebaseAnalysis } from './codebaseAnalysis.js';
+/**
+ * Question Generation Engine
+ *
+ * Generates context-aware questions for the CDD setup process:
+ * - Classifies questions as Additive (multiple) or Exclusive (single choice)
+ * - Generates brownfield questions based on codebase analysis
+ * - Generates greenfield questions based on common patterns
+ * - Creates 5 answer options (A-C: contextual, D: custom, E: autogenerate)
+ *
+ * Based on reference implementations:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+export type QuestionType = 'additive' | 'exclusive';
+export type Section = 'product' | 'guidelines' | 'tech-stack' | 'styleguides' | 'workflow';
+export interface Question {
+    id: string;
+    text: string;
+    type: QuestionType;
+    section: Section;
+    options: string[];
+}
+/**
+ * Classify question type based on question text
+ */
+export declare function classifyQuestionType(questionText: string): QuestionType;
+/**
+ * Add suffix to question text based on type
+ */
+export declare function addQuestionSuffix(questionText: string, type: QuestionType): string;
+/**
+ * Generate brownfield questions based on codebase analysis
+ */
+export declare function generateBrownfieldQuestions(section: Section, analysis: CodebaseAnalysis): Question[];
+/**
+ * Generate greenfield questions based on common patterns
+ */
+export declare function generateGreenfieldQuestions(section: Section): Question[];
+/**
+ * Generate answer options (always 5 options: A-C contextual, D custom, E autogenerate)
+ */
+export declare function generateAnswerOptions(contextualOptions: string[], section: Section): string[];
+/**
+ * Format question for display with lettered options
+ */
+export declare function formatQuestion(question: Question, questionNumber: number): string;
+/**
+ * Main function: Generate questions for a section
+ */
+export declare function generateQuestionsForSection(section: Section, projectMaturity: 'brownfield' | 'greenfield', codebaseAnalysis?: CodebaseAnalysis): Question[];

package/dist/utils/questionGenerator.js

@@ -0,0 +1,535 @@
+/**
+ * Ensure question has exactly 5 options (A-E)
+ * Options D and E are always "Custom" and "Auto-generate"
+ */
+function ensureFiveOptions(question) {
+    const options = [...question.options];
+    // Trim to 3 contextual options (A, B, C)
+    while (options.length > 3) {
+        options.pop();
+    }
+    // Add D (Custom) and E (Auto-generate)
+    options.push('Enter custom text');
+    options.push(`Auto-generate ${question.section} from context`);
+    return {
+        ...question,
+        options,
+    };
+}
+/**
+ * Classify question type based on question text
+ */
+export function classifyQuestionType(questionText) {
+    const lowerText = questionText.toLowerCase();
+    // Exclusive indicators (single choice)
+    const exclusiveKeywords = [
+        'what is the',
+        'which one',
+        'select one',
+        'choose one',
+        'primary',
+        'main',
+        'or',
+    ];
+    // Additive indicators (multiple choices)
+    const additiveKeywords = [
+        'what are',
+        'which',
+        'all',
+        'select all',
+        'features',
+        'capabilities',
+        'and',
+    ];
+    // Check for exclusive indicators first (more specific)
+    for (const keyword of exclusiveKeywords) {
+        if (lowerText.includes(keyword)) {
+            return 'exclusive';
+        }
+    }
+    // Check for additive indicators
+    for (const keyword of additiveKeywords) {
+        if (lowerText.includes(keyword)) {
+            return 'additive';
+        }
+    }
+    // Default to exclusive for safety
+    return 'exclusive';
+}
+/**
+ * Add suffix to question text based on type
+ */
+export function addQuestionSuffix(questionText, type) {
+    if (type === 'additive') {
+        return `${questionText} (Select all that apply)`;
+    }
+    return questionText;
+}
+/**
+ * Generate brownfield questions based on codebase analysis
+ */
+export function generateBrownfieldQuestions(section, analysis) {
+    const questions = [];
+    switch (section) {
+        case 'product':
+            questions.push(...generateProductQuestionsBrownfield(analysis));
+            break;
+        case 'guidelines':
+            questions.push(...generateGuidelinesQuestionsBrownfield(analysis));
+            break;
+        case 'tech-stack':
+            questions.push(...generateTechStackQuestionsBrownfield(analysis));
+            break;
+        case 'styleguides':
+            questions.push(...generateStyleguidesQuestionsBrownfield(analysis));
+            break;
+        case 'workflow':
+            questions.push(...generateWorkflowQuestionsBrownfield(analysis));
+            break;
+    }
+    // Ensure all questions have exactly 5 options (A-E)
+    const questionsWithFiveOptions = questions.map(ensureFiveOptions);
+    // Limit to max 5 questions per section
+    return questionsWithFiveOptions.slice(0, 5);
+}
+/**
+ * Generate greenfield questions based on common patterns
+ */
+export function generateGreenfieldQuestions(section) {
+    let questions = [];
+    switch (section) {
+        case 'product':
+            questions = generateProductQuestionsGreenfield();
+            break;
+        case 'guidelines':
+            questions = generateGuidelinesQuestionsGreenfield();
+            break;
+        case 'tech-stack':
+            questions = generateTechStackQuestionsGreenfield();
+            break;
+        case 'styleguides':
+            questions = generateStyleguidesQuestionsGreenfield();
+            break;
+        case 'workflow':
+            questions = generateWorkflowQuestionsGreenfield();
+            break;
+    }
+    // Ensure all questions have exactly 5 options (A-E)
+    const questionsWithFiveOptions = questions.map(ensureFiveOptions);
+    // Limit to max 5 questions per section
+    return questionsWithFiveOptions.slice(0, 5);
+}
+/**
+ * Product section - Brownfield
+ */
+function generateProductQuestionsBrownfield(analysis) {
+    const questions = [];
+    // Question 1: Refine project goal
+    const goalHint = analysis.projectGoal || 'this project';
+    questions.push({
+        id: 'product_goal',
+        text: `Based on "${goalHint}", what is the primary goal?`,
+        type: 'exclusive',
+        section: 'product',
+        options: [
+            'Deliver a production-ready application',
+            'Create a proof-of-concept or prototype',
+            'Build an internal tool or utility',
+        ],
+    });
+    // Question 2: Target users
+    questions.push({
+        id: 'product_users',
+        text: 'Who are the target users?',
+        type: 'additive',
+        section: 'product',
+        options: [
+            'End consumers (B2C)',
+            'Business clients (B2B)',
+            'Internal team members',
+        ],
+    });
+    // Question 3: Key features
+    questions.push({
+        id: 'product_features',
+        text: 'What are the key features to document?',
+        type: 'additive',
+        section: 'product',
+        options: generateContextualFeatures(analysis),
+    });
+    return questions;
+}
+/**
+ * Product section - Greenfield
+ */
+function generateProductQuestionsGreenfield() {
+    return [
+        {
+            id: 'product_goal',
+            text: 'What is the primary goal of this project?',
+            type: 'exclusive',
+            section: 'product',
+            options: [
+                'Deliver a production-ready application',
+                'Create a proof-of-concept or prototype',
+                'Build an internal tool or utility',
+            ],
+        },
+        {
+            id: 'product_users',
+            text: 'Who are the target users?',
+            type: 'additive',
+            section: 'product',
+            options: [
+                'End consumers (B2C)',
+                'Business clients (B2B)',
+                'Internal team members',
+            ],
+        },
+        {
+            id: 'product_features',
+            text: 'What are the core features?',
+            type: 'additive',
+            section: 'product',
+            options: [
+                'User authentication and authorization',
+                'Data management (CRUD operations)',
+                'Real-time notifications or updates',
+            ],
+        },
+    ];
+}
+/**
+ * Guidelines section - Brownfield
+ */
+function generateGuidelinesQuestionsBrownfield(analysis) {
+    return [
+        {
+            id: 'guidelines_tone',
+            text: 'What tone should the documentation use?',
+            type: 'exclusive',
+            section: 'guidelines',
+            options: [
+                'Professional and formal',
+                'Friendly and conversational',
+                'Technical and precise',
+            ],
+        },
+        {
+            id: 'guidelines_audience',
+            text: 'Who is the primary audience for documentation?',
+            type: 'exclusive',
+            section: 'guidelines',
+            options: [
+                'Developers (internal team)',
+                'External contributors (open source)',
+                'End users (product documentation)',
+            ],
+        },
+    ];
+}
+/**
+ * Guidelines section - Greenfield
+ */
+function generateGuidelinesQuestionsGreenfield() {
+    return [
+        {
+            id: 'guidelines_tone',
+            text: 'What tone should the documentation use?',
+            type: 'exclusive',
+            section: 'guidelines',
+            options: [
+                'Professional and formal',
+                'Friendly and conversational',
+                'Technical and precise',
+            ],
+        },
+        {
+            id: 'guidelines_audience',
+            text: 'Who is the primary audience for documentation?',
+            type: 'exclusive',
+            section: 'guidelines',
+            options: [
+                'Developers (internal team)',
+                'External contributors (open source)',
+                'End users (product documentation)',
+            ],
+        },
+    ];
+}
+/**
+ * Tech Stack section - Brownfield
+ */
+function generateTechStackQuestionsBrownfield(analysis) {
+    const questions = [];
+    // Generate language-specific question
+    const languages = Object.keys(analysis.languages);
+    if (languages.length > 0) {
+        const topLanguages = languages.slice(0, 3);
+        questions.push({
+            id: 'techstack_languages',
+            text: 'Confirm the primary programming languages:',
+            type: 'additive',
+            section: 'tech-stack',
+            options: topLanguages.length >= 3 ? topLanguages : [
+                ...topLanguages,
+                ...['TypeScript', 'Python', 'Go'].filter(l => !topLanguages.includes(l)),
+            ].slice(0, 3),
+        });
+    }
+    // Generate framework question
+    const allFrameworks = [...analysis.frameworks.frontend, ...analysis.frameworks.backend];
+    if (allFrameworks.length > 0) {
+        // Ensure we have exactly 3 options
+        const frameworkOptions = allFrameworks.slice(0, 3);
+        while (frameworkOptions.length < 3) {
+            const fallbacks = ['React', 'Express', 'Django', 'Vue', 'Spring Boot'];
+            const missing = fallbacks.find(f => !frameworkOptions.includes(f));
+            if (missing)
+                frameworkOptions.push(missing);
+            else
+                break;
+        }
+        questions.push({
+            id: 'techstack_frameworks',
+            text: 'Confirm the frameworks in use:',
+            type: 'additive',
+            section: 'tech-stack',
+            options: frameworkOptions.slice(0, 3),
+        });
+    }
+    // Generate database question
+    if (analysis.databases.length > 0) {
+        // Ensure we have exactly 3 options
+        const dbOptions = analysis.databases.slice(0, 3);
+        while (dbOptions.length < 3) {
+            const fallbacks = ['PostgreSQL', 'MySQL', 'MongoDB', 'Redis'];
+            const missing = fallbacks.find(f => !dbOptions.includes(f));
+            if (missing)
+                dbOptions.push(missing);
+            else
+                break;
+        }
+        questions.push({
+            id: 'techstack_databases',
+            text: 'Confirm the databases in use:',
+            type: 'additive',
+            section: 'tech-stack',
+            options: dbOptions.slice(0, 3),
+        });
+    }
+    // Generate architecture question
+    if (analysis.architecture.length > 0 && !analysis.architecture.includes('unknown')) {
+        const archOptions = analysis.architecture.map(arch => {
+            return arch.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+        });
+        // Ensure we have exactly 3 options
+        while (archOptions.length < 3) {
+            const fallbacks = ['Monorepo', 'Microservices', 'MVC', 'Layered Architecture'];
+            const missing = fallbacks.find(f => !archOptions.includes(f));
+            if (missing)
+                archOptions.push(missing);
+            else
+                break;
+        }
+        questions.push({
+            id: 'techstack_architecture',
+            text: 'Confirm the architectural pattern:',
+            type: 'additive',
+            section: 'tech-stack',
+            options: archOptions.slice(0, 3),
+        });
+    }
+    return questions;
+}
+/**
+ * Tech Stack section - Greenfield
+ */
+function generateTechStackQuestionsGreenfield() {
+    return [
+        {
+            id: 'techstack_languages',
+            text: 'What programming languages will you use?',
+            type: 'additive',
+            section: 'tech-stack',
+            options: [
+                'TypeScript',
+                'Python',
+                'Go',
+            ],
+        },
+        {
+            id: 'techstack_frontend',
+            text: 'What frontend framework will you use?',
+            type: 'exclusive',
+            section: 'tech-stack',
+            options: [
+                'React',
+                'Vue',
+                'Angular',
+            ],
+        },
+        {
+            id: 'techstack_backend',
+            text: 'What backend framework will you use?',
+            type: 'exclusive',
+            section: 'tech-stack',
+            options: [
+                'Express (Node.js)',
+                'Django (Python)',
+                'Spring Boot (Java)',
+            ],
+        },
+    ];
+}
+/**
+ * Styleguides section - Brownfield
+ */
+function generateStyleguidesQuestionsBrownfield(analysis) {
+    const languages = Object.keys(analysis.languages);
+    const primaryLanguage = languages[0] || 'JavaScript';
+    return [
+        {
+            id: 'styleguides_choice',
+            text: `What code style guide should be used for ${primaryLanguage}?`,
+            type: 'exclusive',
+            section: 'styleguides',
+            options: getStyleguideOptionsForLanguage(primaryLanguage),
+        },
+    ];
+}
+/**
+ * Styleguides section - Greenfield
+ */
+function generateStyleguidesQuestionsGreenfield() {
+    return [
+        {
+            id: 'styleguides_choice',
+            text: 'What code style guide should be used?',
+            type: 'exclusive',
+            section: 'styleguides',
+            options: [
+                'Airbnb JavaScript Style Guide',
+                'Google Style Guides',
+                'Standard JS',
+            ],
+        },
+    ];
+}
+/**
+ * Workflow section - Brownfield & Greenfield (similar)
+ */
+function generateWorkflowQuestionsBrownfield(analysis) {
+    return generateWorkflowQuestionsGreenfield();
+}
+function generateWorkflowQuestionsGreenfield() {
+    return [
+        {
+            id: 'workflow_testing',
+            text: 'What testing approach will you follow?',
+            type: 'exclusive',
+            section: 'workflow',
+            options: [
+                'Test-Driven Development (TDD)',
+                'Behavior-Driven Development (BDD)',
+                'Write tests after implementation',
+            ],
+        },
+        {
+            id: 'workflow_commits',
+            text: 'What commit message convention will you use?',
+            type: 'exclusive',
+            section: 'workflow',
+            options: [
+                'Conventional Commits (feat:, fix:, etc.)',
+                'Semantic versioning triggers',
+                'Freeform descriptive messages',
+            ],
+        },
+    ];
+}
+/**
+ * Helper: Generate contextual features from analysis
+ */
+function generateContextualFeatures(analysis) {
+    const features = [];
+    if (analysis.frameworks.frontend.length > 0) {
+        features.push('User interface and interactions');
+    }
+    if (analysis.frameworks.backend.length > 0) {
+        features.push('API endpoints and business logic');
+    }
+    if (analysis.databases.length > 0) {
+        features.push('Data persistence and retrieval');
+    }
+    // Fill remaining with generic options
+    const generic = [
+        'Authentication and authorization',
+        'Real-time updates',
+        'Third-party integrations',
+    ];
+    for (const g of generic) {
+        if (features.length >= 3)
+            break;
+        if (!features.includes(g))
+            features.push(g);
+    }
+    return features.slice(0, 3);
+}
+/**
+ * Helper: Get styleguide options for language
+ */
+function getStyleguideOptionsForLanguage(language) {
+    const guides = {
+        'TypeScript': ['Airbnb TypeScript Style Guide', 'Google TypeScript Style Guide', 'Standard TS'],
+        'JavaScript': ['Airbnb JavaScript Style Guide', 'Google JavaScript Style Guide', 'Standard JS'],
+        'Python': ['PEP 8', 'Google Python Style Guide', 'Black (opinionated)'],
+        'Go': ['Effective Go', 'Uber Go Style Guide', 'Go standard formatting'],
+        'Rust': ['Rust Style Guide', 'Rustfmt (official)', 'Clippy lints'],
+        'Ruby': ['Ruby Style Guide', 'RuboCop defaults', 'GitHub Ruby Style Guide'],
+        'Java': ['Google Java Style Guide', 'Oracle Code Conventions', 'Spring conventions'],
+    };
+    return guides[language] || ['Google Style Guides', 'Language-specific standard', 'Team custom guide'];
+}
+/**
+ * Generate answer options (always 5 options: A-C contextual, D custom, E autogenerate)
+ */
+export function generateAnswerOptions(contextualOptions, section) {
+    // Ensure exactly 3 contextual options
+    const options = contextualOptions.slice(0, 3);
+    while (options.length < 3) {
+        options.push(`Option ${options.length + 1}`);
+    }
+    // Truncate options to max 80 characters
+    const truncated = options.map(opt => opt.length > 80 ? opt.substring(0, 77) + '...' : opt);
+    // Add standard D and E options
+    truncated.push('Type your own answer');
+    truncated.push(`Autogenerate and review ${section}.md`);
+    return truncated;
+}
+/**
+ * Format question for display with lettered options
+ */
+export function formatQuestion(question, questionNumber) {
+    const suffix = question.type === 'additive' ? ' (Select all that apply)' : '';
+    const lines = [];
+    lines.push(`Question ${questionNumber}: ${question.text}${suffix}`);
+    lines.push('');
+    const letters = ['A', 'B', 'C', 'D', 'E'];
+    const options = generateAnswerOptions(question.options, question.section);
+    options.forEach((option, index) => {
+        lines.push(`${letters[index]}) ${option}`);
+    });
+    return lines.join('\n');
+}
+/**
+ * Main function: Generate questions for a section
+ */
+export function generateQuestionsForSection(section, projectMaturity, codebaseAnalysis) {
+    if (projectMaturity === 'brownfield' && codebaseAnalysis) {
+        return generateBrownfieldQuestions(section, codebaseAnalysis);
+    }
+    else {
+        return generateGreenfieldQuestions(section);
+    }
+}

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

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