@buoy-design/cli 0.1.30 → 0.2.0

package/dist/commands/dock.js

@@ -1,885 +1,647 @@
+/**
+ * buoy dock - Dock Buoy into your project
+ *
+ * Smart walkthrough that sets up config, agents, and hooks.
+ *
+ * Usage:
+ *   buoy dock              # Smart walkthrough: config → agents → hooks
+ *   buoy dock config       # Just create buoy.config.mjs
+ *   buoy dock agents       # Set up AI agents (skills + context)
+ *   buoy dock skills       # Just create skill files
+ *   buoy dock context      # Just generate CLAUDE.md section
+ *   buoy dock hooks        # Just set up git hooks
+ */
 import { Command } from "commander";
-import { writeFileSync, existsSync, readFileSync } from "fs";
-import { resolve, extname } from "path";
+import { writeFileSync, existsSync, readFileSync, mkdirSync, appendFileSync, copyFileSync, readdirSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
 import chalk from "chalk";
-import ora from "ora";
 import { createInterface } from "readline";
-import { success, error, info, warning } from "../output/reporters.js";
-import { ProjectDetector, detectMonorepoConfig, expandPatternsForMonorepo, } from "../detect/index.js";
-import { detectFrameworks, getPluginInstallCommand, PLUGIN_INFO, BUILTIN_SCANNERS, } from "../detect/frameworks.js";
-import { setupHooks, generateStandaloneHook, detectHookSystem, } from "../hooks/index.js";
-import { parseTokenFile, detectFormat } from "@buoy-design/core";
-function generateConfig(project) {
-    const lines = [];
-    // Detect monorepo configuration for pattern expansion
-    const monorepoConfig = detectMonorepoConfig(project.root);
-    lines.push(`/** @type {import('@buoy-design/cli').BuoyConfig} */`);
-    lines.push(`export default {`);
-    lines.push(`  project: {`);
-    lines.push(`    name: '${project.name}',`);
-    lines.push(`  },`);
-    lines.push(`  sources: {`);
-    // Determine the correct source key based on framework
-    const getSourceKey = (frameworkName) => {
-        // React-based frameworks
-        if ([
-            "react",
-            "nextjs",
-            "remix",
-            "gatsby",
-            "react-native",
-            "expo",
-            "preact",
-            "solid",
-        ].includes(frameworkName)) {
-            return "react";
-        }
-        // Vue-based frameworks
-        if (["vue", "nuxt"].includes(frameworkName)) {
-            return "vue";
-        }
-        // Svelte-based frameworks
-        if (["svelte", "sveltekit"].includes(frameworkName)) {
-            return "svelte";
-        }
-        // Angular
-        if (frameworkName === "angular") {
-            return "angular";
-        }
-        // Web Components
-        if (["lit", "stencil"].includes(frameworkName)) {
-            return "webcomponent";
-        }
-        // Astro is special - can use multiple frameworks
-        if (frameworkName === "astro") {
-            return "react"; // Default to React for Astro
-        }
-        return null;
+import ora from "ora";
+import { success, error, info, warning, setJsonMode, spinner } from "../output/reporters.js";
+import { loadConfig, getConfigPath } from "../config/loader.js";
+import { buildAutoConfig } from "../config/auto-detect.js";
+import { ScanOrchestrator } from "../scan/orchestrator.js";
+import { SkillExportService } from "../services/skill-export.js";
+import { generateContext } from "../services/context-generator.js";
+import { setupHooks, generateStandaloneHook, detectHookSystem, setupClaudeHooks } from "../hooks/index.js";
+import { ProjectDetector, detectMonorepoConfig, expandPatternsForMonorepo } from "../detect/index.js";
+import { detectFrameworks, getPluginInstallCommand } from "../detect/frameworks.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export function createDockCommand() {
+    const cmd = new Command("dock")
+        .description("Dock Buoy into your project")
+        .option("-y, --yes", "Auto-accept all defaults")
+        .option("--json", "Output results as JSON")
+        .action(async (options) => {
+        await runSmartDock(options);
+    });
+    // dock config - Just create config
+    cmd
+        .command("config")
+        .description("Create buoy.config.mjs")
+        .option("-f, --force", "Overwrite existing configuration")
+        .option("-y, --yes", "Auto-install recommended plugins without prompting")
+        .option("--skip-detect", "Skip auto-detection and create minimal config")
+        .action(async (options) => {
+        await runConfigDock(options);
+    });
+    // dock agents - Full AI agent onboarding
+    cmd
+        .command("agents")
+        .description("Set up AI agents with your design system")
+        .option("--dry-run", "Show what would be created without writing files")
+        .option("--json", "Output result as JSON")
+        .action(async (options) => {
+        await runAgentsDock(options);
+    });
+    // dock skills - Create skill files
+    cmd
+        .command("skills")
+        .description("Create skill files for AI agents")
+        .option("-o, --output <path>", "Output directory", ".claude/skills/design-system")
+        .option("--global", "Export to global skills directory (~/.claude/skills/)")
+        .option("--dry-run", "Show what would be created without writing files")
+        .option("--json", "Output result as JSON")
+        .action(async (options) => {
+        await runSkillsDock(options);
+    });
+    // dock context - Generate CLAUDE.md section
+    cmd
+        .command("context")
+        .description("Generate design system context for CLAUDE.md")
+        .option("-o, --output <path>", "Output file path (default: CLAUDE.md)")
+        .option("--stdout", "Output to stdout instead of file")
+        .option("-d, --detail <level>", "Detail level: minimal, standard, comprehensive", "standard")
+        .option("--json", "Output as JSON with stats")
+        .action(async (options) => {
+        await runContextDock(options);
+    });
+    // dock hooks - Set up git hooks
+    cmd
+        .command("hooks")
+        .description("Set up git hooks for drift checking")
+        .option("--claude", "Also set up Claude Code hooks")
+        .action(async (options) => {
+        await runHooksDock(options);
+    });
+    return cmd;
+}
+/**
+ * Smart dock walkthrough - goes through config → agents → hooks
+ */
+async function runSmartDock(options) {
+    const cwd = process.cwd();
+    if (options.json) {
+        setJsonMode(true);
+    }
+    console.log("");
+    console.log(chalk.cyan.bold("  Docking Buoy..."));
+    console.log(chalk.dim("  ─".repeat(25)));
+    console.log("");
+    const results = {
+        configCreated: false,
+        agentsSetup: false,
+        hooksSetup: false,
     };
-    // File extensions by framework
-    const getExtensions = (sourceKey, typescript) => {
-        switch (sourceKey) {
-            case "vue":
-                return ["vue"];
-            case "svelte":
-                return ["svelte"];
-            case "angular":
-                return ["component.ts"];
-            case "webcomponent":
-                return ["ts"];
-            default: // react
-                return typescript ? ["tsx", "jsx"] : ["jsx", "tsx"];
+    // Step 1: Check/create config
+    const configPath = getConfigPath();
+    if (!configPath) {
+        console.log(chalk.yellow("  ⚠ No buoy.config.mjs found"));
+        console.log("");
+        const shouldCreateConfig = options.yes || await promptConfirm("  Create config now?", true);
+        if (shouldCreateConfig) {
+            console.log("");
+            await runConfigDock({ yes: options.yes });
+            results.configCreated = true;
         }
-    };
-    // JS Framework config (React, Vue, Svelte, Angular, Web Components)
-    // Handle multiple frameworks - generate config for each UI framework
-    const addedSourceKeys = new Set();
-    for (const framework of project.frameworks) {
-        const sourceKey = getSourceKey(framework.name);
-        if (sourceKey && !addedSourceKeys.has(sourceKey)) {
-            addedSourceKeys.add(sourceKey);
-            const extensions = getExtensions(sourceKey, framework.typescript);
-            const jsComponents = project.components.filter((c) => c.type === "jsx" ||
-                c.type === "vue" ||
-                c.type === "svelte" ||
-                !c.type);
-            let includePatterns;
-            if (jsComponents.length > 0) {
-                includePatterns = jsComponents.flatMap((c) => extensions.map((ext) => `${c.path}/**/*.${ext}`));
-            }
-            else {
-                // Use default patterns, but expand for monorepo if detected
-                const defaultPatterns = extensions.map((ext) => `src/**/*.${ext}`);
-                if (monorepoConfig.type) {
-                    const expanded = expandPatternsForMonorepo(defaultPatterns, monorepoConfig);
-                    includePatterns = expanded.allPatterns;
-                }
-                else {
-                    includePatterns = defaultPatterns;
-                }
-            }
-            lines.push(`    ${sourceKey}: {`);
-            lines.push(`      enabled: true,`);
-            lines.push(`      include: [${includePatterns.map((p) => `'${p}'`).join(", ")}],`);
-            lines.push(`      exclude: ['**/*.test.*', '**/*.spec.*', '**/*.stories.*'],`);
-            if (project.designSystem) {
-                lines.push(`      designSystemPackage: '${project.designSystem.package}',`);
-            }
-            if (sourceKey === "webcomponent") {
-                const wcFramework = framework.name === "lit" ? "lit" : "stencil";
-                lines.push(`      framework: '${wcFramework}',`);
-            }
-            lines.push(`    },`);
+        else {
+            console.log("");
+            info("Run `buoy dock config` later to create config.");
+            console.log("");
+            return;
         }
     }
-    // Server-side / template-based framework config
-    const serverFrameworks = [
-        "php",
-        "laravel",
-        "symfony",
-        "rails",
-        "django",
-        "flask",
-        "fastapi",
-        "express",
-        "nestjs",
-        "spring",
-        "aspnet",
-        "go",
-        "hugo",
-        "jekyll",
-        "eleventy",
-    ];
-    // Map framework to template type
-    const getTemplateType = (frameworkName, componentType) => {
-        // Return component type directly if it's a known template type
-        const knownTypes = [
-            // Server-side templates
-            "blade", "erb", "twig", "njk", "razor", "hbs", "mustache",
-            "ejs", "pug", "liquid", "slim", "haml", "jinja", "django",
-            "thymeleaf", "freemarker", "go-template", "edge", "eta", "heex",
-            "velocity", "xslt",
-            // JS frameworks
-            "astro", "solid", "qwik", "marko", "lit", "fast", "angular",
-            "stencil", "alpine", "htmx",
-            // Static site generators
-            "hugo", "jekyll", "eleventy", "shopify",
-            // Documentation
-            "markdown", "mdx", "asciidoc",
-            // Graphics
-            "svg",
-            // Data templates
-            "yaml-template", "json-template"
-        ];
-        if (componentType && knownTypes.includes(componentType)) {
-            return componentType;
-        }
-        // Framework-based defaults
-        if (frameworkName === "laravel")
-            return "blade";
-        if (frameworkName === "rails")
-            return "erb";
-        if (frameworkName === "symfony")
-            return "twig";
-        if (frameworkName === "eleventy")
-            return "eleventy";
-        if (frameworkName === "aspnet")
-            return "razor";
-        if (frameworkName === "express")
-            return "ejs";
-        if (frameworkName === "flask")
-            return "jinja";
-        if (frameworkName === "django")
-            return "django";
-        if (frameworkName === "spring")
-            return "thymeleaf";
-        if (frameworkName === "go")
-            return "go-template";
-        if (frameworkName === "astro")
-            return "astro";
-        if (frameworkName === "hugo")
-            return "hugo";
-        if (frameworkName === "jekyll")
-            return "jekyll";
-        return "html";
-    };
-    // Check if any framework is a server-side framework
-    const serverFramework = project.frameworks.find((f) => serverFrameworks.includes(f.name));
-    if (serverFramework) {
-        const templateTypes = [
-            // Server-side templates
-            "php", "blade", "erb", "twig", "html", "njk", "razor", "hbs",
-            "mustache", "ejs", "pug", "liquid", "slim", "haml", "jinja",
-            "django", "thymeleaf", "freemarker", "go-template", "edge",
-            "eta", "heex", "velocity", "xslt",
-            // JS frameworks
-            "astro", "solid", "qwik", "marko", "lit", "fast", "angular",
-            "stencil", "alpine", "htmx",
-            // Static site generators
-            "hugo", "jekyll", "eleventy", "shopify",
-            // Documentation
-            "markdown", "mdx", "asciidoc",
-            // Graphics
-            "svg",
-            // Data templates
-            "yaml-template", "json-template"
-        ];
-        const templateComponents = project.components.filter((c) => c.type && templateTypes.includes(c.type));
-        if (templateComponents.length > 0) {
-            // Use the first component's type to determine template type
-            const templateType = getTemplateType(serverFramework.name, templateComponents[0]?.type);
-            lines.push(`    templates: {`);
-            lines.push(`      enabled: true,`);
-            lines.push(`      type: '${templateType}',`);
-            lines.push(`      include: [`);
-            for (const comp of templateComponents) {
-                lines.push(`        '${comp.pattern}',`);
-            }
-            lines.push(`      ],`);
-            lines.push(`    },`);
+    else {
+        results.configCreated = true;
+        console.log(`  ${chalk.green("✓")} Config exists`);
+    }
+    // Step 2: Check/setup AI agents
+    const skillsDir = resolve(cwd, ".claude/skills/design-system");
+    const claudeMdPath = join(cwd, "CLAUDE.md");
+    const hasSkills = existsSync(skillsDir);
+    const hasClaudeMd = existsSync(claudeMdPath) && readFileSync(claudeMdPath, "utf-8").includes("Design System");
+    if (!hasSkills || !hasClaudeMd) {
+        console.log("");
+        console.log(chalk.yellow("  ⚠ AI agents not configured"));
+        if (!hasSkills)
+            console.log(chalk.dim("    • Missing skill files"));
+        if (!hasClaudeMd)
+            console.log(chalk.dim("    • Missing CLAUDE.md section"));
+        console.log("");
+        const shouldSetupAgents = options.yes || await promptConfirm("  Set up AI agents?", true);
+        if (shouldSetupAgents) {
+            console.log("");
+            await runAgentsDock({ json: options.json });
+            results.agentsSetup = true;
         }
     }
-    // Storybook config
-    if (project.storybook) {
-        lines.push(`    storybook: {`);
-        lines.push(`      enabled: true,`);
-        lines.push(`    },`);
-    }
-    // Token files config
-    const tokenFiles = project.tokens.filter((t) => t.type !== "tailwind");
-    const hasTailwind = project.tokens.some((t) => t.type === "tailwind");
-    if (tokenFiles.length > 0 || hasTailwind) {
-        lines.push(`    tokens: {`);
-        lines.push(`      enabled: true,`);
-        if (tokenFiles.length > 0) {
-            lines.push(`      files: [`);
-            for (const token of tokenFiles) {
-                lines.push(`        '${token.path}',`);
-            }
-            lines.push(`      ],`);
+    else {
+        console.log(`  ${chalk.green("✓")} AI agents configured`);
+        results.agentsSetup = true;
+    }
+    // Step 3: Check/setup hooks
+    const hasHooks = existsSync(join(cwd, ".husky/pre-commit")) ||
+        existsSync(join(cwd, "lefthook.yml")) ||
+        existsSync(join(cwd, ".git/hooks/pre-commit"));
+    if (!hasHooks) {
+        console.log("");
+        console.log(chalk.yellow("  ⚠ No pre-commit hooks"));
+        console.log("");
+        const shouldSetupHooks = options.yes || await promptConfirm("  Set up hooks?", true);
+        if (shouldSetupHooks) {
+            await runHooksDock({});
+            results.hooksSetup = true;
         }
-        lines.push(`    },`);
     }
-    // Figma placeholder (always disabled by default)
-    lines.push(`    figma: {`);
-    lines.push(`      enabled: false,`);
-    lines.push(`      // accessToken: process.env.FIGMA_ACCESS_TOKEN,`);
-    lines.push(`      // fileKeys: [],`);
-    lines.push(`    },`);
-    lines.push(`  },`);
-    lines.push(`  output: {`);
-    lines.push(`    format: 'table',`);
-    lines.push(`    colors: true,`);
-    lines.push(`  },`);
-    lines.push(`};`);
-    lines.push(``);
-    return lines.join("\n");
-}
-function printDetectionResults(project) {
-    console.log("");
-    console.log(chalk.bold("  Detected:"));
-    const frameworkNames = {
-        // JS frameworks
-        react: "React",
-        vue: "Vue",
-        svelte: "Svelte",
-        angular: "Angular",
-        solid: "Solid",
-        preact: "Preact",
-        // Meta-frameworks
-        nextjs: "Next.js",
-        nuxt: "Nuxt",
-        astro: "Astro",
-        remix: "Remix",
-        sveltekit: "SvelteKit",
-        gatsby: "Gatsby",
-        // Mobile
-        "react-native": "React Native",
-        flutter: "Flutter",
-        expo: "Expo",
-        // Web Components
-        lit: "Lit",
-        stencil: "Stencil",
-        // Server-side
-        php: "PHP",
-        laravel: "Laravel",
-        symfony: "Symfony",
-        rails: "Ruby on Rails",
-        django: "Django",
-        flask: "Flask",
-        fastapi: "FastAPI",
-        express: "Express",
-        nestjs: "NestJS",
-        spring: "Spring Boot",
-        aspnet: "ASP.NET",
-        go: "Go",
-        // Static site generators
-        hugo: "Hugo",
-        jekyll: "Jekyll",
-        eleventy: "Eleventy",
-    };
-    // Frameworks - show all detected
-    if (project.frameworks.length > 0) {
-        // Show warning if multiple UI frameworks detected (framework sprawl)
-        const uiFrameworks = [
-            "react",
-            "vue",
-            "svelte",
-            "angular",
-            "solid",
-            "preact",
-            "lit",
-            "stencil",
-            "nextjs",
-            "nuxt",
-            "astro",
-            "remix",
-            "sveltekit",
-            "gatsby",
-            "react-native",
-            "expo",
-            "flutter",
-        ];
-        const uiCount = project.frameworks.filter((f) => uiFrameworks.includes(f.name)).length;
-        if (uiCount > 1) {
-            console.log(chalk.yellow("    ⚠ ") +
-                chalk.yellow.bold("Multiple UI frameworks detected (framework sprawl)"));
-        }
-        for (const framework of project.frameworks) {
-            const ts = framework.typescript ? " + TypeScript" : "";
-            const frameworkName = frameworkNames[framework.name] || capitalize(framework.name);
-            const meta = framework.meta ? chalk.dim(` (${framework.meta})`) : "";
-            const version = framework.version !== "unknown" ? ` ${framework.version}` : "";
-            console.log(chalk.green("    ✓ ") +
-                chalk.bold(frameworkName) +
-                ts +
-                meta +
-                chalk.dim(version));
-        }
-    }
-    // Components
-    if (project.components.length > 0) {
-        for (const comp of project.components) {
-            const typeLabels = {
-                // JS frameworks
-                jsx: "component files",
-                tsx: "TypeScript components",
-                vue: "Vue components",
-                svelte: "Svelte components",
-                astro: "Astro components",
-                solid: "Solid components",
-                qwik: "Qwik components",
-                marko: "Marko components",
-                lit: "Lit elements",
-                fast: "FAST elements",
-                // Server-side templates
-                php: "PHP templates",
-                blade: "Blade templates",
-                erb: "ERB templates",
-                twig: "Twig templates",
-                html: "HTML templates",
-                njk: "Nunjucks templates",
-                razor: "Razor views",
-                hbs: "Handlebars templates",
-                mustache: "Mustache templates",
-                ejs: "EJS templates",
-                pug: "Pug templates",
-                liquid: "Liquid templates",
-                slim: "Slim templates",
-                haml: "Haml templates",
-                jinja: "Jinja templates",
-                django: "Django templates",
-                thymeleaf: "Thymeleaf templates",
-                freemarker: "Freemarker templates",
-                velocity: "Velocity templates",
-                "go-template": "Go templates",
-                edge: "Edge.js templates",
-                eta: "Eta templates",
-                heex: "HEEx templates",
-                xslt: "XSLT stylesheets",
-                // Static site generators
-                hugo: "Hugo layouts",
-                jekyll: "Jekyll layouts",
-                eleventy: "Eleventy templates",
-                shopify: "Shopify templates",
-                // Documentation
-                markdown: "Markdown files",
-                mdx: "MDX files",
-                asciidoc: "AsciiDoc files",
-                // Data templates
-                "yaml-template": "YAML templates",
-                "json-template": "JSON templates",
-                // Additional JS frameworks
-                angular: "Angular components",
-                stencil: "Stencil components",
-                alpine: "Alpine.js templates",
-                htmx: "HTMX templates",
-                // Graphics
-                svg: "SVG components",
-            };
-            const typeLabel = comp.type
-                ? typeLabels[comp.type] || "template files"
-                : "component files";
-            console.log(chalk.green("    ✓ ") +
-                `${comp.fileCount} ${typeLabel} in ` +
-                chalk.cyan(comp.path));
-        }
-    }
-    // Tokens
-    if (project.tokens.length > 0) {
-        for (const token of project.tokens) {
-            console.log(chalk.green("    ✓ ") + `${token.name}: ` + chalk.cyan(token.path));
-        }
-    }
-    // Storybook
-    if (project.storybook) {
-        const version = project.storybook.version
-            ? ` (${project.storybook.version})`
-            : "";
-        console.log(chalk.green("    ✓ ") + `Storybook` + chalk.dim(version));
-    }
-    // Design system
-    if (project.designSystem) {
-        console.log(chalk.green("    ✓ ") +
-            `Design system: ` +
-            chalk.cyan(project.designSystem.package));
-    }
-    // Monorepo
-    if (project.monorepo) {
-        // Show basic monorepo info
-        console.log(chalk.green("    ✓ ") +
-            capitalize(project.monorepo.type) +
-            ` monorepo (${project.monorepo.packages.length} packages)`);
-        // Show monorepo component paths if detected
-        const monorepoComponents = project.components.filter((c) => c.path.startsWith("packages/") ||
-            c.path.startsWith("apps/") ||
-            c.path.startsWith("libs/") ||
-            c.path.startsWith("modules/"));
-        if (monorepoComponents.length > 0) {
-            console.log(chalk.dim("      ") +
-                chalk.dim(`Scanning: ${monorepoComponents.map((c) => c.path).slice(0, 3).join(", ")}${monorepoComponents.length > 3 ? ` +${monorepoComponents.length - 3} more` : ""}`));
-        }
-    }
-    // Design system documentation tools
-    if (project.designSystemDocs) {
-        const typeNames = {
-            'zeroheight': 'Zeroheight',
-            'supernova': 'Supernova',
-            'specify': 'Specify',
-            'knapsack': 'Knapsack',
-            'framer': 'Framer',
-            'tokenforge': 'TokenForge',
-            'tokens-studio': 'Tokens Studio (Figma Tokens)',
-        };
-        const name = typeNames[project.designSystemDocs.type] || project.designSystemDocs.type;
-        const path = project.designSystemDocs.exportPath || project.designSystemDocs.configPath || '';
-        console.log(chalk.green("    ✓ ") +
-            chalk.bold(name) +
-            (path ? chalk.dim(` (${path})`) : ''));
-    }
-    // Nothing found
-    if (project.frameworks.length === 0 &&
-        project.components.length === 0 &&
-        project.tokens.length === 0 &&
-        !project.storybook &&
-        !project.designSystemDocs) {
-        console.log(chalk.yellow("    ⚠ ") + "No sources auto-detected");
-        console.log(chalk.dim("      You can manually configure sources in buoy.config.mjs"));
+    else {
+        console.log(`  ${chalk.green("✓")} Hooks configured`);
+        results.hooksSetup = true;
     }
+    // Summary
     console.log("");
-}
-function capitalize(s) {
-    return s.charAt(0).toUpperCase() + s.slice(1);
-}
-/**
- * Import tokens from a detected source and generate output file
- */
-async function importTokensFromSource(sourcePath, outputPath) {
-    try {
-        const content = readFileSync(sourcePath, 'utf-8');
-        const ext = extname(sourcePath).toLowerCase();
-        let tokens = [];
-        if (ext === '.json') {
-            const json = JSON.parse(content);
-            const format = detectFormat(json);
-            info(`Detected format: ${formatTokenFormat(format)}`);
-            tokens = parseTokenFile(content);
-        }
-        else if (ext === '.css') {
-            tokens = parseCssVariablesForInit(content, sourcePath);
+    console.log(chalk.dim("  ─".repeat(25)));
+    console.log("");
+    if (options.json) {
+        console.log(JSON.stringify(results, null, 2));
+    }
+    else {
+        const allDone = results.configCreated && results.agentsSetup && results.hooksSetup;
+        if (allDone) {
+            console.log(chalk.green.bold("  ✓ Buoy is docked!"));
+            console.log("");
+            console.log(chalk.dim("  Try:"));
+            console.log(`    ${chalk.cyan("buoy show all")}      # See your design system`);
+            console.log(`    ${chalk.cyan("buoy show drift")}    # Check for drift`);
         }
         else {
-            return { success: false, tokenCount: 0 };
-        }
-        if (tokens.length === 0) {
-            return { success: false, tokenCount: 0 };
+            console.log(chalk.yellow("  Partially docked"));
+            console.log("");
+            if (!results.configCreated)
+                console.log(`    Run ${chalk.cyan("buoy dock config")}`);
+            if (!results.agentsSetup)
+                console.log(`    Run ${chalk.cyan("buoy dock agents")}`);
+            if (!results.hooksSetup)
+                console.log(`    Run ${chalk.cyan("buoy dock hooks")}`);
         }
-        // Generate CSS output
-        const outputContent = generateCssFromTokens(tokens);
-        writeFileSync(outputPath, outputContent);
-        return { success: true, tokenCount: tokens.length };
-    }
-    catch {
-        return { success: false, tokenCount: 0 };
     }
+    console.log("");
 }
 /**
- * Parse CSS variables for token import
+ * Config dock - creates buoy.config.mjs
  */
-function parseCssVariablesForInit(content, filePath) {
-    const tokens = [];
-    const varRegex = /--([\\w-]+)\\s*:\\s*([^;]+);/g;
-    let match;
-    while ((match = varRegex.exec(content)) !== null) {
-        const name = match[1];
-        const value = match[2].trim();
-        tokens.push({
-            id: `css:${filePath}:${name}`,
-            name: `--${name}`,
-            category: inferTokenCategory(name, value),
-            value: parseTokenValue(value),
-            source: { type: 'css', path: filePath },
-            aliases: [],
-            usedBy: [],
-            metadata: {},
-            scannedAt: new Date(),
-        });
+async function runConfigDock(options) {
+    const cwd = process.cwd();
+    const configFilePath = resolve(cwd, "buoy.config.mjs");
+    if (existsSync(configFilePath) && !options.force) {
+        warning(`Config already exists at ${configFilePath}`);
+        info("Use --force to overwrite");
+        return;
     }
-    return tokens;
-}
-/**
- * Infer token category from name or value
- */
-function inferTokenCategory(name, value) {
-    const nameLower = name.toLowerCase();
-    if (nameLower.includes('color') || value.startsWith('#') || value.startsWith('rgb') || value.startsWith('hsl')) {
-        return 'color';
+    let project;
+    if (options.skipDetect) {
+        const detector = new ProjectDetector(cwd);
+        project = {
+            name: (await detector.detect()).name,
+            root: cwd,
+            frameworks: [],
+            primaryFramework: null,
+            components: [],
+            tokens: [],
+            storybook: null,
+            designSystem: null,
+            monorepo: null,
+            designSystemDocs: null,
+        };
     }
-    if (nameLower.includes('spacing') || nameLower.includes('space') || nameLower.includes('gap')) {
-        return 'spacing';
+    else {
+        const spin = ora("Scanning project...").start();
+        try {
+            const detector = new ProjectDetector(cwd);
+            project = await detector.detect();
+            spin.stop();
+            printDetectionResults(project);
+        }
+        catch (err) {
+            spin.fail("Detection failed");
+            error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
     }
-    if (nameLower.includes('font') || nameLower.includes('text') || nameLower.includes('size')) {
-        return 'typography';
+    // Show frameworks and offer plugin install
+    const detectedFrameworks = await detectFrameworks(cwd);
+    if (detectedFrameworks.length > 0) {
+        await showFrameworksAndPlugins(detectedFrameworks, options.yes);
     }
-    if (nameLower.includes('radius') || nameLower.includes('rounded')) {
-        return 'border';
+    // Generate and write config
+    const content = generateConfig(project);
+    try {
+        writeFileSync(configFilePath, content, "utf-8");
+        success("Created buoy.config.mjs");
     }
-    if (nameLower.includes('shadow')) {
-        return 'shadow';
+    catch (err) {
+        error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
     }
-    return 'other';
 }
 /**
- * Parse a CSS value into TokenValue
+ * Agents dock - sets up AI agents (skills + context + commands)
  */
-function parseTokenValue(value) {
-    if (value.startsWith('#') || value.startsWith('rgb') || value.startsWith('hsl')) {
-        return { type: 'color', hex: value.startsWith('#') ? value.toLowerCase() : value };
+async function runAgentsDock(options) {
+    const cwd = process.cwd();
+    if (options.json)
+        setJsonMode(true);
+    const spin = spinner("Setting up AI agents...");
+    try {
+        const { config, projectName } = await loadOrBuildConfig(cwd);
+        spin.text = "Scanning...";
+        const orchestrator = new ScanOrchestrator(config, cwd);
+        const scanResult = await orchestrator.scan({ onProgress: (msg) => { spin.text = msg; } });
+        spin.text = "Analyzing...";
+        const { SemanticDiffEngine } = await import("@buoy-design/core/analysis");
+        const engine = new SemanticDiffEngine();
+        const diffResult = engine.analyzeComponents(scanResult.components, {
+            checkDeprecated: true,
+            checkNaming: true,
+            checkDocumentation: true,
+        });
+        spin.stop();
+        const results = {
+            skillCreated: false,
+            contextUpdated: false,
+            commandsInstalled: [],
+            stats: { tokens: 0, components: 0 },
+        };
+        // Create skill files
+        const skillPath = resolve(cwd, ".claude/skills/design-system");
+        if (options.dryRun) {
+            console.log(chalk.dim("  Would create: " + skillPath));
+        }
+        else {
+            const exportService = new SkillExportService(projectName);
+            const skillResult = await exportService.export({ tokens: scanResult.tokens, components: scanResult.components, drifts: diffResult.drifts, projectName }, { sections: ["tokens", "components", "patterns", "anti-patterns"], outputPath: skillPath });
+            for (const file of skillResult.files) {
+                const dir = dirname(file.path);
+                if (!existsSync(dir))
+                    mkdirSync(dir, { recursive: true });
+                writeFileSync(file.path, file.content);
+            }
+            results.skillCreated = true;
+            results.stats.tokens = skillResult.stats.tokens.total;
+            results.stats.components = skillResult.stats.components;
+        }
+        // Update CLAUDE.md
+        const claudeMdPath = join(cwd, "CLAUDE.md");
+        if (options.dryRun) {
+            console.log(chalk.dim("  Would update: CLAUDE.md"));
+        }
+        else {
+            const contextResult = generateContext({ tokens: scanResult.tokens, components: scanResult.components, drifts: diffResult.drifts, projectName }, { detailLevel: "standard" });
+            let existingContent = "";
+            let hasSection = false;
+            if (existsSync(claudeMdPath)) {
+                existingContent = readFileSync(claudeMdPath, "utf-8");
+                hasSection = /^##?\s*[Dd]esign\s*[Ss]ystem/m.test(existingContent.replace(/```[\s\S]*?```/g, ""));
+            }
+            if (!hasSection) {
+                const section = `\n## Design System\n\n${contextResult.content}\n`;
+                if (existingContent) {
+                    appendFileSync(claudeMdPath, section);
+                }
+                else {
+                    writeFileSync(claudeMdPath, `# CLAUDE.md\n${section}`);
+                }
+                results.contextUpdated = true;
+            }
+        }
+        // Install commands
+        if (!options.dryRun) {
+            const { installed } = installClaudeCommands(false);
+            results.commandsInstalled = installed;
+        }
+        if (options.json) {
+            console.log(JSON.stringify(results, null, 2));
+        }
+        else if (!options.dryRun) {
+            console.log("");
+            if (results.skillCreated)
+                console.log(`  ${chalk.green("✓")} Created skill files`);
+            if (results.contextUpdated)
+                console.log(`  ${chalk.green("✓")} Updated CLAUDE.md`);
+            if (results.commandsInstalled.length > 0) {
+                console.log(`  ${chalk.green("✓")} Installed: ${results.commandsInstalled.map(c => `/${c}`).join(", ")}`);
+            }
+            console.log("");
+        }
     }
-    const dimMatch = value.match(/^([\d.]+)(px|rem|em|%)$/);
-    if (dimMatch) {
-        return { type: 'spacing', value: parseFloat(dimMatch[1]), unit: dimMatch[2] };
+    catch (err) {
+        spin.stop();
+        error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
     }
-    return { type: 'raw', value };
 }
 /**
- * Generate CSS file from tokens
+ * Skills dock - creates skill files only
  */
-function generateCssFromTokens(tokens) {
-    const lines = [
-        '/**',
-        ' * Design Tokens',
-        ' * Imported by Buoy',
-        ' */',
-        '',
-        ':root {',
-    ];
-    // Group by category
-    const groups = {};
-    for (const token of tokens) {
-        const cat = token.category;
-        if (!groups[cat])
-            groups[cat] = [];
-        groups[cat].push(token);
-    }
-    for (const [category, catTokens] of Object.entries(groups)) {
-        lines.push(`  /* ${capitalize(category)} */`);
-        for (const token of catTokens) {
-            const name = token.name.startsWith('--') ? token.name : `--${token.name}`;
-            const value = getTokenDisplayValue(token);
-            lines.push(`  ${name}: ${value};`);
-        }
-        lines.push('');
-    }
-    lines.push('}');
-    return lines.join('\\n');
-}
-/**
- * Get display value for a token
- */
-function getTokenDisplayValue(token) {
-    const v = token.value;
-    if (v.type === 'color')
-        return v.hex;
-    if (v.type === 'spacing')
-        return `${v.value}${v.unit}`;
-    if (v.type === 'raw')
-        return v.value;
-    return JSON.stringify(v);
+async function runSkillsDock(options) {
+    const cwd = process.cwd();
+    if (options.json)
+        setJsonMode(true);
+    const spin = spinner("Creating skills...");
+    try {
+        const { config, projectName } = await loadOrBuildConfig(cwd);
+        spin.text = "Scanning...";
+        const orchestrator = new ScanOrchestrator(config, cwd);
+        const scanResult = await orchestrator.scan({ onProgress: (msg) => { spin.text = msg; } });
+        spin.text = "Analyzing...";
+        const { SemanticDiffEngine } = await import("@buoy-design/core/analysis");
+        const engine = new SemanticDiffEngine();
+        const diffResult = engine.analyzeComponents(scanResult.components, {});
+        spin.stop();
+        let outputPath = options.output || ".claude/skills/design-system";
+        if (options.global)
+            outputPath = join(homedir(), ".claude", "skills", projectName);
+        outputPath = resolve(cwd, outputPath);
+        if (options.dryRun) {
+            console.log(chalk.dim(`Would create: ${outputPath}`));
+            return;
+        }
+        const exportService = new SkillExportService(projectName);
+        const result = await exportService.export({ tokens: scanResult.tokens, components: scanResult.components, drifts: diffResult.drifts, projectName }, { sections: ["tokens", "components", "patterns", "anti-patterns"], outputPath });
+        for (const file of result.files) {
+            const dir = dirname(file.path);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(file.path, file.content);
+        }
+        if (options.json) {
+            console.log(JSON.stringify({ path: outputPath, stats: result.stats }, null, 2));
+        }
+        else {
+            success(`Created skills at ${outputPath}`);
+        }
+    }
+    catch (err) {
+        spin.stop();
+        error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
 }
 /**
- * Format token format name for display
+ * Context dock - generates CLAUDE.md section
  */
-function formatTokenFormat(format) {
-    const names = {
-        dtcg: 'W3C Design Tokens (DTCG)',
-        'tokens-studio': 'Tokens Studio (Figma Tokens)',
-        'style-dictionary': 'Style Dictionary',
-    };
-    return names[format] || format;
-}
-async function promptConfirm(message, defaultValue = true) {
-    const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const suffix = defaultValue ? "[Y/n]" : "[y/N]";
-    return new Promise((resolve) => {
-        rl.question(`${message} ${suffix} `, (answer) => {
-            rl.close();
-            const trimmed = answer.trim().toLowerCase();
-            if (trimmed === "") {
-                resolve(defaultValue);
+async function runContextDock(options) {
+    const cwd = process.cwd();
+    if (options.json)
+        setJsonMode(true);
+    const spin = spinner("Generating context...");
+    try {
+        const { config, projectName } = await loadOrBuildConfig(cwd);
+        spin.text = "Scanning...";
+        const orchestrator = new ScanOrchestrator(config, cwd);
+        const scanResult = await orchestrator.scan();
+        spin.text = "Analyzing...";
+        const { SemanticDiffEngine } = await import("@buoy-design/core/analysis");
+        const engine = new SemanticDiffEngine();
+        const diffResult = engine.analyzeComponents(scanResult.components, { availableTokens: scanResult.tokens });
+        spin.stop();
+        const contextResult = generateContext({ tokens: scanResult.tokens, components: scanResult.components, drifts: diffResult.drifts, projectName }, { detailLevel: options.detail || "standard" });
+        if (options.json) {
+            console.log(JSON.stringify({ content: contextResult.content, stats: contextResult.stats }, null, 2));
+            return;
+        }
+        if (options.stdout) {
+            console.log(contextResult.content);
+            return;
+        }
+        const claudeMdPath = options.output || join(cwd, "CLAUDE.md");
+        const header = "## Design System\n\n";
+        if (existsSync(claudeMdPath)) {
+            const existing = readFileSync(claudeMdPath, "utf-8");
+            if (!existing.includes("## Design System")) {
+                appendFileSync(claudeMdPath, `\n${header}${contextResult.content}\n`);
+                success("Appended to CLAUDE.md");
             }
             else {
-                resolve(trimmed === "y" || trimmed === "yes");
+                warning("CLAUDE.md already has Design System section");
             }
-        });
-    });
+        }
+        else {
+            writeFileSync(claudeMdPath, `# CLAUDE.md\n\n${header}${contextResult.content}\n`);
+            success("Created CLAUDE.md");
+        }
+    }
+    catch (err) {
+        spin.stop();
+        error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
 }
-export function createDockCommand() {
-    const cmd = new Command("dock")
-        .description("Dock Buoy into your project")
-        .option("-f, --force", "Overwrite existing configuration")
-        .option("-n, --name <name>", "Project name")
-        .option("--skip-detect", "Skip auto-detection and create minimal config")
-        .option("-y, --yes", "Auto-install recommended plugins without prompting")
-        .option("--no-install", "Skip plugin installation prompts")
-        .option("--hooks", "Setup pre-commit hook for drift checking")
-        .action(async (options) => {
-        const cwd = process.cwd();
-        const configPath = resolve(cwd, "buoy.config.mjs");
-        // Check if config already exists
-        if (existsSync(configPath) && !options.force) {
-            warning(`Configuration already exists at ${configPath}`);
-            info("Use --force to overwrite");
-            return;
+/**
+ * Hooks dock - sets up git hooks
+ */
+async function runHooksDock(options) {
+    const cwd = process.cwd();
+    console.log("");
+    const hookSystem = detectHookSystem(cwd);
+    if (hookSystem) {
+        info(`Detected: ${hookSystem}`);
+        const hookResult = setupHooks(cwd);
+        if (hookResult.success) {
+            success(hookResult.message);
         }
-        let project;
-        if (options.skipDetect) {
-            // Minimal detection - just get the project name
-            const detector = new ProjectDetector(cwd);
-            project = {
-                name: options.name || (await detector.detect()).name,
-                root: cwd,
-                frameworks: [],
-                primaryFramework: null,
-                components: [],
-                tokens: [],
-                storybook: null,
-                designSystem: null,
-                monorepo: null,
-                designSystemDocs: null,
-            };
+        else {
+            warning(hookResult.message);
+        }
+    }
+    else {
+        const standaloneResult = generateStandaloneHook(cwd);
+        if (standaloneResult.success) {
+            success(standaloneResult.message);
+            info("Copy to .git/hooks/pre-commit to activate");
         }
         else {
-            // Run auto-detection
-            const spinner = ora("Scanning project...").start();
-            try {
-                const detector = new ProjectDetector(cwd);
-                project = await detector.detect();
-                if (options.name) {
-                    project.name = options.name;
-                }
-                spinner.stop();
-                printDetectionResults(project);
-            }
-            catch (err) {
-                spinner.fail("Detection failed");
-                const message = err instanceof Error ? err.message : String(err);
-                error(message);
-                process.exit(1);
-            }
+            warning(standaloneResult.message);
         }
-        // Track imported token file path for config generation
-        let importedTokenFile = null;
-        // Check if design system docs were detected and offer to import tokens
-        if (project.designSystemDocs && !options.skipDetect) {
-            const docType = project.designSystemDocs.type;
-            const sourcePath = project.designSystemDocs.exportPath || project.designSystemDocs.configPath;
-            const typeNames = {
-                'zeroheight': 'Zeroheight',
-                'supernova': 'Supernova',
-                'specify': 'Specify',
-                'knapsack': 'Knapsack',
-                'framer': 'Framer',
-                'tokenforge': 'TokenForge',
-                'tokens-studio': 'Tokens Studio',
-            };
-            const docName = typeNames[docType] || docType;
-            if (sourcePath && existsSync(resolve(cwd, sourcePath))) {
-                console.log(chalk.bold("  Token Import"));
-                console.log("");
-                console.log(`  Found ${chalk.cyan(docName)} tokens at ${chalk.dim(sourcePath)}`);
-                console.log("");
-                let shouldImport = false;
-                if (options.yes) {
-                    shouldImport = true;
-                }
-                else if (process.stdin.isTTY) {
-                    shouldImport = await promptConfirm(`  Import tokens from ${docName}?`, true);
-                }
-                if (shouldImport) {
-                    const outputFile = 'design-tokens.css';
-                    const importSpinner = ora(`Importing tokens from ${docName}...`).start();
-                    const result = await importTokensFromSource(resolve(cwd, sourcePath), resolve(cwd, outputFile));
-                    if (result.success) {
-                        importSpinner.succeed(`Imported ${result.tokenCount} tokens to ${outputFile}`);
-                        importedTokenFile = outputFile;
-                        // Add to project tokens for config generation
-                        project.tokens.push({
-                            name: 'Design Tokens',
-                            path: outputFile,
-                            type: 'css',
-                        });
-                    }
-                    else {
-                        importSpinner.warn('Could not parse tokens from source');
-                        info(`You can manually import later with: ${chalk.cyan(`buoy import ${sourcePath}`)}`);
-                    }
-                    console.log("");
-                }
-            }
+    }
+    if (options.claude) {
+        console.log("");
+        const { config, projectName } = await loadOrBuildConfig(cwd);
+        const orchestrator = new ScanOrchestrator(config, cwd);
+        const scanResult = await orchestrator.scan();
+        const { SemanticDiffEngine } = await import("@buoy-design/core/analysis");
+        const engine = new SemanticDiffEngine();
+        const diffResult = engine.analyzeComponents(scanResult.components, {});
+        const exportService = new SkillExportService(projectName);
+        const condensedContext = exportService.generateCondensedContext({
+            tokens: scanResult.tokens,
+            components: scanResult.components,
+            drifts: diffResult.drifts,
+            projectName,
+        });
+        const claudeDir = resolve(cwd, ".claude");
+        if (!existsSync(claudeDir))
+            mkdirSync(claudeDir, { recursive: true });
+        writeFileSync(resolve(claudeDir, "buoy-context.md"), condensedContext);
+        const claudeResult = setupClaudeHooks(cwd);
+        if (claudeResult.success) {
+            success("Created Claude hooks");
         }
-        // Show detected frameworks and scanners
-        const detectedFrameworks = await detectFrameworks(cwd);
-        if (detectedFrameworks.length > 0) {
-            // Separate built-in scanners from optional plugins
-            const builtIn = detectedFrameworks.filter((fw) => fw.scanner);
-            const optionalPlugins = detectedFrameworks.filter((fw) => fw.plugin && !fw.scanner);
-            // Show built-in scanners (no install needed)
-            if (builtIn.length > 0) {
-                console.log(chalk.bold("  Built-in Scanners") +
-                    chalk.dim(" (no install needed)"));
-                console.log("");
-                for (const fw of builtIn) {
-                    const scannerInfo = BUILTIN_SCANNERS[fw.scanner];
-                    const scannerLabel = scannerInfo?.description || capitalize(fw.name);
-                    console.log(`  ${chalk.green("✓")} ${chalk.cyan.bold(scannerLabel)}`);
-                    console.log(`    ${chalk.dim(fw.evidence)}`);
-                    console.log("");
-                }
-            }
-            // Show optional plugins (need install)
-            if (optionalPlugins.length > 0) {
-                console.log(chalk.bold("  Optional Plugins"));
-                console.log("");
-                for (const fw of optionalPlugins) {
-                    const pluginInfo = PLUGIN_INFO[fw.plugin];
-                    const pluginName = pluginInfo?.name || `@buoy-design/plugin-${fw.plugin}`;
-                    console.log(`  ${chalk.dim("┌")} ${chalk.cyan.bold(pluginName)}`);
-                    console.log(`  ${chalk.dim("│")}`);
-                    // What was detected
-                    const detectsLabel = pluginInfo?.detects || capitalize(fw.name);
-                    console.log(`  ${chalk.dim("│")}  ${chalk.white("Detected:")} ${detectsLabel} ${chalk.dim(`(${fw.evidence.toLowerCase()})`)}`);
-                    console.log(`  ${chalk.dim("│")}`);
-                    // What the plugin does
-                    if (pluginInfo?.description) {
-                        console.log(`  ${chalk.dim("│")}  ${chalk.dim(pluginInfo.description)}`);
-                    }
-                    console.log(`  ${chalk.dim("└─")} ${chalk.dim(getPluginInstallCommand([fw.plugin]))}`);
-                    console.log("");
-                }
-                const missingPlugins = optionalPlugins
-                    .map((fw) => fw.plugin)
-                    .filter((plugin, index, self) => self.indexOf(plugin) === index);
-                if (missingPlugins.length > 0) {
-                    console.log(chalk.dim("  " + "─".repeat(65)));
-                    console.log("");
-                    console.log(chalk.bold("  Install all optional plugins:"));
-                    console.log(`    ${chalk.cyan(getPluginInstallCommand(missingPlugins))}`);
-                    console.log("");
-                    // Determine if we should install plugins
-                    let shouldInstall = false;
-                    if (options.yes) {
-                        shouldInstall = true;
-                    }
-                    else if (options.install !== false) {
-                        // Only prompt if --no-install was not passed and stdin is a TTY
-                        if (process.stdin.isTTY) {
-                            shouldInstall = await promptConfirm("Install optional plugins now?", true);
-                        }
-                    }
-                    if (shouldInstall) {
-                        const { execSync } = await import("node:child_process");
-                        console.log("");
-                        console.log("Installing plugins...");
-                        try {
-                            execSync(getPluginInstallCommand(missingPlugins), {
-                                stdio: "inherit",
-                            });
-                            success("Plugins installed successfully");
-                        }
-                        catch {
-                            warning("Plugin installation failed. You can install manually with the command above.");
-                        }
-                    }
-                }
-            }
-            console.log("");
+        else {
+            warning(`Claude hooks failed: ${claudeResult.message}`);
         }
-        // Generate and write config
-        const content = generateConfig(project);
-        try {
-            writeFileSync(configPath, content, "utf-8");
-            success(`Created buoy.config.mjs`);
-            // Setup hooks if --hooks flag is provided
-            if (options.hooks) {
-                console.log("");
-                const hookSystem = detectHookSystem(cwd);
-                if (hookSystem) {
-                    info(`Detected hook system: ${hookSystem}`);
-                    const hookResult = setupHooks(cwd);
-                    if (hookResult.success) {
-                        success(hookResult.message);
-                    }
-                    else {
-                        warning(hookResult.message);
-                    }
-                }
-                else {
-                    // No hook system detected, create standalone hook
-                    const standaloneResult = generateStandaloneHook(cwd);
-                    if (standaloneResult.success) {
-                        success(standaloneResult.message);
-                        info("To use this hook, copy it to .git/hooks/pre-commit or configure your hook system");
-                    }
-                    else {
-                        warning(standaloneResult.message);
-                    }
-                }
-            }
-            console.log("");
-            info("Next steps:");
-            let stepNum = 1;
-            if (importedTokenFile) {
-                info(`  ${stepNum}. Review imported tokens in ${chalk.cyan(importedTokenFile)}`);
-                stepNum++;
-            }
-            info(`  ${stepNum}. Run ${chalk.cyan("buoy sweep")} to scan your codebase`);
-            stepNum++;
-            info(`  ${stepNum}. Run ${chalk.cyan("buoy drift check")} to detect drift`);
-            stepNum++;
-            if (!options.hooks) {
-                info(`  ${stepNum}. Run ` +
-                    chalk.cyan("buoy dock --hooks") +
-                    " to setup pre-commit hooks");
-                stepNum++;
+    }
+    console.log("");
+}
+// ============ Helpers ============
+async function loadOrBuildConfig(cwd) {
+    const existingConfigPath = getConfigPath();
+    if (existingConfigPath) {
+        const result = await loadConfig();
+        return { config: result.config, projectName: result.config.project?.name || "design-system" };
+    }
+    const autoResult = await buildAutoConfig(cwd);
+    return { config: autoResult.config, projectName: autoResult.config.project?.name || "design-system" };
+}
+function installClaudeCommands(dryRun = false) {
+    const commandsDir = join(homedir(), ".claude", "commands");
+    const assetsDir = resolve(__dirname, "..", "..", "assets", "commands");
+    const installed = [];
+    const alreadyExisted = [];
+    if (!existsSync(assetsDir))
+        return { installed, alreadyExisted };
+    if (!dryRun && !existsSync(commandsDir))
+        mkdirSync(commandsDir, { recursive: true });
+    for (const file of readdirSync(assetsDir).filter(f => f.endsWith(".md"))) {
+        const destPath = join(commandsDir, file);
+        if (existsSync(destPath)) {
+            alreadyExisted.push(file.replace(".md", ""));
+        }
+        else {
+            if (!dryRun)
+                copyFileSync(join(assetsDir, file), destPath);
+            installed.push(file.replace(".md", ""));
+        }
+    }
+    return { installed, alreadyExisted };
+}
+function generateConfig(project) {
+    const lines = [];
+    const monorepoConfig = detectMonorepoConfig(project.root);
+    lines.push(`/** @type {import('@buoy-design/cli').BuoyConfig} */`);
+    lines.push(`export default {`);
+    lines.push(`  project: { name: '${project.name}' },`);
+    lines.push(`  sources: {`);
+    for (const framework of project.frameworks) {
+        const sourceKey = getSourceKey(framework.name);
+        if (sourceKey) {
+            const extensions = getExtensions(sourceKey, framework.typescript);
+            const defaultPatterns = extensions.map(ext => `src/**/*.${ext}`);
+            const patterns = monorepoConfig.type
+                ? expandPatternsForMonorepo(defaultPatterns, monorepoConfig).allPatterns
+                : defaultPatterns;
+            lines.push(`    ${sourceKey}: {`);
+            lines.push(`      enabled: true,`);
+            lines.push(`      include: [${patterns.map(p => `'${p}'`).join(", ")}],`);
+            lines.push(`      exclude: ['**/*.test.*', '**/*.spec.*', '**/*.stories.*'],`);
+            lines.push(`    },`);
+        }
+    }
+    if (project.tokens.length > 0) {
+        lines.push(`    tokens: { enabled: true, files: [${project.tokens.map(t => `'${t.path}'`).join(", ")}] },`);
+    }
+    lines.push(`    figma: { enabled: false },`);
+    lines.push(`  },`);
+    lines.push(`  output: { format: 'table', colors: true },`);
+    lines.push(`};`);
+    return lines.join("\n");
+}
+function getSourceKey(name) {
+    if (["react", "nextjs", "remix", "gatsby", "react-native", "expo", "preact", "solid"].includes(name))
+        return "react";
+    if (["vue", "nuxt"].includes(name))
+        return "vue";
+    if (["svelte", "sveltekit"].includes(name))
+        return "svelte";
+    if (name === "angular")
+        return "angular";
+    if (["lit", "stencil"].includes(name))
+        return "webcomponent";
+    return null;
+}
+function getExtensions(sourceKey, typescript) {
+    switch (sourceKey) {
+        case "vue": return ["vue"];
+        case "svelte": return ["svelte"];
+        case "angular": return ["component.ts"];
+        case "webcomponent": return ["ts"];
+        default: return typescript ? ["tsx", "jsx"] : ["jsx", "tsx"];
+    }
+}
+function printDetectionResults(project) {
+    console.log("");
+    console.log(chalk.bold("  Detected:"));
+    for (const fw of project.frameworks) {
+        console.log(chalk.green("    ✓ ") + chalk.bold(fw.name) + (fw.typescript ? " + TS" : ""));
+    }
+    for (const comp of project.components) {
+        console.log(chalk.green("    ✓ ") + `${comp.fileCount} files in ${chalk.cyan(comp.path)}`);
+    }
+    for (const token of project.tokens) {
+        console.log(chalk.green("    ✓ ") + `${token.name}: ${chalk.cyan(token.path)}`);
+    }
+    if (project.storybook)
+        console.log(chalk.green("    ✓ ") + "Storybook");
+    console.log("");
+}
+async function showFrameworksAndPlugins(frameworks, autoInstall) {
+    const builtIn = frameworks.filter(fw => fw.scanner);
+    const plugins = frameworks.filter(fw => fw.plugin && !fw.scanner);
+    if (builtIn.length > 0) {
+        console.log(chalk.bold("  Built-in Scanners"));
+        for (const fw of builtIn)
+            console.log(`  ${chalk.green("✓")} ${chalk.cyan(fw.name)}`);
+        console.log("");
+    }
+    if (plugins.length > 0) {
+        const missing = plugins.map(fw => fw.plugin).filter((p, i, arr) => arr.indexOf(p) === i);
+        console.log(chalk.bold("  Optional Plugins"));
+        console.log(`    ${chalk.dim(getPluginInstallCommand(missing))}`);
+        console.log("");
+        if (autoInstall) {
+            const { execSync } = await import("node:child_process");
+            try {
+                execSync(getPluginInstallCommand(missing), { stdio: "inherit" });
+                success("Plugins installed");
             }
-            info(`  ${stepNum}. Run ` +
-                chalk.cyan("buoy onboard") +
-                " to integrate with AI assistants");
-            if (!project.storybook) {
-                console.log("");
-                info(chalk.dim("Optional: Connect Figma by adding your API key to the config"));
+            catch {
+                warning("Plugin install failed");
             }
         }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            error(`Failed to create configuration: ${message}`);
-            process.exit(1);
-        }
+    }
+}
+async function promptConfirm(message, defaultValue = true) {
+    if (!process.stdin.isTTY)
+        return defaultValue;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(`${message} ${defaultValue ? "[Y/n]" : "[y/N]"} `, answer => {
+            rl.close();
+            const t = answer.trim().toLowerCase();
+            resolve(t === "" ? defaultValue : t === "y" || t === "yes");
+        });
     });
-    return cmd;
 }
 //# sourceMappingURL=dock.js.map