ccraft 1.0.11 → 1.0.13

package/src/commands/install.js

@@ -1,4 +1,6 @@
-import { resolve } from 'path';
+import { resolve, join, basename } from 'path';
+import { mkdirSync, existsSync, writeFileSync, readdirSync } from 'fs';
+import { execFileSync } from 'child_process';
 import chalk from 'chalk';
 import ora from 'ora';
 import { detectProject } from '../utils/detect-project.js';
@@ -11,27 +13,24 @@ import {
 } from '../utils/existing-setup.js';
 import {
   gatherProjectPath,
-  gatherPersona,
-  gatherUserProfile,
-  gatherMcpConfig,
-  gatherSecurityConfig,
+  gatherCreateProfile,
   confirmInstallation,
 } from '../prompts/gather.js';
+import { themedInput } from '../ui/prompts.js';
 import { callGenerate, ApiError } from '../utils/api-client.js';
 import { writeApiFiles, buildFileList } from '../utils/api-file-writer.js';
 import { setupMcps } from '../utils/mcp-setup.js';
-import { scoreWithClaude } from '../utils/claude-scorer.js';
 import { optimizeSettings } from '../utils/claude-optimizer.js';
 import { runPreflight } from '../utils/preflight.js';
+import { platformCmd } from '../utils/run-claude.js';
 import {
   writeAnalysisCache,
-  writeUserProfile,
   updateManifest,
   readAnalysisCache,
   promoteCache,
   cleanupAnalysisCache,
 } from '../utils/analysis-cache.js';
-import { PRESET_ALIASES, VERSION, VIBE_DEFAULTS } from '../constants.js';
+import { VERSION } from '../constants.js';
 import * as logger from '../utils/logger.js';
 
 // UI modules
@@ -40,20 +39,48 @@ import { renderPhaseHeader } from '../ui/phase-header.js';
 import { renderProjectCard, renderSuccessCard } from '../ui/cards.js';
 import { renderComponentBreakdown, renderMcpStatus, renderFileResults } from '../ui/tables.js';
 import { runExistingSetupTasks, runAnalysisTasks, runInstallTasks, runVerifyTasks, runFinalizeTasks } from '../ui/tasks.js';
-import { colors } from '../ui/theme.js';
-import { dotPad } from '../ui/format.js';
+
+// ── Create-mode detection ───────────────────────────────────────────────────
+
+const IGNORED_ENTRIES = new Set(['.git', '.DS_Store', 'Thumbs.db', '.gitkeep']);
 
 /**
- * Main install command — 5-phase orchestrator.
+ * Returns true if the directory doesn't exist or contains only ignored files.
+ */
+function isEmptyDir(dirPath) {
+  if (!existsSync(dirPath)) return true;
+  const entries = readdirSync(dirPath).filter((f) => !IGNORED_ENTRIES.has(f));
+  return entries.length === 0;
+}
+
+/**
+ * Determine whether we're in create mode (new project) or install mode (existing project).
  *
- * Phase 1: Welcome & Setup (env check + user profile)
- * Phase 2: Project Discovery (Claude analysis + filesystem scan)
- * Phase 3: Configuration (server API + MCP selection + security + confirmation)
- * Phase 4: Installation (Claude scoring + file writing + MCP verification)
- * Phase 5: Finalization (settings optimization + CLAUDE.md rewrite + success)
+ * Create mode triggers when:
+ * - --name or --description flag is provided (explicit intent)
+ * - Target directory doesn't exist
+ * - Target directory is empty (ignoring .git, .DS_Store, etc.)
+ */
+function isCreateMode(dirPath, options) {
+  if (options.name || options.description) return true;
+  return isEmptyDir(dirPath);
+}
+
+/**
+ * Main install command — unified orchestrator for both new and existing projects.
+ *
+ * Auto-detects mode:
+ * - Create mode (empty/missing dir): gather profile → mkdir → git init → synthetic
+ *   analysis → server → write files → bootstrap → re-analyze → finalize
+ * - Install mode (existing project): discover → analyze → server → confirm →
+ *   write files → MCP verify → finalize
  */
 export async function runInstall(options = {}) {
   let targetDir;
+  let createMode = false;
+  let createName = '';
+  let createDescription = '';
+
   try {
     // ================================================================
     // PHASE 1: Welcome & Setup
@@ -66,88 +93,230 @@ export async function runInstall(options = {}) {
       requireClaude: true,
     });
 
-    // ── Project path ────────────────────────────────────────────────
-    if (!options.yes && !options.dir) {
+    // ── Resolve target directory + detect mode ──────────────────────
+    if (!options.yes && !options.dir && !options.name && !options.description) {
+      // Interactive, no flags — ask for path first, then detect mode
       targetDir = await gatherProjectPath();
     } else {
       targetDir = resolve(options.dir || process.cwd());
     }
 
-    // ── Persona selection ────────────────────────────────────────────
-    renderPhaseHeader(1);
+    createMode = isCreateMode(targetDir, options);
+
+    if (createMode) {
+      // ── Create mode: gather profile + mkdir + git init ────────────
+      let name, description, projectType;
+
+      if (options.yes) {
+        name = options.name || 'my-project';
+        description = options.description || 'A new project';
+        projectType = 'monolith';
+        logger.info(`New project mode — creating ${chalk.bold(name)} (monolith).`);
+      } else if (options.name || options.description) {
+        // Partial flags provided — fill in the rest interactively
+        const profile = await gatherCreateProfile();
+        name = options.name || profile.name;
+        description = options.description || profile.description;
+        projectType = profile.projectType;
+      } else {
+        // Empty dir detected — prompt for project details
+        logger.info('Empty directory detected — switching to new project mode.');
+        const profile = await gatherCreateProfile();
+        name = profile.name;
+        description = profile.description;
+        projectType = profile.projectType;
+      }
+
+      // Resolve target directory for new project
+      const parentDir = resolve(options.dir || process.cwd());
+      let useCurrentDir = false;
+
+      if (!name) {
+        // Empty name = use current directory
+        targetDir = parentDir;
+        useCurrentDir = true;
+        const contents = readdirSync(targetDir).filter((f) => !IGNORED_ENTRIES.has(f));
+        if (contents.length > 0) {
+          logger.error(`Current directory ${chalk.bold(targetDir)} is not empty. Cannot create a project here.`);
+          process.exit(1);
+        }
+        name = basename(targetDir) || 'my-project';
+      } else {
+        // Named project — re-prompt if directory already exists and is non-empty
+        targetDir = join(parentDir, name);
+        while (existsSync(targetDir) && !isEmptyDir(targetDir)) {
+          logger.warn(`Directory ${chalk.bold(name)} already exists and is not empty.`);
+          const newName = await themedInput({
+            message: 'Enter a different project name:',
+            hint: 'Letters, numbers, dots, hyphens, underscores only.',
+            validate: (v) => {
+              const t = v.trim();
+              if (!t) return 'Name is required.';
+              if (!/^[a-zA-Z0-9._-]+$/.test(t)) return 'Only letters, numbers, dots, hyphens, and underscores allowed.';
+              return true;
+            },
+          });
+          name = newName.trim();
+          targetDir = join(parentDir, name);
+        }
+      }
 
-    let persona;
-    if (options.yes) {
-      persona = 'developer'; // non-interactive: always developer defaults
-    } else if (options.pro) {
-      persona = 'developer'; // interactive developer mode: skip persona prompt
-    } else {
-      persona = await gatherPersona();
-    }
+      // Create directory + git init
+      const spinner1 = ora(useCurrentDir ? 'Initializing project in current directory...' : 'Creating project directory...').start();
+      if (!useCurrentDir && !existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+      }
 
-    const isVibe = persona === 'vibe';
+      writeFileSync(
+        join(targetDir, '.gitignore'),
+        'node_modules/\ndist/\nbuild/\n.env\n.env.*\n!.env.example\n*.log\n.DS_Store\nThumbs.db\n',
+        'utf8',
+      );
 
-    // ── User profile ───────────────────────────────────────────────
-    let userProfile;
-    if (options.yes) {
-      userProfile = { intents: ['implementing', 'debugging', 'refactoring', 'testing', 'reviewing'], sourceControl: 'github', documentTools: [] };
-      logger.info('Non-interactive mode — using default profile (web, all intents, github).');
-    } else if (isVibe) {
-      userProfile = { ...VIBE_DEFAULTS };
-      logger.info('Vibe mode — using streamlined defaults.');
-    } else {
-      userProfile = await gatherUserProfile();
+      try {
+        const { file, args } = platformCmd('git', ['init']);
+        execFileSync(file, args, { cwd: targetDir, stdio: 'pipe', windowsHide: true });
+        spinner1.succeed(useCurrentDir
+          ? `Initialized project in ${chalk.bold(targetDir)} with git.`
+          : `Created ${chalk.bold(name)}/ with git initialized.`);
+      } catch {
+        spinner1.succeed(useCurrentDir
+          ? `Initialized project in ${chalk.bold(targetDir)} (git init skipped — git not available).`
+          : `Created ${chalk.bold(name)}/ (git init skipped — git not available).`);
+      }
+
+      createName = name;
+      createDescription = description;
+      // projectType is captured in the closure for Phase 2
+      options._createProjectType = projectType;
     }
-    userProfile.persona = persona;
 
     // ================================================================
     // PHASE 2: Project Discovery
     // ================================================================
-    renderPhaseHeader(2);
-
-    // ── Check for existing Claude setup ─────────────────────────────
-    let existingContext = null;
-    try {
-      const setupCtx = await runExistingSetupTasks(targetDir, {
-        detectExistingSetup,
-        extractExistingContext,
-        removeExistingSetup,
-      });
-      existingContext = setupCtx.existingContext || null;
-    } catch (setupErr) {
-      logger.debug(`Existing setup check failed: ${setupErr.message}`);
-    }
+    const phaseOpts = createMode ? { totalPhases: 6 } : {};
+    renderPhaseHeader(2, phaseOpts);
 
-    // ── Project analysis ────────────────────────────────────────────
     let projectInfo;
     let detected;
+    let existingContext = null;
 
-    try {
-      const ctx = await runAnalysisTasks(targetDir, { analyzeWithClaude, detectProject, existingContext });
+    if (createMode) {
+      // ── Create mode: synthetic analysis from description ──────────
+      const { analyzeDescription } = await import('../utils/description-analyzer.js');
+
+      let descAnalysis = null;
+      {
+        const spinnerAnalyze = ora('Analyzing your requirements...').start();
+        const { analysis, failReason } = await analyzeDescription(createDescription, options._createProjectType);
+        if (analysis) {
+          descAnalysis = analysis;
+          const parts = [];
+          if (analysis.frameworks.length) parts.push(analysis.frameworks.join(', '));
+          if (analysis.languages.length) parts.push(analysis.languages.join(', '));
+          if (analysis.databases.length) parts.push(analysis.databases.join(', '));
+          spinnerAnalyze.succeed(
+            parts.length
+              ? `Detected stack: ${chalk.bold(parts.join(' + '))}`
+              : 'Requirements analyzed.',
+          );
+        } else {
+          spinnerAnalyze.info(`Stack inference skipped${failReason ? ` (${failReason})` : ''} — using defaults.`);
+        }
+      }
 
-      const { claudeAnalysis, claudeFailReason, fsDetected } = ctx;
+      projectInfo = {
+        name: createName,
+        description: createDescription,
+        projectType: options._createProjectType || 'monolith',
+        languages: descAnalysis?.languages?.length ? descAnalysis.languages : [],
+        frameworks: descAnalysis?.frameworks?.length ? descAnalysis.frameworks : [],
+        codeStyle: descAnalysis?.codeStyle?.length ? descAnalysis.codeStyle : [],
+        cicd: descAnalysis?.cicd?.length ? descAnalysis.cicd : [],
+        subprojects: descAnalysis?.subprojects?.length ? descAnalysis.subprojects : [],
+        architecture: descAnalysis?.architecture || '',
+        buildCommands: descAnalysis?.buildCommands || {},
+        complexity: descAnalysis?.complexity ?? 0.3,
+        metrics: descAnalysis?.metrics || null,
+        entryPoints: descAnalysis?.entryPoints || [],
+        coreModules: descAnalysis?.coreModules || [],
+        testFramework: descAnalysis?.testFramework || '',
+        packageManager: descAnalysis?.packageManager || '',
+        languageDistribution: descAnalysis?.languageDistribution || null,
+      };
 
-      if (claudeAnalysis) {
-        projectInfo = {
-          name: claudeAnalysis.name || fsDetected.name || 'my-project',
-          description: claudeAnalysis.description || fsDetected.description || '',
-          projectType: claudeAnalysis.projectType || fsDetected.projectType || 'monolith',
-          languages: claudeAnalysis.languages.length ? claudeAnalysis.languages : (fsDetected.languages.length ? fsDetected.languages : ['JavaScript']),
-          frameworks: claudeAnalysis.frameworks.length ? claudeAnalysis.frameworks : fsDetected.frameworks,
-          codeStyle: claudeAnalysis.codeStyle.length ? claudeAnalysis.codeStyle : fsDetected.codeStyle,
-          cicd: claudeAnalysis.cicd.length ? claudeAnalysis.cicd : fsDetected.cicd,
-          subprojects: claudeAnalysis.subprojects.length ? claudeAnalysis.subprojects : fsDetected.subprojects,
-          architecture: claudeAnalysis.architecture || '',
-          buildCommands: claudeAnalysis.buildCommands || {},
-          complexity: claudeAnalysis.complexity ?? 0.5,
-          metrics: claudeAnalysis.metrics || null,
-          entryPoints: claudeAnalysis.entryPoints || [],
-          coreModules: claudeAnalysis.coreModules || [],
-          testFramework: claudeAnalysis.testFramework || '',
-          packageManager: claudeAnalysis.packageManager || fsDetected.packageManager || '',
-          languageDistribution: claudeAnalysis.languageDistribution || fsDetected.languageDistribution || null,
-        };
-      } else {
+      detected = {
+        ...projectInfo,
+        sensitiveFiles: { found: [], gitignoreCovers: true },
+        _rootFiles: [],
+        databases: descAnalysis?.databases?.length ? descAnalysis.databases : [],
+      };
+    } else {
+      // ── Install mode: real project analysis ───────────────────────
+      try {
+        const setupCtx = await runExistingSetupTasks(targetDir, {
+          detectExistingSetup,
+          extractExistingContext,
+          removeExistingSetup,
+        });
+        existingContext = setupCtx.existingContext || null;
+      } catch (setupErr) {
+        logger.debug(`Existing setup check failed: ${setupErr.message}`);
+      }
+
+      try {
+        const ctx = await runAnalysisTasks(targetDir, { analyzeWithClaude, detectProject, existingContext });
+
+        const { claudeAnalysis, claudeFailReason, fsDetected } = ctx;
+
+        if (claudeAnalysis) {
+          projectInfo = {
+            name: claudeAnalysis.name || fsDetected.name || 'my-project',
+            description: claudeAnalysis.description || fsDetected.description || '',
+            projectType: claudeAnalysis.projectType || fsDetected.projectType || 'monolith',
+            languages: claudeAnalysis.languages.length ? claudeAnalysis.languages : (fsDetected.languages.length ? fsDetected.languages : ['JavaScript']),
+            frameworks: claudeAnalysis.frameworks.length ? claudeAnalysis.frameworks : fsDetected.frameworks,
+            codeStyle: claudeAnalysis.codeStyle.length ? claudeAnalysis.codeStyle : fsDetected.codeStyle,
+            cicd: claudeAnalysis.cicd.length ? claudeAnalysis.cicd : fsDetected.cicd,
+            subprojects: claudeAnalysis.subprojects.length ? claudeAnalysis.subprojects : fsDetected.subprojects,
+            architecture: claudeAnalysis.architecture || '',
+            buildCommands: claudeAnalysis.buildCommands || {},
+            complexity: claudeAnalysis.complexity ?? 0.5,
+            metrics: claudeAnalysis.metrics || null,
+            entryPoints: claudeAnalysis.entryPoints || [],
+            coreModules: claudeAnalysis.coreModules || [],
+            testFramework: claudeAnalysis.testFramework || '',
+            packageManager: claudeAnalysis.packageManager || fsDetected.packageManager || '',
+            languageDistribution: claudeAnalysis.languageDistribution || fsDetected.languageDistribution || null,
+          };
+        } else {
+          projectInfo = {
+            name: fsDetected.name || targetDir.split(/[/\\]/).filter(Boolean).pop() || 'my-project',
+            description: fsDetected.description || '',
+            projectType: fsDetected.projectType || 'monolith',
+            languages: fsDetected.languages.length ? fsDetected.languages : ['JavaScript'],
+            frameworks: fsDetected.frameworks,
+            codeStyle: fsDetected.codeStyle,
+            cicd: fsDetected.cicd,
+            subprojects: fsDetected.subprojects,
+            architecture: '',
+            buildCommands: {},
+            complexity: 0.5,
+            metrics: null,
+            entryPoints: [],
+            coreModules: [],
+            testFramework: '',
+            packageManager: fsDetected.packageManager || '',
+            languageDistribution: fsDetected.languageDistribution || null,
+          };
+        }
+
+        detected = { ...fsDetected, ...projectInfo };
+      } catch (analysisErr) {
+        // Fallback if task runner fails — run sequentially with spinner
+        const spinner = ora('Analyzing project...').start();
+        const fsDetected = await detectProject(targetDir);
+        spinner.succeed('Project scanned.');
         projectInfo = {
           name: fsDetected.name || targetDir.split(/[/\\]/).filter(Boolean).pop() || 'my-project',
           description: fsDetected.description || '',
@@ -167,77 +336,31 @@ export async function runInstall(options = {}) {
           packageManager: fsDetected.packageManager || '',
           languageDistribution: fsDetected.languageDistribution || null,
         };
+        detected = { ...fsDetected, ...projectInfo };
       }
 
-      detected = { ...fsDetected, ...projectInfo };
-    } catch (analysisErr) {
-      // Fallback if task runner fails — run sequentially with spinner
-      const spinner = ora('Analyzing project...').start();
-      const fsDetected = await detectProject(targetDir);
-      spinner.succeed('Project scanned.');
-      projectInfo = {
-        name: fsDetected.name || targetDir.split(/[/\\]/).filter(Boolean).pop() || 'my-project',
-        description: fsDetected.description || '',
-        projectType: fsDetected.projectType || 'monolith',
-        languages: fsDetected.languages.length ? fsDetected.languages : ['JavaScript'],
-        frameworks: fsDetected.frameworks,
-        codeStyle: fsDetected.codeStyle,
-        cicd: fsDetected.cicd,
-        subprojects: fsDetected.subprojects,
-        architecture: '',
-        buildCommands: {},
-        complexity: 0.5,
-        metrics: null,
-        entryPoints: [],
-        coreModules: [],
-        testFramework: '',
-        packageManager: fsDetected.packageManager || '',
-        languageDistribution: fsDetected.languageDistribution || null,
-      };
-      detected = { ...fsDetected, ...projectInfo };
+      // Display results (install mode only — create mode has no real project to show)
+      console.log();
+      renderProjectCard(projectInfo);
     }
 
-    // Cache analysis and user profile for later phases and future update runs
+    // Cache analysis for later phases and future update runs
     try {
       writeAnalysisCache(targetDir, projectInfo, detected, existingContext);
-      writeUserProfile(targetDir, userProfile);
     } catch (cacheErr) {
       logger.debug(`Analysis cache write failed: ${cacheErr.message}`);
     }
 
-    // Display results
-    console.log();
-    renderProjectCard(projectInfo);
-
-    // Preset alias injection
-    if (options.preset) {
-      const alias = PRESET_ALIASES[options.preset];
-      if (!alias) {
-        logger.error(
-          `Unknown preset ${chalk.bold(options.preset)}. ` +
-            `Available presets: ${Object.keys(PRESET_ALIASES).map((p) => colors.success(p)).join(', ')}`
-        );
-        process.exit(1);
-      }
-      for (const fw of alias.frameworks) {
-        if (!projectInfo.frameworks.includes(fw)) projectInfo.frameworks.push(fw);
-      }
-      for (const lang of alias.languages) {
-        if (!projectInfo.languages.includes(lang)) projectInfo.languages.push(lang);
-      }
-    }
-
     // ================================================================
     // PHASE 3: Configuration
     // ================================================================
-    renderPhaseHeader(3);
+    renderPhaseHeader(3, phaseOpts);
 
     const spinner3 = ora('Calling claude-craft server...').start();
 
     let apiResponse;
     try {
       apiResponse = await callGenerate(
-        userProfile,
         {
           name: projectInfo.name,
           projectType: projectInfo.projectType,
@@ -258,7 +381,7 @@ export async function runInstall(options = {}) {
           detectedFiles: detected._rootFiles || [],
           databases: projectInfo.databases || detected.databases || [],
         },
-        { preset: options.preset, projectPath: targetDir },
+        { projectPath: targetDir },
       );
       spinner3.succeed('Server returned configuration.');
     } catch (err) {
@@ -272,27 +395,17 @@ export async function runInstall(options = {}) {
 
     const { summary, mcpConfigs } = apiResponse;
 
-    // Display scoring summary
+    // Display component summary
     console.log();
     renderComponentBreakdown(summary);
 
-    // MCP selection + credential setup + security + confirmation
-    let selectedMcps;
-    let mcpKeys = {};
-    let securityConfig;
-
-    if (options.yes || isVibe) {
-      selectedMcps = mcpConfigs.filter(
-        (m) => m.tier === 'core' || m.tier === 'role' || m.tier === 'stack' || m.tier === 'auto' || m.recommended
-      );
-      securityConfig = { addSecurityGitignore: true };
-    } else {
-      const mcpResult = await gatherMcpConfig(mcpConfigs);
-      selectedMcps = mcpResult.selectedMcps;
-      mcpKeys = mcpResult.mcpKeys;
-
-      securityConfig = gatherSecurityConfig(detected);
+    // All MCPs are auto-installed; no interactive selection
+    const selectedMcps = mcpConfigs || [];
+    const mcpKeys = {};
+    const securityConfig = { addSecurityGitignore: true };
 
+    // Confirmation gate (skipped in create mode and non-interactive mode)
+    if (!createMode && !options.yes) {
       const finalSummary = { ...summary, mcps: selectedMcps.map((m) => ({ id: m.id, tier: m.tier })) };
       const proceed = await confirmInstallation(finalSummary);
       if (!proceed) {
@@ -305,16 +418,14 @@ export async function runInstall(options = {}) {
     // ================================================================
     // PHASE 4: Installation
     // ================================================================
-    renderPhaseHeader(4);
+    renderPhaseHeader(4, phaseOpts);
 
     let results;
     let filesToWrite;
-    let selectedCandidateIds = null;
 
     try {
       const installCtx = await runInstallTasks({
         apiResponse,
-        selectedCandidateIds: null,
         targetDir,
         selectedMcps,
         mcpKeys,
@@ -322,29 +433,14 @@ export async function runInstall(options = {}) {
         detected,
         buildFileList,
         writeApiFiles,
-        scoreWithClaude,
       });
 
       results = installCtx.results;
       filesToWrite = installCtx.filesToWrite;
-      selectedCandidateIds = installCtx.selectedCandidateIds ?? null;
     } catch (installErr) {
       // Fallback to sequential if task runner fails
-      const candidateCount = apiResponse.candidates?.items?.length || 0;
-
-      if (apiResponse.prompts?.scoring && candidateCount > 0) {
-        const spinner4 = ora(`Evaluating ${candidateCount} optional candidates...`).start();
-        const scoreResult = await scoreWithClaude(apiResponse.prompts.scoring, targetDir);
-        if (scoreResult.selected) {
-          selectedCandidateIds = scoreResult.selected;
-          spinner4.succeed(`Selected ${selectedCandidateIds.length}/${candidateCount} candidates.`);
-        } else {
-          spinner4.warn(`Scoring unavailable — including all ${candidateCount} candidates.`);
-        }
-      }
-
       const spinnerWrite = ora('Writing configuration files...').start();
-      filesToWrite = buildFileList(apiResponse, selectedCandidateIds);
+      filesToWrite = buildFileList(apiResponse);
       results = await writeApiFiles(filesToWrite, targetDir, {
         force: true,
         selectedMcpIds: selectedMcps.map((m) => m.id),
@@ -391,10 +487,81 @@ export async function runInstall(options = {}) {
     }
 
     // ================================================================
-    // PHASE 5: Finalization
+    // CREATE MODE: Bootstrap
+    // ================================================================
+    let bootstrapSucceeded = true;
+
+    if (createMode) {
+      renderPhaseHeader(5, { totalPhases: 6, name: 'Bootstrap' });
+
+      console.log(chalk.dim('  Handing off to Claude to scaffold your project...'));
+      console.log(chalk.dim('  This may take several minutes. Activity log:'));
+      console.log();
+
+      try {
+        const { runBootstrap } = await import('../utils/bootstrap-runner.js');
+        await runBootstrap(targetDir, createDescription);
+      } catch (err) {
+        bootstrapSucceeded = false;
+        console.log();
+        logger.warn('Bootstrap did not complete: ' + err.message);
+        logger.info('Your .claude/ configuration is still intact. You can run /bootstrap:auto manually inside the project.');
+        console.log();
+      }
+    }
+
+    // ================================================================
+    // FINALIZATION
     // ================================================================
-    renderPhaseHeader(5);
+    renderPhaseHeader(createMode ? 6 : 5, createMode ? { totalPhases: 6, name: 'Finalization' } : {});
 
+    // Create mode: re-analyze after bootstrap
+    if (createMode && bootstrapSucceeded) {
+      try {
+        const spinnerReanalyze = ora('Re-analyzing project...').start();
+        const fsDetected = await detectProject(targetDir);
+
+        let reanalyzedInfo;
+        try {
+          const { analysis } = await analyzeWithClaude(targetDir);
+          if (analysis) {
+            reanalyzedInfo = {
+              name: analysis.name || fsDetected.name || createName,
+              description: analysis.description || fsDetected.description || createDescription,
+              projectType: analysis.projectType || fsDetected.projectType || options._createProjectType,
+              languages: analysis.languages?.length ? analysis.languages : fsDetected.languages,
+              frameworks: analysis.frameworks?.length ? analysis.frameworks : fsDetected.frameworks,
+              codeStyle: analysis.codeStyle?.length ? analysis.codeStyle : fsDetected.codeStyle,
+              cicd: analysis.cicd?.length ? analysis.cicd : fsDetected.cicd,
+              subprojects: analysis.subprojects?.length ? analysis.subprojects : fsDetected.subprojects,
+              architecture: analysis.architecture || '',
+              buildCommands: analysis.buildCommands || {},
+              complexity: analysis.complexity ?? 0.5,
+              metrics: analysis.metrics || null,
+              entryPoints: analysis.entryPoints || [],
+              coreModules: analysis.coreModules || [],
+              testFramework: analysis.testFramework || '',
+              packageManager: analysis.packageManager || fsDetected.packageManager || '',
+              languageDistribution: analysis.languageDistribution || fsDetected.languageDistribution || null,
+            };
+          } else {
+            reanalyzedInfo = buildProjectInfoFromFs(fsDetected, createName, createDescription, options._createProjectType);
+          }
+        } catch {
+          reanalyzedInfo = buildProjectInfoFromFs(fsDetected, createName, createDescription, options._createProjectType);
+        }
+
+        spinnerReanalyze.succeed('Project re-analyzed.');
+
+        // Overwrite cache with real data
+        const reanalyzedDetected = { ...fsDetected, ...reanalyzedInfo };
+        writeAnalysisCache(targetDir, reanalyzedInfo, reanalyzedDetected, null);
+      } catch (err) {
+        logger.debug(`Post-bootstrap analysis failed: ${err.message}`);
+      }
+    }
+
+    // Shared finalization — optimize settings + rewrite CLAUDE.md
     try {
       const finCtx = await runFinalizeTasks({
         targetDir,
@@ -403,7 +570,6 @@ export async function runInstall(options = {}) {
         rewriteClaudeMd,
       });
 
-      // Show what was replaced
       const opt = finCtx.optimizationResult;
       if (opt?.status === 'ok' && opt.applied > 0 && opt.replacements?.length > 0) {
         for (const label of opt.replacements) {
@@ -411,9 +577,6 @@ export async function runInstall(options = {}) {
         }
       }
     } catch {
-      // Fallback to sequential
-      // toolkit-usage.md no longer generated — capability-map.md covers routing
-
       const spinner7 = ora('Optimizing settings...').start();
       const optResult = optimizeSettings(targetDir);
 
@@ -434,18 +597,27 @@ export async function runInstall(options = {}) {
     }
 
     // ── Success ──────────────────────────────────────────────────────
-    const totalItems = countTotalItems(summary, selectedCandidateIds);
+    const totalItems = countTotalItems(summary);
     const mcpsNeedingKeys = mcpResults.filter((r) => r.status === 'needs-key');
 
     renderSuccessCard({
       totalItems,
       mcpCount: selectedMcps.length,
       mcpsNeedingKeys,
-      persona,
     });
 
     console.log();
-    logger.success(isVibe ? 'Done! Start Claude Code and describe what you want to build.' : 'Done! Claude Code is ready.');
+    if (createMode) {
+      if (bootstrapSucceeded) {
+        logger.success(`Project ${chalk.bold(createName)} created and bootstrapped!`);
+        console.log(chalk.dim(`  cd ${createName} && claude`));
+      } else {
+        logger.success(`Project ${chalk.bold(createName)} created with Claude configuration.`);
+        console.log(chalk.dim(`  cd ${createName} && claude -p "/bootstrap:auto ${createDescription}"`));
+      }
+    } else {
+      logger.success('Done! Claude Code is ready.');
+    }
     console.log();
   } catch (err) {
     if (
@@ -475,9 +647,9 @@ export async function runInstall(options = {}) {
 }
 
 /**
- * Count total installed items from guaranteed + selected candidates.
+ * Count total installed items from the summary.
  */
-function countTotalItems(summary, selectedCandidateIds) {
+function countTotalItems(summary) {
   const countBucket = (bucket) => {
     if (!bucket) return 0;
     return Object.values(bucket).reduce(
@@ -486,13 +658,30 @@ function countTotalItems(summary, selectedCandidateIds) {
     );
   };
 
-  let total = countBucket(summary.guaranteed);
-
-  if (selectedCandidateIds === null) {
-    total += countBucket(summary.candidates);
-  } else {
-    total += selectedCandidateIds.length;
-  }
+  return countBucket(summary.guaranteed) + countBucket(summary.candidates);
+}
 
-  return total;
+/**
+ * Build projectInfo from filesystem detection only (fallback for create mode re-analysis).
+ */
+function buildProjectInfoFromFs(fsDetected, name, description, projectType) {
+  return {
+    name: fsDetected.name || name,
+    description: fsDetected.description || description,
+    projectType: fsDetected.projectType || projectType,
+    languages: fsDetected.languages?.length ? fsDetected.languages : [],
+    frameworks: fsDetected.frameworks || [],
+    codeStyle: fsDetected.codeStyle || [],
+    cicd: fsDetected.cicd || [],
+    subprojects: fsDetected.subprojects || [],
+    architecture: '',
+    buildCommands: {},
+    complexity: 0.5,
+    metrics: null,
+    entryPoints: [],
+    coreModules: [],
+    testFramework: '',
+    packageManager: fsDetected.packageManager || '',
+    languageDistribution: fsDetected.languageDistribution || null,
+  };
 }