@claudetools/cli 0.10.0 → 0.11.1

package/dist/onboard/questions.js

@@ -1,274 +1,427 @@
 // =============================================================================
-// Interactive Onboarding Questions
+// Interactive Onboarding Questions - Progressive Q&A System
 // =============================================================================
-// Dynamic Q&A flow to understand project context
+// Comprehensive questioning that adapts based on project type and user answers
 import prompts from 'prompts';
 import chalk from 'chalk';
-// Dynamic questions based on detected stack
-const QUESTIONS = [
-    {
-        id: 'projectDescription',
-        question: 'Briefly describe what this project does:',
+/**
+ * Run comprehensive interactive onboarding with progressive questions
+ */
+export async function runInteractiveOnboarding(stack, options = {}) {
+    const answers = {};
+    const isNew = options.isNewProject || stack.isEmpty;
+    console.log('');
+    console.log(chalk.dim('    ┌─ Project Understanding ─────────────────'));
+    console.log(chalk.dim('    │'));
+    console.log(chalk.dim('    │  Answer questions to help generate better docs.'));
+    console.log(chalk.dim('    │  Press Enter to skip, Ctrl+C to finish early.'));
+    console.log(chalk.dim('    │  The more you share, the better the results.'));
+    console.log(chalk.dim('    │'));
+    console.log(chalk.dim('    └──────────────────────────────────────────'));
+    console.log('');
+    // =========================================================================
+    // PHASE 1: Essential Questions (Always ask)
+    // =========================================================================
+    console.log(chalk.cyan.bold('    📋 Project Basics\n'));
+    // Q1: What is this project?
+    const descResponse = await safePrompt({
         type: 'text',
-        category: 'Overview',
-    },
-    {
-        id: 'primaryPurpose',
-        question: 'What is the primary purpose of this project?',
+        name: 'projectDescription',
+        message: isNew
+            ? 'What do you want to build? (describe your project)'
+            : 'What is this project? (brief description)',
+    });
+    if (descResponse?.projectDescription && typeof descResponse.projectDescription === 'string') {
+        answers.projectDescription = descResponse.projectDescription;
+    }
+    // Q2: Project type
+    const typeResponse = await safePrompt({
         type: 'select',
-        options: [
-            'Web application (user-facing)',
-            'API/Backend service',
-            'CLI tool',
-            'Library/Package',
-            'Mobile app',
-            'Desktop app',
-            'Documentation site',
-            'Internal tool',
-            'Other',
+        name: 'projectType',
+        message: 'What type of project is this?',
+        choices: [
+            { title: 'Web Application', value: 'web-app', description: 'Full-stack or frontend web app' },
+            { title: 'API / Backend', value: 'api', description: 'REST API, GraphQL, or backend service' },
+            { title: 'CLI Tool', value: 'cli', description: 'Command-line application' },
+            { title: 'Library / Package', value: 'library', description: 'Reusable code library' },
+            { title: 'Mobile App', value: 'mobile', description: 'iOS, Android, or cross-platform' },
+            { title: 'Desktop App', value: 'desktop', description: 'Electron, Tauri, etc.' },
+            { title: 'Monorepo', value: 'monorepo', description: 'Multiple packages in one repo' },
+            { title: 'Other', value: 'other', description: 'Something else' },
         ],
-        category: 'Overview',
-    },
-    {
-        id: 'targetAudience',
-        question: 'Who is the target audience?',
+        initial: guessProjectType(stack),
+    });
+    if (typeResponse?.projectType && typeof typeResponse.projectType === 'string') {
+        answers.projectType = typeResponse.projectType;
+    }
+    // Q3: Primary purpose - more specific based on type
+    const purposeResponse = await safePrompt({
+        type: 'text',
+        name: 'primaryPurpose',
+        message: 'What problem does this solve? (be specific)',
+    });
+    if (purposeResponse?.primaryPurpose && typeof purposeResponse.primaryPurpose === 'string') {
+        answers.primaryPurpose = purposeResponse.primaryPurpose;
+    }
+    // Q4: Key features (if they described the project)
+    if (answers.projectDescription || answers.primaryPurpose) {
+        const featuresResponse = await safePrompt({
+            type: 'text',
+            name: 'keyFeatures',
+            message: 'What are the main features? (comma-separated)',
+        });
+        if (featuresResponse?.keyFeatures && typeof featuresResponse.keyFeatures === 'string') {
+            answers.keyFeatures = featuresResponse.keyFeatures.split(',').map((f) => f.trim()).filter(Boolean);
+        }
+    }
+    // =========================================================================
+    // PHASE 2: Context Questions
+    // =========================================================================
+    console.log('');
+    console.log(chalk.cyan.bold('    👥 Context\n'));
+    // Q5: Target audience
+    const audienceResponse = await safePrompt({
         type: 'select',
-        options: [
-            'End users (consumers)',
-            'Business users (B2B)',
-            'Developers',
-            'Internal team',
-            'Mixed audience',
+        name: 'targetAudience',
+        message: 'Who will use this?',
+        choices: [
+            { title: 'End users (consumers)', value: 'consumers' },
+            { title: 'Business users (B2B)', value: 'business' },
+            { title: 'Developers', value: 'developers' },
+            { title: 'Internal team only', value: 'internal' },
+            { title: 'Mixed audience', value: 'mixed' },
         ],
-        category: 'Overview',
-    },
-    {
-        id: 'architectureStyle',
-        question: 'What architectural style does this project follow?',
+    });
+    if (audienceResponse?.targetAudience && typeof audienceResponse.targetAudience === 'string') {
+        answers.targetAudience = audienceResponse.targetAudience;
+    }
+    // Q6: Experience level - affects documentation style
+    const expResponse = await safePrompt({
         type: 'select',
-        options: [
-            'Monolithic',
-            'Microservices',
-            'Serverless',
-            'JAMstack',
-            'Modular monolith',
-            'Event-driven',
-            'Not sure / Mixed',
+        name: 'experienceLevel',
+        message: 'Your experience with this stack?',
+        choices: [
+            { title: 'Beginner', value: 'beginner', description: 'Learning as I go - need detailed explanations' },
+            { title: 'Intermediate', value: 'intermediate', description: 'Comfortable but still learning' },
+            { title: 'Expert', value: 'expert', description: 'Very experienced - just need references' },
         ],
-        category: 'Architecture',
-        condition: (stack) => stack.frameworks.length > 0,
-    },
-    {
-        id: 'stateManagement',
-        question: 'How is state managed in this project?',
+        initial: 1,
+    });
+    if (expResponse?.experienceLevel && typeof expResponse.experienceLevel === 'string') {
+        const level = expResponse.experienceLevel;
+        if (level === 'beginner' || level === 'intermediate' || level === 'expert') {
+            answers.experienceLevel = level;
+        }
+    }
+    // Q7: Team size
+    const teamResponse = await safePrompt({
         type: 'select',
-        options: [
-            'React Context',
-            'Redux / Redux Toolkit',
-            'Zustand',
-            'Jotai / Recoil',
-            'MobX',
-            'Server state only (TanStack Query/SWR)',
-            'URL state',
-            'No client state management',
-            'Other',
+        name: 'teamSize',
+        message: 'Team size?',
+        choices: [
+            { title: 'Solo developer', value: 'solo' },
+            { title: 'Small team (2-5)', value: 'small' },
+            { title: 'Medium team (6-15)', value: 'medium' },
+            { title: 'Large team (15+)', value: 'large' },
         ],
-        category: 'Architecture',
-        condition: (stack) => stack.frameworks.some(f => ['react', 'next', 'vue', 'svelte'].includes(f.name.toLowerCase())),
-    },
-    {
-        id: 'dataFetching',
-        question: 'How is data fetched in this project?',
-        type: 'select',
-        options: [
-            'TanStack Query (React Query)',
-            'SWR',
-            'tRPC',
-            'GraphQL (Apollo/urql)',
-            'REST with fetch/axios',
-            'Server Components (Next.js)',
-            'Server Actions',
-            'Mixed approach',
+    });
+    if (teamResponse?.teamSize && typeof teamResponse.teamSize === 'string') {
+        answers.teamSize = teamResponse.teamSize;
+    }
+    // =========================================================================
+    // PHASE 3: Technical Questions (based on project type)
+    // =========================================================================
+    const isWebOrMobile = ['web-app', 'mobile'].includes(answers.projectType || '');
+    const isApi = answers.projectType === 'api';
+    const hasFrontendFramework = stack.frameworks.some(f => ['react', 'next', 'vue', 'nuxt', 'svelte', 'sveltekit', 'angular'].includes(f.name.toLowerCase()));
+    if (isWebOrMobile || hasFrontendFramework) {
+        console.log('');
+        console.log(chalk.cyan.bold('    ⚙️ Technical Choices\n'));
+        // Architecture
+        const archResponse = await safePrompt({
+            type: 'select',
+            name: 'architectureStyle',
+            message: 'How is the code organized?',
+            choices: [
+                { title: 'Feature-based', value: 'feature-based', description: 'Folders by feature/domain' },
+                { title: 'Component-based', value: 'component-based', description: 'UI components hierarchy' },
+                { title: 'Layered', value: 'layered', description: 'UI → Business → Data layers' },
+                { title: 'Atomic Design', value: 'atomic', description: 'Atoms → Molecules → Organisms' },
+                { title: 'Not organized yet', value: 'none', description: 'Still figuring it out' },
+                { title: 'Not sure', value: 'unsure', description: 'Let AI analyze and document' },
+            ],
+        });
+        if (archResponse?.architectureStyle && typeof archResponse.architectureStyle === 'string') {
+            answers.architectureStyle = archResponse.architectureStyle;
+        }
+        // State management (frontend only)
+        if (hasFrontendFramework) {
+            const stateResponse = await safePrompt({
+                type: 'select',
+                name: 'stateManagement',
+                message: 'State management approach?',
+                choices: getStateManagementChoices(stack),
+            });
+            if (stateResponse?.stateManagement && typeof stateResponse.stateManagement === 'string') {
+                answers.stateManagement = stateResponse.stateManagement;
+            }
+            // Data fetching
+            const dataResponse = await safePrompt({
+                type: 'select',
+                name: 'dataFetching',
+                message: 'How do you fetch data?',
+                choices: [
+                    { title: 'TanStack Query', value: 'tanstack-query', description: 'Powerful async state' },
+                    { title: 'SWR', value: 'swr', description: 'Stale-while-revalidate' },
+                    { title: 'tRPC', value: 'trpc', description: 'End-to-end typesafe' },
+                    { title: 'Plain fetch/axios', value: 'fetch', description: 'Simple HTTP' },
+                    { title: 'GraphQL', value: 'graphql', description: 'Apollo, urql, etc.' },
+                    { title: 'Server Components', value: 'rsc', description: 'Next.js RSC' },
+                    { title: 'Not sure', value: 'unsure' },
+                ],
+                initial: detectDataFetchingChoice(stack),
+            });
+            if (dataResponse?.dataFetching && typeof dataResponse.dataFetching === 'string') {
+                answers.dataFetching = dataResponse.dataFetching;
+            }
+        }
+    }
+    // Authentication (API or web app)
+    if (isApi || isWebOrMobile) {
+        const authResponse = await safePrompt({
+            type: 'select',
+            name: 'authenticationMethod',
+            message: 'Authentication method?',
+            choices: [
+                { title: 'None yet', value: 'none' },
+                { title: 'JWT tokens', value: 'jwt' },
+                { title: 'Session cookies', value: 'session' },
+                { title: 'OAuth (Google, GitHub)', value: 'oauth' },
+                { title: 'Auth provider (Auth0, Clerk)', value: 'provider' },
+                { title: 'API keys', value: 'api-keys' },
+                { title: 'Not sure', value: 'unsure' },
+            ],
+        });
+        if (authResponse?.authenticationMethod && typeof authResponse.authenticationMethod === 'string') {
+            answers.authenticationMethod = authResponse.authenticationMethod;
+        }
+    }
+    // =========================================================================
+    // PHASE 4: Development Practices
+    // =========================================================================
+    console.log('');
+    console.log(chalk.cyan.bold('    🛠️ Development Practices\n'));
+    // Testing
+    const testResponse = await safePrompt({
+        type: 'multiselect',
+        name: 'testingApproach',
+        message: 'Testing approach? (Space to select)',
+        choices: [
+            { title: 'Unit tests', value: 'unit' },
+            { title: 'Integration tests', value: 'integration' },
+            { title: 'E2E tests (Playwright/Cypress)', value: 'e2e' },
+            { title: 'Component tests', value: 'component' },
+            { title: 'API tests', value: 'api' },
+            { title: 'No tests yet', value: 'none' },
         ],
-        category: 'Architecture',
-        condition: (stack) => stack.frameworks.some(f => ['react', 'next', 'vue', 'svelte'].includes(f.name.toLowerCase())),
-    },
-    {
-        id: 'testingApproach',
-        question: 'What testing approaches are used?',
+    });
+    if (testResponse?.testingApproach && Array.isArray(testResponse.testingApproach) && testResponse.testingApproach.length > 0) {
+        answers.testingApproach = testResponse.testingApproach;
+    }
+    // Coding conventions
+    const convResponse = await safePrompt({
         type: 'multiselect',
-        options: [
-            'Unit tests',
-            'Integration tests',
-            'End-to-end tests (Playwright/Cypress)',
-            'Component tests',
-            'API tests',
-            'Snapshot tests',
-            'No tests yet',
+        name: 'codingConventions',
+        message: 'Coding conventions? (Space to select)',
+        choices: [
+            { title: 'TypeScript strict mode', value: 'typescript-strict', selected: hasTypeScript(stack) },
+            { title: 'ESLint + Prettier', value: 'eslint-prettier', selected: hasEslint(stack) },
+            { title: 'Conventional commits', value: 'conventional-commits' },
+            { title: 'Feature folders', value: 'feature-folders' },
+            { title: 'Barrel exports (index.ts)', value: 'barrel-exports' },
+            { title: 'No strict conventions', value: 'none' },
         ],
-        category: 'Quality',
-    },
-    {
-        id: 'codingConventions',
-        question: 'Which coding conventions does this project follow?',
+    });
+    if (convResponse?.codingConventions && Array.isArray(convResponse.codingConventions) && convResponse.codingConventions.length > 0) {
+        answers.codingConventions = convResponse.codingConventions;
+    }
+    // Important patterns
+    const patternResponse = await safePrompt({
         type: 'multiselect',
-        options: [
-            'Functional components only (no classes)',
-            'Strict TypeScript (no any)',
-            'Named exports over default exports',
-            'Barrel files (index.ts re-exports)',
-            'Co-located tests (__tests__ folders)',
-            'Feature-based folder structure',
-            'Atomic design (atoms/molecules/organisms)',
-            'Domain-driven design',
+        name: 'importantPatterns',
+        message: 'Key patterns used? (Space to select)',
+        choices: [
+            { title: 'Custom hooks', value: 'custom-hooks' },
+            { title: 'Compound components', value: 'compound-components' },
+            { title: 'Repository pattern', value: 'repository' },
+            { title: 'Factory pattern', value: 'factory' },
+            { title: 'Dependency injection', value: 'di' },
+            { title: 'None specifically', value: 'none' },
         ],
-        category: 'Conventions',
-    },
-    {
-        id: 'importantPatterns',
-        question: 'Which patterns are important in this codebase?',
+    });
+    if (patternResponse?.importantPatterns && Array.isArray(patternResponse.importantPatterns) && patternResponse.importantPatterns.length > 0) {
+        answers.importantPatterns = patternResponse.importantPatterns;
+    }
+    // =========================================================================
+    // PHASE 5: Priorities and Challenges
+    // =========================================================================
+    console.log('');
+    console.log(chalk.cyan.bold('    🎯 Current Focus\n'));
+    // Priorities
+    const priorityResponse = await safePrompt({
         type: 'multiselect',
-        options: [
-            'Repository pattern',
-            'Factory pattern',
-            'Dependency injection',
-            'Composition over inheritance',
-            'Custom hooks for logic reuse',
-            'Higher-order components',
-            'Render props',
-            'Compound components',
-            'None specifically',
+        name: 'currentPriorities',
+        message: 'Current priorities? (pick top 3)',
+        choices: [
+            { title: 'Get MVP working', value: 'mvp' },
+            { title: 'Ship new features', value: 'features' },
+            { title: 'Fix bugs', value: 'bugs' },
+            { title: 'Improve performance', value: 'performance' },
+            { title: 'Add tests', value: 'testing' },
+            { title: 'Refactor/cleanup', value: 'refactor' },
+            { title: 'Better documentation', value: 'docs' },
         ],
-        category: 'Patterns',
-    },
-    {
-        id: 'knownChallenges',
-        question: 'Any known challenges or areas needing attention?',
+        max: 3,
+    });
+    if (priorityResponse?.currentPriorities && Array.isArray(priorityResponse.currentPriorities) && priorityResponse.currentPriorities.length > 0) {
+        answers.currentPriorities = priorityResponse.currentPriorities;
+    }
+    // Challenges - free text for rich context
+    const challengeResponse = await safePrompt({
         type: 'text',
-        category: 'Context',
-    },
-    {
-        id: 'teamSize',
-        question: 'Team size working on this project?',
-        type: 'select',
-        options: [
-            'Solo developer',
-            'Small team (2-5)',
-            'Medium team (6-15)',
-            'Large team (15+)',
-        ],
-        category: 'Context',
-    },
-];
-export async function runInteractiveOnboarding(stack, options = {}) {
-    const answers = {};
-    let questionCount = 0;
-    let currentCategory = '';
-    console.log(chalk.dim('\n  Answer a few questions to help generate better documentation.'));
-    console.log(chalk.dim('  Press Enter to skip any question.\n'));
-    for (const q of QUESTIONS) {
-        // Check condition
-        if (q.condition && !q.condition(stack, answers)) {
-            continue;
-        }
-        // Show category header
-        if (q.category !== currentCategory) {
-            currentCategory = q.category;
-            console.log(chalk.cyan.bold(`\n  ${currentCategory}`));
+        name: 'knownChallenges',
+        message: 'Any pain points or challenges?',
+    });
+    if (challengeResponse?.knownChallenges && typeof challengeResponse.knownChallenges === 'string') {
+        answers.knownChallenges = challengeResponse.knownChallenges;
+    }
+    // =========================================================================
+    // PHASE 6: New Project Stack (if empty project)
+    // =========================================================================
+    if (isNew && stack.isEmpty) {
+        console.log('');
+        console.log(chalk.cyan.bold('    🚀 Stack Setup\n'));
+        const recResponse = await safePrompt({
+            type: 'confirm',
+            name: 'needsRecommendation',
+            message: 'Want AI to recommend a tech stack?',
+            initial: true,
+        });
+        if (recResponse?.needsRecommendation !== undefined && typeof recResponse.needsRecommendation === 'boolean') {
+            answers.needsRecommendation = recResponse.needsRecommendation;
         }
-        questionCount++;
-        try {
-            if (q.type === 'text') {
-                const { response } = await prompts({
-                    type: 'text',
-                    name: 'response',
-                    message: q.question,
-                }, { onCancel: () => { throw new Error('cancelled'); } });
-                if (response && response.trim()) {
-                    answers[q.id] = response.trim();
-                }
-            }
-            else if (q.type === 'select') {
-                const { selected } = await prompts({
-                    type: 'select',
-                    name: 'selected',
-                    message: q.question,
-                    choices: [
-                        ...(q.options || []).map(opt => ({ title: opt, value: opt })),
-                        { title: chalk.dim('Skip'), value: '__skip__' },
-                    ],
-                }, { onCancel: () => { throw new Error('cancelled'); } });
-                if (selected && selected !== '__skip__') {
-                    answers[q.id] = selected;
-                }
+        if (!answers.needsRecommendation) {
+            const stackResponse = await safePrompt({
+                type: 'text',
+                name: 'preferredStack',
+                message: 'What stack do you want?',
+            });
+            if (stackResponse?.preferredStack && typeof stackResponse.preferredStack === 'string') {
+                answers.preferredStack = stackResponse.preferredStack;
             }
-            else if (q.type === 'multiselect') {
-                const { selected } = await prompts({
-                    type: 'multiselect',
-                    name: 'selected',
-                    message: q.question,
-                    choices: (q.options || []).map(opt => ({ title: opt, value: opt })),
-                    hint: '- Space to select, Enter to confirm',
-                }, { onCancel: () => { throw new Error('cancelled'); } });
-                if (selected && selected.length > 0) {
-                    answers[q.id] = selected;
-                }
-            }
-        }
-        catch {
-            // User cancelled
-            console.log(chalk.dim('\n  Onboarding cancelled. Using auto-detected information only.\n'));
-            break;
         }
     }
-    if (options.verbose) {
-        console.log(chalk.dim(`\n  Collected ${Object.keys(answers).length} answers from ${questionCount} questions.`));
-    }
+    console.log('');
+    const answeredCount = Object.keys(answers).filter(k => answers[k] !== undefined).length;
+    console.log(chalk.dim(`    Collected ${answeredCount} responses. Generating documentation...\n`));
     return answers;
 }
+// =========================================================================
+// Safe prompt wrapper - handles cancellation gracefully
+// =========================================================================
+async function safePrompt(config) {
+    try {
+        const response = await prompts(config, {
+            onCancel: () => {
+                throw new Error('cancelled');
+            },
+        });
+        return response;
+    }
+    catch {
+        return null;
+    }
+}
+// =========================================================================
+// Helper Functions
+// =========================================================================
+function guessProjectType(stack) {
+    if (stack.frameworks.some(f => ['next', 'nuxt', 'sveltekit', 'remix', 'astro'].includes(f.name.toLowerCase()))) {
+        return 0; // web-app
+    }
+    if (stack.frameworks.some(f => ['express', 'fastify', 'hono', 'nestjs', 'koa'].includes(f.name.toLowerCase()))) {
+        return 1; // api
+    }
+    if (stack.frameworks.some(f => ['react-native', 'expo'].includes(f.name.toLowerCase()))) {
+        return 4; // mobile
+    }
+    if (stack.frameworks.some(f => ['electron', 'tauri'].includes(f.name.toLowerCase()))) {
+        return 5; // desktop
+    }
+    return 0;
+}
+function getStateManagementChoices(stack) {
+    const choices = [
+        { title: 'React Context / useState', value: 'context' },
+        { title: 'Zustand', value: 'zustand' },
+        { title: 'Jotai', value: 'jotai' },
+        { title: 'Redux Toolkit', value: 'redux' },
+        { title: 'Server state only', value: 'server-state' },
+        { title: 'Not sure', value: 'unsure' },
+    ];
+    // Detect from stack
+    const detected = stack.libraries.find(l => ['zustand', 'jotai', 'redux', '@reduxjs/toolkit', 'recoil', 'mobx'].includes(l.name));
+    if (detected) {
+        const name = detected.name.replace('@reduxjs/toolkit', 'redux');
+        const idx = choices.findIndex(c => c.value === name);
+        if (idx > 0) {
+            const [item] = choices.splice(idx, 1);
+            if (item)
+                choices.unshift(item);
+        }
+    }
+    return choices;
+}
+function detectDataFetchingChoice(stack) {
+    if (stack.libraries.some(l => l.name.includes('tanstack') || l.name.includes('react-query')))
+        return 0;
+    if (stack.libraries.some(l => l.name === 'swr'))
+        return 1;
+    if (stack.libraries.some(l => l.name.includes('trpc')))
+        return 2;
+    if (stack.frameworks.some(f => f.name === 'next'))
+        return 5;
+    return 3;
+}
+function hasTypeScript(stack) {
+    return stack.primaryLanguage === 'typescript';
+}
+function hasEslint(stack) {
+    return stack.devTools.some(t => t.name === 'eslint' || t.name === 'prettier');
+}
+/**
+ * Format answers for documentation
+ */
 export function formatAnswersForDocs(answers) {
     const sections = [];
     if (answers.projectDescription) {
-        sections.push(`## Project Description\n\n${answers.projectDescription}`);
+        sections.push(`## Project Overview\n\n${answers.projectDescription}`);
     }
-    if (answers.primaryPurpose || answers.targetAudience) {
-        let overview = '## Overview\n\n';
-        if (answers.primaryPurpose) {
-            overview += `**Purpose:** ${answers.primaryPurpose}\n`;
-        }
-        if (answers.targetAudience) {
-            overview += `**Target Audience:** ${answers.targetAudience}\n`;
-        }
-        sections.push(overview);
+    if (answers.primaryPurpose) {
+        sections.push(`## Purpose\n\n${answers.primaryPurpose}`);
     }
-    if (answers.architectureStyle || answers.stateManagement || answers.dataFetching) {
-        let arch = '## Architecture\n\n';
-        if (answers.architectureStyle) {
-            arch += `**Style:** ${answers.architectureStyle}\n`;
-        }
-        if (answers.stateManagement) {
-            arch += `**State Management:** ${answers.stateManagement}\n`;
-        }
-        if (answers.dataFetching) {
-            arch += `**Data Fetching:** ${answers.dataFetching}\n`;
-        }
-        sections.push(arch);
-    }
-    if (answers.codingConventions && Array.isArray(answers.codingConventions) && answers.codingConventions.length > 0) {
-        sections.push(`## Coding Conventions\n\n${answers.codingConventions.map((c) => `- ${c}`).join('\n')}`);
+    if (answers.keyFeatures?.length) {
+        sections.push(`## Key Features\n\n${answers.keyFeatures.map(f => `- ${f}`).join('\n')}`);
     }
-    if (answers.importantPatterns && Array.isArray(answers.importantPatterns) && answers.importantPatterns.length > 0) {
-        sections.push(`## Important Patterns\n\n${answers.importantPatterns.map((p) => `- ${p}`).join('\n')}`);
+    if (answers.targetAudience) {
+        sections.push(`## Target Audience\n\n${answers.targetAudience}`);
     }
-    if (answers.testingApproach && Array.isArray(answers.testingApproach) && answers.testingApproach.length > 0) {
-        sections.push(`## Testing\n\n${answers.testingApproach.map((t) => `- ${t}`).join('\n')}`);
+    if (answers.architectureStyle && answers.architectureStyle !== 'unsure') {
+        sections.push(`## Architecture\n\n**Style:** ${answers.architectureStyle}`);
     }
     if (answers.knownChallenges) {
         sections.push(`## Known Challenges\n\n${answers.knownChallenges}`);
     }
-    if (answers.teamSize) {
-        sections.push(`## Team\n\n**Size:** ${answers.teamSize}`);
-    }
     return sections.join('\n\n');
 }
 //# sourceMappingURL=questions.js.map