@claudetools/cli 0.12.0 → 0.13.1

package/dist/onboard/index.js

@@ -6,18 +6,16 @@ import chalk from 'chalk';
 import ora from 'ora';
 import prompts from 'prompts';
 import { existsSync, writeFileSync, mkdirSync, readFileSync } from 'fs';
+import { execSync } from 'child_process';
 import { join, basename } from 'path';
 import { detectStack } from './stack-detector.js';
 import { buildDocs } from './docs-builder.js';
 import { buildAgentsMd, writeAgentsMd } from './agents-md-builder.js';
 import { runInteractiveOnboarding } from './questions.js';
-import { isClaudeCliAvailable, analyzeWithClaude } from './claude-inference.js';
-// Progress bar helper
-function progressBar(current, total, width = 20) {
-    const filled = Math.round((current / total) * width);
-    const empty = width - filled;
-    return chalk.cyan('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
-}
+import { isClaudeCliAvailable, runClaudeAnalysis } from './claude-inference.js';
+// =============================================================================
+// Main Onboarding Flow
+// =============================================================================
 /**
  * Run the complete onboarding workflow
  */
@@ -33,351 +31,494 @@ export async function runOnboard(projectPath, options = {}) {
     console.log(chalk.dim(`  Project: ${chalk.white(projectName)}`));
     console.log(chalk.dim(`  Path: ${projectPath}`));
     console.log('');
+    // ==========================================================================
     // Phase 1: Stack Detection
-    console.log(chalk.cyan('  ▸ Phase 1/5: Stack Detection'));
+    // ==========================================================================
+    console.log(chalk.cyan('  ▸ Phase 1/4: Stack Detection'));
     const stackSpinner = ora({ text: 'Scanning project files...', indent: 4 }).start();
     const stack = detectStack(projectPath);
-    // Handle empty/new projects
     if (stack.isEmpty) {
-        stackSpinner.warn(chalk.yellow('No project files detected'));
-        console.log('');
-        console.log(chalk.dim('    ┌─ New/Empty Project ────────────────────'));
-        console.log(chalk.dim('    │'));
-        console.log(chalk.dim('    │  ') + chalk.yellow('No package.json, requirements.txt, go.mod,'));
-        console.log(chalk.dim('    │  ') + chalk.yellow('or Cargo.toml found.'));
-        console.log(chalk.dim('    │'));
-        console.log(chalk.dim('    │  ') + chalk.white('This appears to be a new or empty project.'));
-        console.log(chalk.dim('    │'));
-        console.log(chalk.dim('    └──────────────────────────────────────'));
-        console.log('');
-        const { continueEmpty } = await prompts({
-            type: 'confirm',
-            name: 'continueEmpty',
-            message: '    Continue with minimal setup for new project?',
-            initial: true,
-        });
-        if (!continueEmpty) {
-            console.log('');
-            console.log(chalk.dim('  Tip: Initialize your project first, then run onboarding:'));
-            console.log(chalk.dim('    • npm init / pnpm init / yarn init'));
-            console.log(chalk.dim('    • npx create-next-app'));
-            console.log(chalk.dim('    • pip init / poetry init'));
-            console.log(chalk.dim('    • go mod init'));
-            console.log(chalk.dim('    • cargo init'));
-            console.log('');
-            return;
-        }
-        console.log(chalk.dim('    Proceeding with minimal setup...'));
-        console.log('');
+        stackSpinner.info(chalk.cyan('New project - let\'s set it up'));
     }
     else {
         stackSpinner.succeed(chalk.green('Stack detected'));
-        console.log('');
-        // Show detected stack summary
-        console.log(chalk.dim('    ┌─ Detected Stack ─────────────────────'));
-        console.log(chalk.dim('    │'));
-        console.log(chalk.dim('    │  ') + chalk.white(`Language: ${stack.primaryLanguage}`));
-        console.log(chalk.dim('    │  ') + chalk.white(`Package Manager: ${stack.packageManager}`));
-        if (stack.frameworks.length > 0) {
-            console.log(chalk.dim('    │  ') + chalk.white(`Frameworks: ${stack.frameworks.map(f => f.name).join(', ')}`));
-        }
-        if (stack.libraries.length > 0) {
-            const libCount = stack.libraries.length;
-            const topLibs = stack.libraries.slice(0, 5).map(l => l.name).join(', ');
-            console.log(chalk.dim('    │  ') + chalk.white(`Libraries: ${topLibs}${libCount > 5 ? ` (+${libCount - 5} more)` : ''}`));
-        }
-        if (stack.devTools.length > 0) {
-            console.log(chalk.dim('    │  ') + chalk.white(`Dev Tools: ${stack.devTools.map(t => t.name).join(', ')}`));
-        }
-        console.log(chalk.dim('    │'));
-        console.log(chalk.dim('    └─────────────────────────────────────'));
-        console.log('');
-        if (options.verbose) {
-            printStackDetails(stack);
-        }
     }
-    // Phase 2: Project Context Analysis
-    console.log(chalk.cyan('  ▸ Phase 2/5: Project Analysis'));
+    console.log('');
+    // ==========================================================================
+    // Phase 2: Quick Questions
+    // ==========================================================================
+    console.log(chalk.cyan('  ▸ Phase 2/4: Quick Questions'));
     let answers = {};
     if (!options.skipQuestions && !options.refresh) {
-        // For empty projects, use interactive questions (no codebase to analyze)
-        if (stack.isEmpty) {
-            console.log(chalk.dim('    New project - gathering requirements'));
-            const { doInteractive } = await prompts({
-                type: 'confirm',
-                name: 'doInteractive',
-                message: '    Define project requirements?',
-                initial: true,
+        answers = await runInteractiveOnboarding(stack, {
+            verbose: options.verbose,
+            isNewProject: stack.isEmpty,
+        });
+    }
+    else {
+        console.log(chalk.dim('    Skipping questions'));
+        console.log('');
+    }
+    // ==========================================================================
+    // Phase 3: AI Analysis & Proposal
+    // ==========================================================================
+    console.log(chalk.cyan('  ▸ Phase 3/4: AI Analysis'));
+    const hasClaudeCli = isClaudeCliAvailable();
+    if (!hasClaudeCli) {
+        console.log(chalk.yellow('    Claude CLI not available - using detected stack'));
+        console.log('');
+    }
+    else {
+        // AI analyzes and proposes
+        let proposal = await generateProposal(projectPath, stack, answers);
+        let approved = false;
+        while (!approved) {
+            // Display proposal
+            displayProposal(proposal);
+            // Ask for approval
+            const { decision } = await prompts({
+                type: 'select',
+                name: 'decision',
+                message: '    How does this look?',
+                choices: [
+                    { title: 'Looks good, proceed', value: 'approve' },
+                    { title: 'I have feedback', value: 'feedback' },
+                    { title: 'Skip AI analysis', value: 'skip' },
+                ],
             });
-            if (doInteractive) {
-                answers = await runInteractiveOnboarding(stack, { verbose: options.verbose });
-            }
-            else {
-                console.log(chalk.dim('    Skipping - using minimal defaults'));
-            }
-        }
-        else {
-            // Existing project - offer Claude analysis
-            const hasClaudeCli = isClaudeCliAvailable();
-            if (hasClaudeCli) {
-                console.log(chalk.dim('    Claude Code CLI detected'));
-                const { useClaudeAnalysis } = await prompts({
-                    type: 'confirm',
-                    name: 'useClaudeAnalysis',
-                    message: '    Use AI to analyze codebase? (recommended)',
-                    initial: true,
-                });
-                if (useClaudeAnalysis) {
-                    const analysisSpinner = ora({
-                        text: 'Claude is analyzing your codebase...',
-                        indent: 4,
-                    }).start();
-                    const analysisSteps = [
-                        'Reading project structure...',
-                        'Analyzing architecture patterns...',
-                        'Detecting conventions...',
-                        'Identifying key components...',
-                        'Generating insights...',
-                    ];
-                    let stepIndex = 0;
-                    const stepInterval = setInterval(() => {
-                        stepIndex = (stepIndex + 1) % analysisSteps.length;
-                        analysisSpinner.text = analysisSteps[stepIndex];
-                    }, 3000);
-                    try {
-                        answers = await analyzeWithClaude(projectPath, stack);
-                        clearInterval(stepInterval);
-                        analysisSpinner.succeed(chalk.green('Codebase analysis complete'));
-                        // Show what was discovered
-                        if (answers.projectDescription) {
-                            console.log('');
-                            console.log(chalk.dim('    ┌─ Analysis Results ────────────────────'));
-                            console.log(chalk.dim('    │'));
-                            console.log(chalk.dim('    │  ') + chalk.white(answers.projectDescription.slice(0, 60) + (answers.projectDescription.length > 60 ? '...' : '')));
-                            if (answers.architectureStyle) {
-                                console.log(chalk.dim('    │  ') + chalk.dim('Architecture: ') + chalk.white(answers.architectureStyle));
-                            }
-                            console.log(chalk.dim('    │'));
-                            console.log(chalk.dim('    └──────────────────────────────────────'));
-                        }
+            if (decision === 'approve') {
+                approved = true;
+                console.log(chalk.green('    ✓ Approved'));
+                // For empty projects, offer scaffolding
+                if (stack.isEmpty) {
+                    console.log('');
+                    const { scaffold } = await prompts({
+                        type: 'confirm',
+                        name: 'scaffold',
+                        message: '    Create package.json and install dependencies?',
+                        initial: true,
+                    });
+                    if (scaffold) {
+                        await scaffoldProject(projectPath, proposal, answers);
                     }
-                    catch (err) {
-                        clearInterval(stepInterval);
-                        analysisSpinner.fail(chalk.yellow('Analysis failed, using manual questions'));
-                        answers = await runInteractiveOnboarding(stack, { verbose: options.verbose });
-                    }
-                }
-                else {
-                    answers = await runInteractiveOnboarding(stack, { verbose: options.verbose });
                 }
             }
-            else {
-                console.log(chalk.dim('    Claude Code CLI not detected - using interactive mode'));
-                const { doInteractive } = await prompts({
-                    type: 'confirm',
-                    name: 'doInteractive',
-                    message: '    Answer questions to improve documentation?',
-                    initial: true,
+            else if (decision === 'feedback') {
+                const { feedback } = await prompts({
+                    type: 'text',
+                    name: 'feedback',
+                    message: '    What should be different?',
                 });
-                if (doInteractive) {
-                    answers = await runInteractiveOnboarding(stack, { verbose: options.verbose });
-                }
-                else {
-                    console.log(chalk.dim('    Skipping - using defaults'));
+                if (feedback && typeof feedback === 'string' && feedback.trim()) {
+                    console.log('');
+                    const refineSpinner = ora({ text: 'Refining proposal...', indent: 4 }).start();
+                    proposal = await refineProposal(projectPath, stack, answers, proposal, feedback.trim());
+                    refineSpinner.succeed('Updated proposal');
+                    console.log('');
                 }
             }
+            else {
+                // Skip
+                console.log(chalk.dim('    Using detected stack only'));
+                approved = true;
+            }
         }
     }
-    else {
-        console.log(chalk.dim('    Skipping analysis (refresh mode)'));
-    }
     console.log('');
-    // Phase 3: Documentation Generation
-    console.log(chalk.cyan('  ▸ Phase 3/5: Documentation Generation'));
+    // ==========================================================================
+    // Phase 4: Build Documentation
+    // ==========================================================================
+    console.log(chalk.cyan('  ▸ Phase 4/4: Building Documentation'));
     let generatedDocs = [];
     if (!options.skipDocs) {
-        // Only use Claude for codebase analysis if there's actual code
-        const useClaude = !stack.isEmpty && isClaudeCliAvailable();
-        let docsSpinner = null;
-        if (stack.isEmpty) {
-            console.log(chalk.dim('    Generating documentation templates for new project'));
-            console.log('');
-            docsSpinner = ora({
-                text: 'Creating documentation structure...',
-                indent: 4,
-            }).start();
-        }
-        else if (useClaude) {
-            console.log(chalk.dim('    Using AI to generate comprehensive documentation'));
-            console.log('');
-            docsSpinner = ora({
-                text: 'Preparing documentation structure...',
-                indent: 4,
-            }).start();
-        }
-        else {
-            docsSpinner = ora({
-                text: 'Generating documentation templates...',
-                indent: 4,
-            }).start();
-        }
+        const docsSpinner = ora({ text: 'Fetching documentation...', indent: 4 }).start();
         try {
             generatedDocs = await buildDocs(projectPath, projectName, stack, answers, {
                 verbose: options.verbose,
-                useClaudeInference: useClaude,
+                useClaudeInference: hasClaudeCli,
                 onProgress: (message, current, total) => {
-                    if (docsSpinner && current !== undefined && total !== undefined) {
-                        const bar = progressBar(current, total);
+                    if (current !== undefined && total !== undefined) {
                         const percent = Math.round((current / total) * 100);
-                        docsSpinner.text = `${bar} ${percent}% ${chalk.dim(message)}`;
+                        docsSpinner.text = `${percent}% ${message}`;
                     }
-                    else if (docsSpinner) {
+                    else {
                         docsSpinner.text = message;
                     }
                 },
             });
-            docsSpinner?.succeed(chalk.green(`Generated ${generatedDocs.length} documentation files`));
-            // Show documentation summary
-            console.log('');
-            console.log(chalk.dim('    ┌─ Documentation Created ──────────────'));
-            console.log(chalk.dim('    │'));
-            const categories = {};
-            for (const doc of generatedDocs) {
-                const cat = doc.category || 'general';
-                categories[cat] = (categories[cat] || 0) + 1;
-            }
-            for (const [category, count] of Object.entries(categories)) {
-                const icon = getCategoryIcon(category);
-                console.log(chalk.dim('    │  ') + icon + ' ' + chalk.white(`${category}/`) + chalk.dim(` (${count} files)`));
+            docsSpinner.succeed(chalk.green(`Generated ${generatedDocs.length} docs`));
+            // Show summary
+            const categories = new Set(generatedDocs.map(d => d.category).filter(Boolean));
+            if (categories.size > 0) {
+                console.log(chalk.dim(`    Categories: ${[...categories].join(', ')}`));
             }
-            console.log(chalk.dim('    │'));
-            console.log(chalk.dim('    └──────────────────────────────────────'));
         }
         catch (err) {
-            docsSpinner?.fail(chalk.red('Documentation generation failed'));
-            console.error(chalk.red(`    ${err instanceof Error ? err.message : String(err)}`));
+            docsSpinner.fail(chalk.red('Documentation failed'));
+            console.error(chalk.dim(`    ${err instanceof Error ? err.message : String(err)}`));
         }
     }
     else {
-        console.log(chalk.dim('    Skipping documentation generation'));
+        console.log(chalk.dim('    Skipping documentation'));
     }
     console.log('');
-    // Phase 4: AGENTS.md Generation
-    console.log(chalk.cyan('  ▸ Phase 4/5: Agent Context File'));
-    const agentsSpinner = ora({ text: 'Building AGENTS.md...', indent: 4 }).start();
+    // Build AGENTS.md
+    const agentsSpinner = ora({ text: 'Creating AGENTS.md...', indent: 4 }).start();
     const agentsContent = buildAgentsMd(projectPath, stack, generatedDocs, answers);
     writeAgentsMd(projectPath, agentsContent);
     agentsSpinner.succeed(chalk.green('Created AGENTS.md'));
-    console.log(chalk.dim('    Comprehensive AI agent context file'));
-    console.log('');
-    // Phase 5: Finalization
-    console.log(chalk.cyan('  ▸ Phase 5/5: Finalization'));
-    const finalSpinner = ora({ text: 'Finalizing setup...', indent: 4 }).start();
+    // Create CLAUDE.md pointer
     createClaudeMdPointer(projectPath, projectName);
-    finalSpinner.succeed(chalk.green('Setup complete'));
     console.log('');
-    // Final Summary
+    // ==========================================================================
+    // Summary
+    // ==========================================================================
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
     console.log(chalk.bold.green('  ╭─────────────────────────────────────╮'));
-    console.log(chalk.bold.green('  │') + chalk.bold.white('      Onboarding Complete!           ') + chalk.bold.green('│'));
+    console.log(chalk.bold.green('  │') + chalk.bold.white('         Setup Complete!             ') + chalk.bold.green('│'));
     console.log(chalk.bold.green('  ╰─────────────────────────────────────╯'));
     console.log('');
     console.log(chalk.dim(`  Completed in ${elapsed}s`));
     console.log('');
-    console.log(chalk.white('  Generated files:'));
+    console.log(chalk.white('  Files created:'));
+    console.log(chalk.cyan('    AGENTS.md') + chalk.dim(' ─────── AI context'));
+    if (!options.skipDocs && generatedDocs.length > 0) {
+        console.log(chalk.cyan('    .claudetools/docs/') + chalk.dim(' ─ documentation'));
+    }
     console.log('');
-    console.log(chalk.cyan('    AGENTS.md') + chalk.dim(' ────────────── AI agent entry point'));
-    if (!options.skipDocs) {
-        console.log(chalk.cyan('    .claudetools/'));
-        console.log(chalk.dim('    └── docs/') + chalk.dim('              AI context documentation'));
-        console.log(chalk.dim('        ├── architecture/') + chalk.dim('  system design, data flow'));
-        console.log(chalk.dim('        ├── api/') + chalk.dim('           endpoints, schemas'));
-        console.log(chalk.dim('        ├── guides/') + chalk.dim('        getting started, workflow'));
-        console.log(chalk.dim('        ├── reference/') + chalk.dim('     config, env, deps'));
-        console.log(chalk.dim('        ├── patterns/') + chalk.dim('      coding standards'));
-        console.log(chalk.dim('        ├── testing/') + chalk.dim('       test strategy'));
-        console.log(chalk.dim('        ├── deployment/') + chalk.dim('    environments, CI/CD'));
-        console.log(chalk.dim('        └── decisions/') + chalk.dim('     ADRs'));
-    }
-    console.log(chalk.cyan('    .claude/CLAUDE.md') + chalk.dim(' ───── config pointer'));
+    console.log(chalk.dim('  Refresh: claudetools onboard --refresh'));
     console.log('');
-    console.log(chalk.dim('  Next steps:'));
-    console.log(chalk.dim('    • Review AGENTS.md for accuracy'));
-    console.log(chalk.dim('    • AI context in .claudetools/ is gitignored (regeneratable)'));
-    console.log(chalk.dim('    • Run `claudetools onboard --refresh` to update'));
+}
+// =============================================================================
+// Proposal Generation
+// =============================================================================
+/**
+ * Format dynamic answers for inclusion in AI prompts
+ */
+function formatDynamicAnswers(answers) {
+    const dynamicAnswers = Object.entries(answers)
+        .filter(([key, value]) => key.startsWith('dynamic_') && value)
+        .map(([key, value]) => {
+        // Convert dynamic_auth-method to "Auth method"
+        const label = key
+            .replace('dynamic_', '')
+            .replace(/-/g, ' ')
+            .replace(/\b\w/g, c => c.toUpperCase());
+        return `- ${label}: ${value}`;
+    });
+    if (dynamicAnswers.length === 0)
+        return '';
+    return `\nAdditional requirements:\n${dynamicAnswers.join('\n')}`;
+}
+async function generateProposal(projectPath, stack, answers) {
+    const isNewProject = stack.isEmpty;
+    const spinnerText = isNewProject ? 'Generating stack recommendation...' : 'Analyzing codebase...';
+    const spinner = ora({ text: spinnerText, indent: 4 }).start();
+    try {
+        let prompt;
+        if (isNewProject) {
+            // For new/empty projects: recommend a complete stack
+            const projectTypeDescriptions = {
+                web: 'a web application (frontend-focused)',
+                api: 'an API/backend service',
+                cli: 'a command-line tool',
+                library: 'a reusable library/package',
+                fullstack: 'a full-stack application with frontend and backend',
+            };
+            const typeDesc = answers.projectType
+                ? projectTypeDescriptions[answers.projectType] || answers.projectType
+                : 'a project';
+            prompt = `The user wants to build ${typeDesc}.
+
+Project description: "${answers.projectDescription || 'Not specified'}"
+${answers.mainGoal ? `Current focus: ${answers.mainGoal}` : ''}
+${answers.additionalContext ? `Additional context: ${answers.additionalContext}` : ''}
+${formatDynamicAnswers(answers)}
+
+Recommend a modern, production-ready tech stack for this project.
+Choose popular, well-maintained tools with good documentation.
+
+Respond in this exact JSON format:
+{
+  "summary": "One sentence describing what this project will be",
+  "frameworks": ["primary framework", "supporting frameworks"],
+  "libraries": ["essential libraries for this type of project"],
+  "devTools": ["typescript", "eslint", "prettier", "testing framework"],
+  "architecture": "Recommended architecture approach",
+  "recommendations": ["key suggestion 1", "key suggestion 2", "key suggestion 3"]
+}`;
+        }
+        else {
+            // For existing projects: analyze the codebase
+            prompt = `Analyze this codebase and provide a brief stack summary.
+
+User context:
+${answers.projectDescription ? `- Project: ${answers.projectDescription}` : ''}
+${answers.mainGoal ? `- Current focus: ${answers.mainGoal}` : ''}
+${answers.additionalContext ? `- Notes: ${answers.additionalContext}` : ''}
+${formatDynamicAnswers(answers)}
+
+Detected from package.json:
+- Frameworks: ${stack.frameworks.map(f => f.name).join(', ') || 'none detected'}
+- Libraries: ${stack.libraries.slice(0, 10).map(l => l.name).join(', ') || 'none detected'}
+- Dev tools: ${stack.devTools.map(t => t.name).join(', ') || 'none detected'}
+
+Respond in this exact JSON format:
+{
+  "summary": "One sentence describing what this project is",
+  "frameworks": ["list", "of", "key", "frameworks"],
+  "libraries": ["list", "of", "important", "libraries"],
+  "devTools": ["list", "of", "dev", "tools"],
+  "architecture": "Brief architecture description",
+  "recommendations": ["suggestion 1", "suggestion 2"]
+}`;
+        }
+        const result = await runClaudeAnalysis(projectPath, prompt, 60000);
+        spinner.stop();
+        if (result) {
+            // Try to parse JSON from response
+            const jsonMatch = result.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                try {
+                    return JSON.parse(jsonMatch[0]);
+                }
+                catch {
+                    // Fall through to default
+                }
+            }
+        }
+    }
+    catch {
+        spinner.stop();
+    }
+    // Default proposal from detected stack
+    return {
+        summary: answers.projectDescription || `${stack.primaryLanguage} project`,
+        frameworks: stack.frameworks.map(f => f.name),
+        libraries: stack.libraries.slice(0, 8).map(l => l.name),
+        devTools: stack.devTools.map(t => t.name),
+        architecture: 'Standard project structure',
+        recommendations: [],
+    };
+}
+async function refineProposal(projectPath, _stack, _answers, currentProposal, feedback) {
+    try {
+        const prompt = `Refine this stack proposal based on user feedback.
+
+Current proposal:
+${JSON.stringify(currentProposal, null, 2)}
+
+User feedback: "${feedback}"
+
+Provide updated proposal in same JSON format:
+{
+  "summary": "...",
+  "frameworks": [...],
+  "libraries": [...],
+  "devTools": [...],
+  "architecture": "...",
+  "recommendations": [...]
+}`;
+        const result = await runClaudeAnalysis(projectPath, prompt, 45000);
+        if (result) {
+            const jsonMatch = result.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                try {
+                    return JSON.parse(jsonMatch[0]);
+                }
+                catch {
+                    // Fall through
+                }
+            }
+        }
+    }
+    catch {
+        // Fall through
+    }
+    return currentProposal;
+}
+function displayProposal(proposal) {
     console.log('');
+    console.log(chalk.dim('    ┌─ Proposed Configuration ────────────────'));
+    console.log(chalk.dim('    │'));
+    console.log(chalk.dim('    │  ') + chalk.white(proposal.summary));
+    console.log(chalk.dim('    │'));
+    if (proposal.frameworks.length > 0) {
+        console.log(chalk.dim('    │  ') + chalk.cyan('Frameworks: ') + proposal.frameworks.join(', '));
+    }
+    if (proposal.libraries.length > 0) {
+        console.log(chalk.dim('    │  ') + chalk.cyan('Libraries: ') + proposal.libraries.slice(0, 6).join(', ') +
+            (proposal.libraries.length > 6 ? ` (+${proposal.libraries.length - 6})` : ''));
+    }
+    if (proposal.devTools.length > 0) {
+        console.log(chalk.dim('    │  ') + chalk.cyan('Dev Tools: ') + proposal.devTools.join(', '));
+    }
+    if (proposal.architecture) {
+        console.log(chalk.dim('    │  ') + chalk.cyan('Architecture: ') + proposal.architecture);
+    }
+    if (proposal.recommendations.length > 0) {
+        console.log(chalk.dim('    │'));
+        console.log(chalk.dim('    │  ') + chalk.yellow('Recommendations:'));
+        for (const rec of proposal.recommendations.slice(0, 3)) {
+            console.log(chalk.dim('    │  ') + chalk.dim('• ') + rec);
+        }
+    }
+    console.log(chalk.dim('    │'));
+    console.log(chalk.dim('    └──────────────────────────────────────────'));
+    console.log('');
+}
+// =============================================================================
+// Scaffolding for New Projects
+// =============================================================================
+async function scaffoldProject(projectPath, proposal, answers) {
+    const spinner = ora({ text: 'Scaffolding project...', indent: 4 }).start();
+    try {
+        // Detect package manager
+        const packageManager = detectPackageManager();
+        // Generate package.json
+        const projectName = basename(projectPath).toLowerCase().replace(/[^a-z0-9-]/g, '-');
+        const packageJson = generatePackageJson(projectName, proposal, answers);
+        const packageJsonPath = join(projectPath, 'package.json');
+        writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        spinner.text = 'Created package.json';
+        // Install dependencies
+        spinner.text = `Installing dependencies with ${packageManager}...`;
+        const installCmd = packageManager === 'yarn' ? 'yarn' : `${packageManager} install`;
+        try {
+            execSync(installCmd, {
+                cwd: projectPath,
+                stdio: 'pipe',
+                timeout: 120000, // 2 minute timeout
+            });
+            spinner.succeed(chalk.green(`Scaffolded with ${packageManager}`));
+        }
+        catch {
+            spinner.warn(chalk.yellow('Created package.json (install failed - run manually)'));
+        }
+    }
+    catch (err) {
+        spinner.fail(chalk.red('Scaffolding failed'));
+        console.error(chalk.dim(`    ${err instanceof Error ? err.message : String(err)}`));
+    }
 }
-function getCategoryIcon(category) {
-    const icons = {
-        architecture: '🏗️ ',
-        api: '🔌',
-        guides: '📖',
-        reference: '📚',
-        patterns: '🎨',
-        testing: '🧪',
-        deployment: '🚀',
-        decisions: '📝',
-        general: '📄',
+function detectPackageManager() {
+    // Check for lock files in current directory or common indicators
+    try {
+        execSync('pnpm --version', { stdio: 'pipe' });
+        return 'pnpm';
+    }
+    catch {
+        // pnpm not available
+    }
+    try {
+        execSync('bun --version', { stdio: 'pipe' });
+        return 'bun';
+    }
+    catch {
+        // bun not available
+    }
+    try {
+        execSync('yarn --version', { stdio: 'pipe' });
+        return 'yarn';
+    }
+    catch {
+        // yarn not available
+    }
+    return 'npm';
+}
+function generatePackageJson(projectName, proposal, answers) {
+    const dependencies = {};
+    const devDependencies = {};
+    // Add frameworks as dependencies
+    for (const framework of proposal.frameworks) {
+        const dep = frameworkToPackage(framework);
+        if (dep)
+            dependencies[dep] = 'latest';
+    }
+    // Add libraries as dependencies
+    for (const lib of proposal.libraries) {
+        const dep = libraryToPackage(lib);
+        if (dep)
+            dependencies[dep] = 'latest';
+    }
+    // Add dev tools as devDependencies
+    for (const tool of proposal.devTools) {
+        const dep = devToolToPackage(tool);
+        if (dep)
+            devDependencies[dep] = 'latest';
+    }
+    // Always include TypeScript for modern projects
+    if (!devDependencies['typescript']) {
+        devDependencies['typescript'] = 'latest';
+    }
+    return {
+        name: projectName,
+        version: '0.1.0',
+        description: answers.projectDescription || proposal.summary,
+        type: 'module',
+        scripts: {
+            dev: 'echo "Add your dev script"',
+            build: 'echo "Add your build script"',
+            test: 'echo "Add your test script"',
+        },
+        dependencies,
+        devDependencies,
     };
-    return icons[category] || '📄';
 }
-/**
- * Create minimal CLAUDE.md that points to AGENTS.md
- */
+function frameworkToPackage(framework) {
+    const mapping = {
+        'next.js': 'next',
+        'nextjs': 'next',
+        'react': 'react',
+        'vue': 'vue',
+        'nuxt': 'nuxt',
+        'express': 'express',
+        'fastify': 'fastify',
+        'hono': 'hono',
+        'svelte': 'svelte',
+        'sveltekit': '@sveltejs/kit',
+        'astro': 'astro',
+        'remix': '@remix-run/node',
+    };
+    return mapping[framework.toLowerCase()] || framework.toLowerCase();
+}
+function libraryToPackage(lib) {
+    // Most libraries map directly to their package name
+    return lib.toLowerCase().replace(/\s+/g, '-');
+}
+function devToolToPackage(tool) {
+    const mapping = {
+        'typescript': 'typescript',
+        'eslint': 'eslint',
+        'prettier': 'prettier',
+        'vitest': 'vitest',
+        'jest': 'jest',
+        'biome': '@biomejs/biome',
+    };
+    return mapping[tool.toLowerCase()] || tool.toLowerCase();
+}
+// =============================================================================
+// Helper Functions
+// =============================================================================
 function createClaudeMdPointer(projectPath, projectName) {
     const claudeDir = join(projectPath, '.claude');
     const claudeMdPath = join(claudeDir, 'CLAUDE.md');
-    // Create .claude directory if needed
     if (!existsSync(claudeDir)) {
         mkdirSync(claudeDir, { recursive: true });
     }
-    // Check if CLAUDE.md already exists with custom content
     if (existsSync(claudeMdPath)) {
         const existing = readFileSync(claudeMdPath, 'utf-8');
-        // If it has substantial custom content, don't overwrite
         if (existing.length > 500 && !existing.includes('See [AGENTS.md]')) {
-            console.log(chalk.dim('  Existing CLAUDE.md preserved (has custom content)'));
-            return;
+            return; // Don't overwrite custom content
         }
     }
     const content = `# ${projectName}
 
-See [AGENTS.md](../AGENTS.md) for comprehensive project context.
-
-## Quick Links
-
-- Project docs: \`docs/\`
-- Agent context: \`AGENTS.md\`
+See [AGENTS.md](../AGENTS.md) for AI context.
 
 ---
-
-*Generated by ClaudeTools. Refresh: \`claudetools onboard --refresh\`*
+*Generated by ClaudeTools*
 `;
     writeFileSync(claudeMdPath, content);
 }
-/**
- * Print detailed stack information
- */
-function printStackDetails(stack) {
-    console.log(chalk.dim('\n  Stack Details:'));
-    if (stack.frameworks.length > 0) {
-        console.log(chalk.dim('  Frameworks:'));
-        for (const fw of stack.frameworks) {
-            console.log(chalk.dim(`    - ${fw.name} ${fw.version} (${fw.category})`));
-        }
-    }
-    if (stack.libraries.length > 0) {
-        console.log(chalk.dim('  Libraries:'));
-        for (const lib of stack.libraries) {
-            console.log(chalk.dim(`    - ${lib.name} ${lib.version} (${lib.category})`));
-        }
-    }
-    if (stack.devTools.length > 0) {
-        console.log(chalk.dim('  Dev Tools:'));
-        for (const tool of stack.devTools) {
-            console.log(chalk.dim(`    - ${tool.name} (${tool.category})`));
-        }
-    }
-    console.log('');
-}
 //# sourceMappingURL=index.js.map