ccraft 1.0.0

package/src/commands/install.js

@@ -0,0 +1,480 @@
+import { resolve } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { detectProject } from '../utils/detect-project.js';
+import { analyzeWithClaude } from '../utils/claude-analyzer.js';
+import { rewriteClaudeMd } from '../utils/claude-rewriter.js';
+import {
+  detectExistingSetup,
+  extractExistingContext,
+  removeExistingSetup,
+} from '../utils/existing-setup.js';
+import {
+  gatherProjectPath,
+  gatherUserProfile,
+  gatherMcpConfig,
+  gatherSecurityConfig,
+  confirmInstallation,
+} from '../prompts/gather.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 {
+  writeAnalysisCache,
+  writeUserProfile,
+  updateManifest,
+  readAnalysisCache,
+  promoteCache,
+  cleanupAnalysisCache,
+} from '../utils/analysis-cache.js';
+import { PRESET_ALIASES, VERSION } from '../constants.js';
+import * as logger from '../utils/logger.js';
+
+// UI modules
+import { renderBanner } from '../ui/brand.js';
+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';
+
+/**
+ * Main install command — 5-phase orchestrator.
+ *
+ * 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)
+ */
+export async function runInstall(options = {}) {
+  let targetDir;
+  try {
+    // ================================================================
+    // PHASE 1: Welcome & Setup
+    // ================================================================
+    renderBanner(VERSION);
+
+    // ── Pre-flight checks (Claude Code + API key + server) ──────
+    const { apiConfig } = await runPreflight({
+      interactive: !options.yes,
+      requireClaude: true,
+    });
+
+    // ── Project path ────────────────────────────────────────────────
+    if (!options.yes && !options.dir) {
+      targetDir = await gatherProjectPath();
+    } else {
+      targetDir = resolve(options.dir || process.cwd());
+    }
+
+    // ── User profile ───────────────────────────────────────────────
+    renderPhaseHeader(1);
+
+    let userProfile;
+    if (options.yes) {
+      userProfile = { role: 'web', intents: ['implementing', 'debugging', 'refactoring', 'testing', 'reviewing'], sourceControl: 'github', documentTools: [] };
+      logger.info('Non-interactive mode — using default profile (web, all intents, github).');
+    } else {
+      userProfile = await gatherUserProfile();
+    }
+
+    // ================================================================
+    // 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}`);
+    }
+
+    // ── Project analysis ────────────────────────────────────────────
+    let projectInfo;
+    let detected;
+
+    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 || '',
+        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 };
+    }
+
+    // Cache analysis and user profile 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);
+
+    const spinner3 = ora('Calling claude-craft server...').start();
+
+    let apiResponse;
+    try {
+      apiResponse = await callGenerate(
+        userProfile,
+        {
+          name: projectInfo.name,
+          projectType: projectInfo.projectType,
+          languages: projectInfo.languages,
+          languageDistribution: projectInfo.languageDistribution,
+          frameworks: projectInfo.frameworks,
+          complexity: projectInfo.complexity,
+          architecture: projectInfo.architecture,
+          buildCommands: projectInfo.buildCommands,
+          codeStyle: projectInfo.codeStyle,
+          cicd: projectInfo.cicd,
+          subprojects: projectInfo.subprojects,
+          metrics: projectInfo.metrics,
+          entryPoints: projectInfo.entryPoints,
+          coreModules: projectInfo.coreModules,
+          testFramework: projectInfo.testFramework,
+          packageManager: projectInfo.packageManager,
+          detectedFiles: detected._rootFiles || [],
+          databases: projectInfo.databases || detected.databases || [],
+        },
+        { preset: options.preset },
+      );
+      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;
+
+    // Display scoring summary
+    console.log();
+    renderComponentBreakdown(summary);
+
+    // MCP selection + credential setup + security + confirmation
+    let selectedMcps;
+    let mcpKeys = {};
+    let securityConfig;
+
+    if (options.yes) {
+      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);
+
+      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);
+      }
+    }
+
+    // ================================================================
+    // PHASE 4: Installation
+    // ================================================================
+    renderPhaseHeader(4);
+
+    let results;
+    let filesToWrite;
+    let selectedCandidateIds = null;
+
+    try {
+      const installCtx = await runInstallTasks({
+        apiResponse,
+        selectedCandidateIds: null,
+        targetDir,
+        selectedMcps,
+        mcpKeys,
+        securityConfig,
+        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);
+      results = await writeApiFiles(filesToWrite, targetDir, {
+        force: true,
+        selectedMcpIds: selectedMcps.map((m) => m.id),
+        mcpKeys,
+        securityConfig,
+        detected,
+      });
+      spinnerWrite.succeed('Configuration generated.');
+    }
+
+    // Update cache with installed file 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);
+    }
+
+    // ================================================================
+    // PHASE 5: Finalization
+    // ================================================================
+    renderPhaseHeader(5);
+
+    try {
+      const finCtx = await runFinalizeTasks({
+        targetDir,
+        readAnalysisCache,
+        optimizeSettings,
+        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) {
+          console.log(chalk.dim(`    • ${label}`));
+        }
+      }
+    } 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);
+
+      if (optResult.status === 'ok' && optResult.applied > 0) {
+        spinner7.succeed(`Optimized ${optResult.applied} setting(s).`);
+      } else {
+        spinner7.succeed('Settings reviewed — no changes needed.');
+      }
+
+      const spinner8 = ora('Rewriting CLAUDE.md...').start();
+      const cache8 = readAnalysisCache(targetDir);
+      const rewritten = await rewriteClaudeMd(targetDir, cache8);
+      if (rewritten) {
+        spinner8.succeed('CLAUDE.md rewritten.');
+      } else {
+        spinner8.warn('CLAUDE.md rewrite skipped — 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();
+    logger.success('Done! Claude Code is ready.');
+    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
+      }
+    }
+  }
+}
+
+/**
+ * Count total installed items from guaranteed + selected candidates.
+ */
+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;
+}

package/src/commands/logout.js

@@ -0,0 +1,24 @@
+/**
+ * Logout command — clear stored API key.
+ *
+ * Usage: claude-craft logout
+ */
+import chalk from 'chalk';
+import { loadConfig, saveConfig } from '../utils/api-client.js';
+import * as logger from '../utils/logger.js';
+
+export async function runLogout() {
+  const config = loadConfig();
+
+  if (!config?.apiKey) {
+    logger.warn('No API key is currently stored.');
+    return;
+  }
+
+  const { apiKey, ...rest } = config;
+  saveConfig(rest);
+
+  console.log();
+  logger.success('API key removed from ~/.claude-craft/config.json');
+  console.log();
+}