ccraft 1.0.0

package/src/commands/update.js

@@ -0,0 +1,339 @@
+/**
+ * Update command — re-analyzes the project, compares to the last install snapshot,
+ * calls /api/update to get delta components, and installs only what's new.
+ *
+ * Flow:
+ *   1. Load stored user profile + analysis from .claude/.claude-craft/
+ *   2. Re-run project analysis (detectProject + analyzeWithClaude)
+ *   3. Extract installed relative paths from manifest
+ *   4. Call /api/update — server returns only new/unlocked components
+ *   5. Show change summary + new component counts
+ *   6. Confirm, write files, merge manifest
+ */
+import { resolve, sep } 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 {
+  readUserProfile,
+  readPermanentAnalysis,
+  readInstalledManifest,
+  mergePermanentManifest,
+} from '../utils/analysis-cache.js';
+import { callUpdate, ApiError } from '../utils/api-client.js';
+import { runPreflight } from '../utils/preflight.js';
+import { writeApiFiles, buildFileList } from '../utils/api-file-writer.js';
+import { colors, icons } from '../ui/theme.js';
+import { dotPad } from '../ui/format.js';
+import { renderFileResults } from '../ui/tables.js';
+import { themedConfirm } from '../ui/prompts.js';
+import * as logger from '../utils/logger.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * Extract normalized relative paths from the installed manifest.
+ * Strips the targetDir prefix so paths are relative (e.g. ".claude/agents/orchestrator.md").
+ */
+function extractRelativePaths(manifest, targetDir) {
+  if (!manifest?.files) return [];
+
+  const prefix = targetDir.endsWith(sep) ? targetDir : targetDir + sep;
+  // Also handle forward-slash variant on Windows
+  const prefixFwd = prefix.replace(/\\/g, '/');
+
+  return manifest.files
+    .map((f) => {
+      let p = (f.relativePath || '').replace(/\\/g, '/');
+      if (p.startsWith(prefixFwd)) p = p.slice(prefixFwd.length);
+      return p;
+    })
+    .filter(Boolean);
+}
+
+/**
+ * Render the detected stack changes to the console.
+ */
+function renderChanges(changes, currentAnalysis) {
+  const { addedFrameworks, removedFrameworks, addedLanguages, addedSubprojects,
+          testFrameworkChanged, packageManagerChanged, hasChanges } = changes;
+
+  if (!hasChanges) {
+    console.log(chalk.dim('  No stack changes detected since last install.'));
+    return;
+  }
+
+  console.log(chalk.bold('  Stack changes'));
+  console.log();
+
+  if (addedFrameworks.length > 0) {
+    for (const fw of addedFrameworks) {
+      console.log(`  ${icons.plus} ${colors.success(fw)} ${chalk.dim('(new framework)')}`);
+    }
+  }
+  if (removedFrameworks.length > 0) {
+    for (const fw of removedFrameworks) {
+      console.log(`  ${chalk.dim('─')} ${chalk.dim(fw)} ${chalk.dim('(removed)')}`);
+    }
+  }
+  if (addedLanguages.length > 0) {
+    for (const lang of addedLanguages) {
+      console.log(`  ${icons.plus} ${colors.success(lang)} ${chalk.dim('(new language)')}`);
+    }
+  }
+  if (addedSubprojects.length > 0) {
+    for (const sub of addedSubprojects) {
+      console.log(`  ${icons.plus} ${colors.success(sub)} ${chalk.dim('(new subproject)')}`);
+    }
+  }
+  if (testFrameworkChanged && currentAnalysis.testFramework) {
+    console.log(
+      `  ${icons.plus} ${colors.success(currentAnalysis.testFramework)} ${chalk.dim('(test framework detected)')}`,
+    );
+  }
+  if (packageManagerChanged) {
+    console.log(
+      `  ${icons.tilde} ${colors.warning('package manager changed')} ${chalk.dim(`→ ${currentAnalysis.packageManager}`)}`,
+    );
+  }
+}
+
+/**
+ * Render the delta component counts.
+ */
+function renderDeltaSummary(delta) {
+  const total = Object.values(delta).reduce((s, n) => s + n, 0);
+  if (total === 0) {
+    console.log(chalk.dim('  No new components to install.'));
+    return false;
+  }
+
+  console.log(chalk.bold(`  New components: ${colors.success(String(total))}`));
+  const entries = Object.entries(delta).filter(([, n]) => n > 0);
+  for (const [cat, count] of entries) {
+    console.log(chalk.dim(`    ${dotPad(cat, colors.success(String(count)))}`));
+  }
+  return true;
+}
+
+// ── Main command ─────────────────────────────────────────────────────────────
+
+/**
+ * @param {object} options - { dir, yes }
+ */
+export async function runUpdate(options = {}) {
+  try {
+    const targetDir = resolve(options.dir || process.cwd());
+
+    // ── Pre-flight checks (Claude Code + project marker + API key + server)
+    await runPreflight({
+      interactive: !options.yes,
+      requireClaude: true,
+      requireCraftProject: true,
+      targetDir,
+    });
+
+    // ── Guard: must have a previous install ───────────────────────────
+    const storedProfile = readUserProfile(targetDir);
+    const previousAnalysis = readPermanentAnalysis(targetDir);
+    const installedManifest = readInstalledManifest(targetDir);
+
+    if (!storedProfile) {
+      logger.error(
+        'No stored user profile found. Re-run: ' + chalk.bold('claude-craft install') +
+          ' to rebuild the profile cache.',
+      );
+      process.exit(1);
+    }
+
+    if (!previousAnalysis) {
+      logger.error(
+        'No stored project analysis found. Re-run: ' + chalk.bold('claude-craft install') +
+          ' to rebuild the analysis cache.',
+      );
+      process.exit(1);
+    }
+
+    console.log(chalk.bold('  claude-craft update'));
+    console.log(chalk.dim('  Re-analyzing project and checking for new components...'));
+    console.log();
+
+    // ── Phase 1: Re-analyze project ───────────────────────────────────
+    let currentProjectInfo;
+    let fsDetected;
+
+    const spinner = ora('Analyzing project...').start();
+    try {
+      fsDetected = await detectProject(targetDir);
+
+      let claudeAnalysis = null;
+      try {
+        const result = await analyzeWithClaude(targetDir);
+        claudeAnalysis = result.analysis;
+      } catch {
+        // Claude unavailable — fall back to filesystem detection only
+      }
+
+      if (claudeAnalysis) {
+        currentProjectInfo = {
+          name: claudeAnalysis.name || fsDetected.name || previousAnalysis.name || 'my-project',
+          description: claudeAnalysis.description || fsDetected.description || '',
+          projectType: claudeAnalysis.projectType || fsDetected.projectType || 'monolith',
+          languages: claudeAnalysis.languages?.length ? claudeAnalysis.languages : fsDetected.languages,
+          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 {
+        currentProjectInfo = {
+          name: fsDetected.name || previousAnalysis.name || 'my-project',
+          description: fsDetected.description || '',
+          projectType: fsDetected.projectType || 'monolith',
+          languages: fsDetected.languages?.length ? fsDetected.languages : previousAnalysis.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,
+        };
+      }
+
+      spinner.succeed('Project analyzed.');
+    } catch (err) {
+      spinner.fail('Analysis failed: ' + err.message);
+      process.exit(1);
+    }
+
+    // ── Phase 2: Build installed path list ────────────────────────────
+    const installedRelativePaths = extractRelativePaths(installedManifest, targetDir);
+
+    // ── Phase 3: Call /api/update ─────────────────────────────────────
+    const spinner2 = ora('Checking for new components...').start();
+    let updateResponse;
+    try {
+      updateResponse = await callUpdate(
+        storedProfile,
+        currentProjectInfo,
+        previousAnalysis,
+        installedRelativePaths,
+      );
+      spinner2.succeed('Server responded.');
+    } catch (err) {
+      spinner2.fail('Server request failed.');
+      if (err instanceof ApiError) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+      throw err;
+    }
+
+    const { changes, summary } = updateResponse;
+
+    // ── Display results ───────────────────────────────────────────────
+    console.log();
+    renderChanges(changes, currentProjectInfo);
+    console.log();
+
+    const hasNewComponents = renderDeltaSummary(summary?.delta || {});
+
+    if (!changes.hasChanges && !hasNewComponents) {
+      console.log();
+      logger.success('Already up to date. Nothing to install.');
+      console.log();
+      process.exit(0);
+    }
+
+    if (!hasNewComponents) {
+      console.log();
+      logger.success('Stack changes noted — no new components needed.');
+      console.log();
+      process.exit(0);
+    }
+
+    // ── Confirm + install ─────────────────────────────────────────────
+    console.log();
+
+    let proceed = true;
+    if (!options.yes) {
+      proceed = await themedConfirm({ message: 'Install new components?', default: true });
+    }
+
+    if (!proceed) {
+      console.log();
+      logger.info('Cancelled.');
+      process.exit(0);
+    }
+
+    // ── Write new files ───────────────────────────────────────────────
+    const filesToWrite = buildFileList(updateResponse, null);
+
+    if (filesToWrite.length === 0) {
+      console.log();
+      logger.success('No files to write. Already up to date.');
+      process.exit(0);
+    }
+
+    const writeSpinner = ora('Writing new components...').start();
+    let results;
+    try {
+      results = await writeApiFiles(filesToWrite, targetDir, {
+        force: true,
+        selectedMcpIds: [],
+        detected: { ...fsDetected, ...currentProjectInfo },
+      });
+      writeSpinner.succeed('Components installed.');
+    } catch (err) {
+      writeSpinner.fail('Write failed: ' + err.message);
+      throw err;
+    }
+
+    // ── Display written files ─────────────────────────────────────────
+    console.log();
+    renderFileResults(results);
+
+    // ── Update manifest ───────────────────────────────────────────────
+    try {
+      mergePermanentManifest(targetDir, results, filesToWrite);
+    } catch (err) {
+      logger.debug(`Manifest merge failed: ${err.message}`);
+    }
+
+    console.log();
+    logger.success('Done! New components installed.');
+    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);
+  }
+}

package/src/constants.js

@@ -0,0 +1,299 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+
+export const VERSION = pkg.version;
+export const TOOL_NAME = 'claude-craft';
+
+// ── Step 1: User roles & intents ──────────────────────────────────────
+
+export const ROLES = [
+  {
+    name: 'Developer',
+    value: 'developer',
+    description: 'Build and ship software across the stack',
+    children: [
+      { name: 'Web', value: 'web', description: 'Frontend and backend development' },
+      { name: 'Mobile', value: 'mobile', description: 'iOS, Android, and cross-platform apps' },
+      { name: 'Game', value: 'game', description: 'Game engines, rendering, and gameplay' },
+      { name: 'Blockchain', value: 'blockchain', description: 'Smart contracts, DApps, and Web3' },
+      { name: 'Embedded', value: 'embedded', description: 'Firmware, IoT, and low-level systems' },
+    ],
+  },
+  { name: 'DevOps', value: 'devops', description: 'Infrastructure, CI/CD, and deployment pipelines' },
+  {
+    name: 'Data & Analytics',
+    value: 'data-analytics',
+    description: 'Data pipelines, analysis, ML, and visualization',
+    children: [
+      { name: 'Data Scientist', value: 'data-scientist', description: 'ML models, experiments, and research' },
+      { name: 'Data Engineer', value: 'data-engineer', description: 'Pipelines, ETL, and data infrastructure' },
+      { name: 'Data Analyst', value: 'data-analyst', description: 'Queries, dashboards, and reporting' },
+    ],
+  },
+  { name: 'Quality Assurance', value: 'qa', description: 'Testing strategy, automation, and quality gates' },
+  { name: 'Cybersecurity', value: 'cybersecurity', description: 'Security audits, vulnerability analysis, hardening' },
+  { name: 'Product & Design', value: 'product-design', description: 'Product specs, design systems, UX workflows' },
+];
+
+export const ROLE_DISPLAY_NAMES = {
+  web: 'Web Developer',
+  mobile: 'Mobile Developer',
+  game: 'Game Developer',
+  blockchain: 'Blockchain Developer',
+  embedded: 'Embedded Developer',
+  devops: 'DevOps / Infrastructure',
+  'data-scientist': 'Data Scientist',
+  'data-engineer': 'Data Engineer',
+  'data-analyst': 'Data Analyst',
+  qa: 'Quality Assurance',
+  cybersecurity: 'Cybersecurity',
+  'product-design': 'Product & Design',
+};
+
+export const INTENTS = [
+  { name: 'Implementing new features', value: 'implementing', description: 'Build features from specs, tickets, or ideas' },
+  { name: 'Debugging & troubleshooting', value: 'debugging', description: 'Track down bugs, analyze stack traces, fix issues' },
+  { name: 'Refactoring & cleanup', value: 'refactoring', description: 'Improve code structure without changing behavior' },
+  { name: 'Writing documentation', value: 'documentation', description: 'READMEs, API docs, architecture decisions' },
+  { name: 'Testing & QA', value: 'testing', description: 'Unit, integration, and e2e tests' },
+  { name: 'Code review', value: 'reviewing', description: 'Review PRs, suggest improvements, catch issues' },
+];
+
+// ── Source control platforms ─────────────────────────────────────────
+
+export const SOURCE_CONTROLS = [
+  { name: 'GitHub', value: 'github', description: 'GitHub.com or GitHub Enterprise' },
+  { name: 'GitLab', value: 'gitlab', description: 'GitLab.com or self-hosted' },
+  { name: 'Bitbucket', value: 'bitbucket', description: 'Bitbucket Cloud or Data Center' },
+  { name: 'Azure DevOps', value: 'azure-devops', description: 'Azure Repos and Pipelines' },
+  { name: 'None / Git only', value: 'none', description: 'Local git without a hosting platform' },
+];
+
+// ── Document & project management tools ─────────────────────────────
+
+export const DOCUMENT_TOOLS = [
+  { name: 'None', value: 'none' },
+  { name: 'Notion', value: 'notion' },
+  { name: 'Linear', value: 'linear' },
+  { name: 'Google Docs', value: 'google-docs' },
+  { name: 'Confluence', value: 'confluence' },
+  { name: 'Jira', value: 'jira' },
+  { name: 'Azure DevOps', value: 'azure-devops' },
+  { name: 'ClickUp', value: 'clickup' },
+  { name: 'Asana', value: 'asana' },
+  { name: 'Shortcut', value: 'shortcut' },
+  { name: 'Monday.com', value: 'monday' },
+  { name: 'YouTrack', value: 'youtrack' },
+  { name: 'Trello', value: 'trello' },
+  { name: 'Todoist', value: 'todoist' },
+  { name: 'Plane', value: 'plane' },
+  { name: 'Other', value: 'other' },
+];
+
+// ── Step 2: Project types ─────────────────────────────────────────────
+
+export const PROJECT_TYPES = [
+  { name: 'Monorepo (multiple packages/apps)', value: 'monorepo' },
+  { name: 'Microservices', value: 'microservice' },
+  { name: 'Monolith', value: 'monolith' },
+  { name: 'Library / Package', value: 'library' },
+  { name: 'CLI Tool', value: 'cli' },
+  { name: 'Other / Unknown', value: 'other' },
+];
+
+// ── Languages & Frameworks ────────────────────────────────────────────
+
+export const SUPPORTED_LANGUAGES = [
+  'JavaScript',
+  'TypeScript',
+  'Python',
+  'Go',
+  'Rust',
+  'Java',
+  'C#',
+  'Ruby',
+  'PHP',
+  'Swift',
+  'Kotlin',
+  'Dart',
+  'SQL',
+  'Solidity',
+  'C',
+  'C++',
+];
+
+export const SUPPORTED_FRAMEWORKS = [
+  // Web frameworks
+  'Next.js',
+  'React',
+  'Vue',
+  'Angular',
+  'Express',
+  'Fastify',
+  'Django',
+  'Flask',
+  'FastAPI',
+  'Gin',
+  'Echo',
+  'Actix',
+  'Spring Boot',
+  'ASP.NET Core',
+  'Rails',
+  'Laravel',
+  'Tailwind CSS',
+  // Expanded web frameworks
+  'SvelteKit',
+  'Nuxt',
+  'Astro',
+  'Gatsby',
+  'NestJS',
+  'Remix',
+  'Socket.io',
+  // Desktop / Mobile
+  'Electron',
+  'React Native',
+  'Expo',
+  'Tauri',
+  'Flutter',
+  // Blockchain
+  'Hardhat',
+  'Foundry',
+  'Web3',
+  // Data / AI
+  'GraphQL',
+  'LangChain',
+  'OpenAI SDK',
+  'PyTorch',
+  'TensorFlow',
+  'scikit-learn',
+  'Streamlit',
+  'Airflow',
+  'Pandas',
+  'Pydantic',
+  'Hugging Face',
+  // Game
+  'Phaser',
+  'Three.js',
+  'Unity',
+  'Godot',
+  'Babylon.js',
+  // ORM / DB
+  'Prisma',
+  'Drizzle',
+  // Go frameworks
+  'Go API',
+  'Cobra',
+  'Fiber',
+  // Rust frameworks
+  'Tokio',
+  'Axum',
+  'Warp',
+  'Clap',
+  // Infrastructure
+  'Terraform',
+  'Serverless Framework',
+  // Static sites
+  'Hugo',
+  'Jekyll',
+  'Docusaurus',
+  // Mobile / Desktop (extended)
+  'Jetpack Compose',
+  '.NET MAUI',
+  // Data
+  'dbt',
+  'Dash',
+  // AI (extended)
+  'LlamaIndex',
+  'Vercel AI SDK',
+  // Testing
+  'Playwright',
+  // Bot
+  'Discord.js',
+  // .NET variants
+  'Razor',
+  'Blazor',
+  'Graphene',
+  'HotChocolate',
+  'SignalR',
+  // CMS / E-commerce
+  'WordPress',
+  'Shopify',
+  // Other
+  'Single-SPA',
+  'CLI Framework',
+  'Scrapy',
+  'Browser Extension',
+  // C / C++ build systems
+  'CMake',
+  'Meson',
+  'Bazel',
+  // C / C++ GUI
+  'Qt',
+  'GTK',
+  'wxWidgets',
+  'Dear ImGui',
+  // C / C++ multimedia / game
+  'SDL',
+  'SFML',
+  'Unreal Engine',
+  // C / C++ web / networking
+  'Boost',
+  'Drogon',
+  'Crow',
+  'gRPC',
+  // C / C++ embedded / IoT
+  'FreeRTOS',
+  'ESP-IDF',
+  'Zephyr',
+  // C / C++ ML / vision
+  'OpenCV',
+  // C / C++ testing
+  'Google Test',
+  'Catch2',
+];
+
+// ── Components (now auto-selected by scoring) ─────────────────────────
+
+export const COMPONENTS = [
+  { name: 'CLAUDE.md', value: 'claude-md', checked: true },
+{ name: 'Agents (.claude/agents/)', value: 'agents', checked: true },
+  { name: 'Rules (.claude/rules/)', value: 'rules', checked: true },
+  { name: 'Hooks (.claude/settings.json)', value: 'hooks', checked: true },
+  { name: 'Skills (.claude/skills/)', value: 'skills', checked: true },
+  { name: 'Commands (.claude/commands/)', value: 'commands', checked: true },
+  { name: 'MCP Servers (.claude/settings.json)', value: 'mcps', checked: true },
+  { name: 'Workflows (.claude/workflows/)', value: 'workflows', checked: true },
+  { name: 'User Guide', value: 'user-guide', checked: true },
+];
+
+export const PRESET_ALIASES = {
+  nextjs:    { frameworks: ['Next.js'], languages: ['TypeScript'] },
+  'go-api':  { frameworks: ['Go API'], languages: ['Go'] },
+  python:    { frameworks: [], languages: ['Python'] },
+  rust:      { frameworks: [], languages: ['Rust'] },
+  aspnet:    { frameworks: ['ASP.NET Core'], languages: ['C#'] },
+  cmake:     { frameworks: ['CMake'], languages: ['C++'] },
+};
+
+// ── Security defaults ─────────────────────────────────────────────────
+
+// ── Component types ──────────────────────────────────────────────────
+
+export const COMPONENT_TYPES = {
+  CORE: 'core',
+  OPTIONAL: 'optional',
+  PLUGIN: 'plugin',
+};
+
+export const SENSITIVE_PATTERNS = [
+  '.env', '.env.*', '*.pem', '*.key', '*.cert',
+  'credentials.json', 'secrets.yaml', 'secrets.yml',
+  '*.secret', 'id_rsa', 'id_ed25519',
+  '.aws/credentials', '.gcp/credentials.json',
+  'serviceAccountKey.json', 'firebase-adminsdk*.json',
+];

package/src/generators/directories.js

@@ -0,0 +1,30 @@
+import { join } from 'path';
+import { ensureDir, outputFile } from 'fs-extra/esm';
+import { pathExists } from 'fs-extra/esm';
+
+const directories = [
+  '.claude/scripts',
+  '.claude/mcps',
+  '.claude/workflows',
+];
+
+export async function generate(config, targetDir, opts = {}) {
+  const results = [];
+
+  for (const dir of directories) {
+    const dirPath = join(targetDir, dir);
+    await ensureDir(dirPath);
+
+    const gitkeepPath = join(dirPath, '.gitkeep');
+    const exists = await pathExists(gitkeepPath);
+
+    if (!exists) {
+      await outputFile(gitkeepPath, '');
+      results.push({ path: gitkeepPath, status: 'created' });
+    } else {
+      results.push({ path: gitkeepPath, status: 'exists' });
+    }
+  }
+
+  return results;
+}