ccraft 1.0.0

package/src/commands/create.js

@@ -0,0 +1,543 @@
+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 { gatherCreateProfile, gatherMcpConfig, confirmInstallation } from '../prompts/gather.js';
+import { themedInput } from '../ui/prompts.js';
+import { callGenerate, ApiError } from '../utils/api-client.js';
+import { runPreflight } from '../utils/preflight.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 { rewriteClaudeMd } from '../utils/claude-rewriter.js';
+import { detectProject } from '../utils/detect-project.js';
+import { analyzeWithClaude } from '../utils/claude-analyzer.js';
+import { analyzeDescription } from '../utils/description-analyzer.js';
+import { platformCmd } from '../utils/run-claude.js';
+import { runBootstrap } from '../utils/bootstrap-runner.js';
+import {
+  writeAnalysisCache,
+  writeUserProfile,
+  updateManifest,
+  readAnalysisCache,
+  promoteCache,
+  cleanupAnalysisCache,
+} from '../utils/analysis-cache.js';
+import { VERSION } from '../constants.js';
+import * as logger from '../utils/logger.js';
+
+// UI modules
+import { renderBanner } from '../ui/brand.js';
+import { renderComponentBreakdown, renderMcpStatus, renderFileResults } from '../ui/tables.js';
+import { renderSuccessCard } from '../ui/cards.js';
+import { runInstallTasks, runVerifyTasks, runFinalizeTasks } from '../ui/tasks.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function renderCreatePhase(number, name, totalPhases) {
+  const w = Math.min((process.stdout.columns || 80) - 4, 56);
+  const label = `Phase ${number} of ${totalPhases}`;
+  const inner = ` ${label} \u2500\u2500 ${name} `;
+  const tailLen = Math.max(2, w - inner.length - 2);
+  console.log();
+  console.log(chalk.bold.cyan(`  \u2500\u2500${inner}${'\u2500'.repeat(tailLen)}`));
+  console.log();
+}
+
+function countTotalItems(summary, selectedCandidateIds) {
+  const countBucket = (bucket) => {
+    if (!bucket) return 0;
+    return Object.values(bucket).reduce(
+      (sum, arr) => sum + (Array.isArray(arr) ? arr.length : 0),
+      0,
+    );
+  };
+  let total = countBucket(summary.guaranteed);
+  if (selectedCandidateIds === null) {
+    total += countBucket(summary.candidates);
+  } else {
+    total += selectedCandidateIds.length;
+  }
+  return total;
+}
+
+// ── Main command ─────────────────────────────────────────────────────────────
+
+/**
+ * Create command — build a new project from scratch.
+ *
+ * Step 1: Welcome & Setup (env check + API key)
+ * Step 2: Project Setup (name, description, role, mkdir, git init)
+ * Step 3: Configuration & Install (synthetic analysis → server → write .claude/)
+ * Step 4: Bootstrap (hand off to Claude CLI /bootstrap:auto)
+ * Step 5: Post-bootstrap Sync (re-analyze, rewrite CLAUDE.md, finalize)
+ */
+export async function runCreate(options = {}) {
+  const TOTAL_PHASES = 5;
+  let targetDir;
+
+  try {
+    // ================================================================
+    // STEP 1: Welcome & Setup
+    // ================================================================
+    renderBanner(VERSION);
+    renderCreatePhase(1, 'Welcome & Setup', TOTAL_PHASES);
+
+    // ── Pre-flight checks (Claude Code + API key + server) ──────
+    await runPreflight({
+      interactive: !options.yes,
+      requireClaude: true,
+    });
+
+    // ================================================================
+    // STEP 2: Project Setup
+    // ================================================================
+    renderCreatePhase(2, 'Project Setup', TOTAL_PHASES);
+
+    let createProfile;
+    if (options.yes) {
+      createProfile = {
+        name: options.name || 'my-project',
+        description: options.description || 'A new project',
+        role: 'web',
+        projectType: 'monolith',
+      };
+      logger.info(`Non-interactive mode — creating ${chalk.bold(createProfile.name)} (web, monolith).`);
+    } else {
+      createProfile = await gatherCreateProfile();
+    }
+
+    let { name, description, role, projectType } = createProfile;
+
+    // Resolve target directory
+    const parentDir = resolve(options.dir || process.cwd());
+    let useCurrentDir = false;
+
+    if (!name) {
+      // Empty name = use current directory — must be empty
+      targetDir = parentDir;
+      useCurrentDir = true;
+      const contents = readdirSync(targetDir).filter((f) => f !== '.git');
+      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
+      targetDir = join(parentDir, name);
+      while (existsSync(targetDir)) {
+        logger.warn(`Directory ${chalk.bold(name)} already exists.`);
+        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);
+      }
+    }
+
+    // Create directory + git init
+    const spinner1 = ora(useCurrentDir ? 'Initializing project in current directory...' : 'Creating project directory...').start();
+    if (!useCurrentDir) {
+      mkdirSync(targetDir, { recursive: true });
+    }
+
+    // Write a minimal .gitignore
+    writeFileSync(
+      join(targetDir, '.gitignore'),
+      'node_modules/\ndist/\nbuild/\n.env\n.env.*\n!.env.example\n*.log\n.DS_Store\nThumbs.db\n',
+      'utf8',
+    );
+
+    // git init
+    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).`);
+    }
+
+    // Build user profile from role
+    const userProfile = {
+      role,
+      intents: ['implementing', 'debugging', 'refactoring', 'testing', 'reviewing'],
+      sourceControl: 'github',
+      documentTools: [],
+    };
+
+    // ================================================================
+    // STEP 3: Configuration & Install
+    // ================================================================
+    renderCreatePhase(3, 'Configuration', TOTAL_PHASES);
+
+    // Analyze description with Claude to infer tech stack
+    let descAnalysis = null;
+    {
+      const spinnerAnalyze = ora('Analyzing your requirements...').start();
+      const { analysis, failReason } = await analyzeDescription(description, role, projectType);
+      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.`);
+      }
+    }
+
+    // Build project info — enriched with description analysis if available
+    const syntheticProjectInfo = {
+      name,
+      description,
+      projectType,
+      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,
+    };
+
+    const syntheticDetected = {
+      ...syntheticProjectInfo,
+      sensitiveFiles: { found: [], gitignoreCovers: true },
+      _rootFiles: [],
+      databases: descAnalysis?.databases?.length ? descAnalysis.databases : [],
+    };
+
+    // Call server
+    const spinner3 = ora('Calling claude-craft server...').start();
+
+    let apiResponse;
+    try {
+      apiResponse = await callGenerate(
+        userProfile,
+        {
+          ...syntheticProjectInfo,
+          detectedFiles: [],
+          databases: syntheticDetected.databases,
+        },
+        {},
+      );
+      spinner3.succeed('Server returned configuration.');
+    } catch (err) {
+      spinner3.fail('Server request failed.');
+      if (err instanceof ApiError) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+      throw err;
+    }
+
+    const { summary, mcpConfigs } = apiResponse;
+
+    // Validate we got components
+    const guaranteedCount = summary?.guaranteed
+      ? Object.values(summary.guaranteed).reduce((s, arr) => s + (Array.isArray(arr) ? arr.length : 0), 0)
+      : 0;
+
+    if (guaranteedCount === 0) {
+      logger.warn('Server returned zero guaranteed components. Continuing with core defaults.');
+    }
+
+    // Display scoring summary
+    console.log();
+    renderComponentBreakdown(summary);
+
+    // MCP selection — auto-select core/role/stack for new projects (no stack to score against)
+    let selectedMcps;
+    let mcpKeys = {};
+    const securityConfig = { addSecurityGitignore: true };
+
+    if (options.yes) {
+      selectedMcps = mcpConfigs.filter(
+        (m) => m.tier === 'core' || m.tier === 'role' || m.tier === 'stack' || m.tier === 'auto' || m.recommended,
+      );
+    } else {
+      const mcpResult = await gatherMcpConfig(mcpConfigs);
+      selectedMcps = mcpResult.selectedMcps;
+      mcpKeys = mcpResult.mcpKeys;
+
+      const finalSummary = { ...summary, mcps: selectedMcps.map((m) => ({ id: m.id, tier: m.tier })) };
+      const proceed = await confirmInstallation(finalSummary);
+      if (!proceed) {
+        console.log();
+        logger.info('Cancelled.');
+        process.exit(0);
+      }
+    }
+
+    // Cache analysis and profile
+    try {
+      writeAnalysisCache(targetDir, syntheticProjectInfo, syntheticDetected, null);
+      writeUserProfile(targetDir, userProfile);
+    } catch (cacheErr) {
+      logger.debug(`Analysis cache write failed: ${cacheErr.message}`);
+    }
+
+    // Write files
+    let results;
+    let filesToWrite;
+    let selectedCandidateIds = null;
+
+    try {
+      const installCtx = await runInstallTasks({
+        apiResponse,
+        selectedCandidateIds: null,
+        targetDir,
+        selectedMcps,
+        mcpKeys,
+        securityConfig,
+        detected: syntheticDetected,
+        buildFileList,
+        writeApiFiles,
+        scoreWithClaude,
+      });
+
+      results = installCtx.results;
+      filesToWrite = installCtx.filesToWrite;
+      selectedCandidateIds = installCtx.selectedCandidateIds ?? null;
+    } catch {
+      // Fallback to direct write
+      const spinnerWrite = ora('Writing configuration files...').start();
+      filesToWrite = buildFileList(apiResponse, null);
+      results = await writeApiFiles(filesToWrite, targetDir, {
+        force: true,
+        selectedMcpIds: selectedMcps.map((m) => m.id),
+        mcpKeys,
+        securityConfig,
+        detected: syntheticDetected,
+      });
+      spinnerWrite.succeed('Configuration generated.');
+    }
+
+    // Update manifest
+    try {
+      if (filesToWrite) updateManifest(targetDir, results, filesToWrite);
+    } catch (cacheErr) {
+      logger.debug(`Manifest update failed: ${cacheErr.message}`);
+    }
+
+    // Display file results
+    renderFileResults(results);
+
+    // MCP verification
+    let mcpResults = [];
+    if (selectedMcps.length > 0) {
+      console.log();
+      try {
+        const verifyCtx = await runVerifyTasks(selectedMcps, mcpKeys, { setupMcps, targetDir });
+        mcpResults = verifyCtx.mcpResults;
+      } catch {
+        const spinnerMcp = ora('Verifying MCP servers...').start();
+        mcpResults = await setupMcps(selectedMcps, mcpKeys, {
+          healthCheck: true,
+          targetDir,
+          onStatus: (id, status) => {
+            if (status === 'verifying') spinnerMcp.text = `Verifying ${id}...`;
+            else if (status === 'testing') spinnerMcp.text = `Health-checking ${id}...`;
+          },
+        });
+        spinnerMcp.succeed('MCP verification complete.');
+      }
+
+      renderMcpStatus(mcpResults);
+    }
+
+    // ================================================================
+    // STEP 4: Bootstrap
+    // ================================================================
+    renderCreatePhase(4, 'Bootstrap', TOTAL_PHASES);
+
+    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();
+
+    let bootstrapSucceeded = true;
+    try {
+      await runBootstrap(targetDir, description);
+    } 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();
+    }
+
+    // ================================================================
+    // STEP 5: Post-Bootstrap Sync
+    // ================================================================
+    renderCreatePhase(5, 'Finalization', TOTAL_PHASES);
+
+    if (bootstrapSucceeded) {
+      // Re-analyze the now-real project
+      try {
+        const spinner5 = ora('Re-analyzing project...').start();
+        const fsDetected = await detectProject(targetDir);
+
+        let projectInfo;
+        try {
+          const { analysis } = await analyzeWithClaude(targetDir);
+          if (analysis) {
+            projectInfo = {
+              name: analysis.name || fsDetected.name || name,
+              description: analysis.description || fsDetected.description || description,
+              projectType: analysis.projectType || fsDetected.projectType || projectType,
+              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 {
+            projectInfo = buildProjectInfoFromFs(fsDetected, name, description, projectType);
+          }
+        } catch {
+          projectInfo = buildProjectInfoFromFs(fsDetected, name, description, projectType);
+        }
+
+        spinner5.succeed('Project re-analyzed.');
+
+        // Overwrite cache with real data
+        const detected = { ...fsDetected, ...projectInfo };
+        writeAnalysisCache(targetDir, projectInfo, detected, null);
+        writeUserProfile(targetDir, userProfile);
+      } catch (err) {
+        logger.debug(`Post-bootstrap analysis failed: ${err.message}`);
+      }
+    }
+
+    // Finalize — optimize settings + rewrite CLAUDE.md
+    try {
+      await runFinalizeTasks({
+        targetDir,
+        readAnalysisCache,
+        optimizeSettings,
+        rewriteClaudeMd,
+      });
+    } catch {
+      // Fallback to sequential
+      const spinnerOpt = ora('Optimizing settings...').start();
+      const optResult = optimizeSettings(targetDir);
+      if (optResult.status === 'ok' && optResult.applied > 0) {
+        spinnerOpt.succeed(`Optimized ${optResult.applied} setting(s).`);
+      } else {
+        spinnerOpt.succeed('Settings reviewed \u2014 no changes needed.');
+      }
+
+      const spinnerMd = ora('Rewriting CLAUDE.md...').start();
+      const cache = readAnalysisCache(targetDir);
+      const rewritten = await rewriteClaudeMd(targetDir, cache);
+      if (rewritten) {
+        spinnerMd.succeed('CLAUDE.md rewritten.');
+      } else {
+        spinnerMd.warn('CLAUDE.md rewrite skipped \u2014 using template version.');
+      }
+    }
+
+    // ── Success ──────────────────────────────────────────────────────
+    const totalItems = countTotalItems(summary, selectedCandidateIds);
+    const mcpsNeedingKeys = mcpResults.filter((r) => r.status === 'needs-key');
+
+    renderSuccessCard({
+      totalItems,
+      mcpCount: selectedMcps.length,
+      mcpsNeedingKeys,
+    });
+
+    console.log();
+    if (bootstrapSucceeded) {
+      logger.success(`Project ${chalk.bold(name)} created and bootstrapped!`);
+      console.log(chalk.dim(`  cd ${name} && claude`));
+    } else {
+      logger.success(`Project ${chalk.bold(name)} created with Claude configuration.`);
+      console.log(chalk.dim(`  cd ${name} && claude -p "/bootstrap:auto ${description}"`));
+    }
+    console.log();
+  } catch (err) {
+    if (
+      err &&
+      (err.name === 'ExitPromptError' ||
+        err.constructor?.name === 'ExitPromptError' ||
+        err.message?.includes('User force closed'))
+    ) {
+      console.log();
+      logger.info('Cancelled.');
+      process.exit(0);
+    }
+
+    console.log();
+    logger.error(err.message || String(err));
+    process.exit(1);
+  } finally {
+    if (targetDir) {
+      try {
+        promoteCache(targetDir);
+        cleanupAnalysisCache(targetDir);
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  }
+}
+
+// ── Helper: build projectInfo from filesystem detection only ─────────────────
+
+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,
+  };
+}