@buoy-design/cli 0.3.33 → 0.3.35

package/dist/commands/dock.sync-conflict-20260309-191923-6PCZ3ZU.js

@@ -0,0 +1,1006 @@
+/**
+ * buoy dock - Dock tools into your project
+ *
+ * Smart walkthrough that sets up config, agents, hooks, tokens, and graph.
+ *
+ * Usage:
+ *   buoy dock              # Smart walkthrough: config → agents → hooks
+ *   buoy dock config       # Just create .buoy.yaml
+ *   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
+ *   buoy dock tokens       # Generate/export design tokens
+ *   buoy dock graph        # Build design system knowledge graph
+ */
+import { Command } from "commander";
+import { writeFileSync, existsSync, readFileSync, mkdirSync, appendFileSync, readdirSync, copyFileSync, } from "fs";
+import { resolve, dirname, join } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+import chalk from "chalk";
+import { stringify as stringifyYaml } from "yaml";
+import { createInterface } from "readline";
+import ora from "ora";
+import { success, error, info, warning, setJsonMode, spinner, } from "../output/reporters.js";
+import { loadConfig, getConfigPath } from "../config/loader.js";
+import { buildAutoConfig, findTokenFiles } 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, BUILTIN_SCANNERS, PLUGIN_INFO, } from "../detect/frameworks.js";
+import { createTokensCommand } from "./tokens.js";
+import { createCompareCommand } from "./compare.js";
+import { createImportCommand } from "./import.js";
+import { createGraphCommand } from "./graph.js";
+import { createLearnCommand } from "./learn.js";
+import { showMenu } from "../wizard/menu.js";
+import { generateAgents, generateCommands } from "../templates/agents.js";
+export function createDockCommand() {
+    const cmd = new Command("dock")
+        .description("Dock tools into your project")
+        .option("-y, --yes", "Auto-accept all defaults")
+        .option("--json", "Output results as JSON")
+        .option("-f, --force", "Overwrite existing configuration")
+        .action(async (options) => {
+        await runSmartDock(options);
+    });
+    // dock config - Just create config
+    cmd
+        .command("config")
+        .description("Create .buoy.yaml configuration file")
+        .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 hooks (interactive by default)
+    cmd
+        .command("hooks")
+        .description("Set up hooks for drift checking")
+        .option("--commit", "Set up git pre-commit hooks")
+        .option("--claude", "Set up Claude Code hooks (design system in every session)")
+        .action(async (options) => {
+        await runHooksDock(options);
+    });
+    // dock commands - Install global Claude Code slash commands
+    const commandsCmd = cmd
+        .command("commands")
+        .description("Manage Claude Code slash commands");
+    commandsCmd
+        .command("list")
+        .description("List available Buoy slash commands")
+        .option("--json", "Output as JSON")
+        .action((options) => {
+        if (options.json)
+            setJsonMode(true);
+        const available = listAvailableSlashCommands();
+        const commandsDir = join(homedir(), ".claude", "commands");
+        if (options.json) {
+            const result = available.map(name => ({
+                name,
+                installed: existsSync(join(commandsDir, `${name}.md`)),
+            }));
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log("");
+        console.log(chalk.cyan.bold("  Available Buoy Commands"));
+        console.log("");
+        if (available.length === 0) {
+            console.log(chalk.dim("  No commands available"));
+            return;
+        }
+        for (const name of available) {
+            const isInstalled = existsSync(join(commandsDir, `${name}.md`));
+            const status = isInstalled
+                ? chalk.green("✓ installed")
+                : chalk.dim("not installed");
+            console.log(`  /${name}  ${status}`);
+        }
+        console.log("");
+        console.log(chalk.dim("  Run `buoy dock commands install` to install all commands"));
+        console.log("");
+    });
+    commandsCmd
+        .command("install")
+        .description("Install Buoy slash commands to ~/.claude/commands/")
+        .option("--dry-run", "Show what would be installed")
+        .option("--json", "Output as JSON")
+        .action((options) => {
+        if (options.json)
+            setJsonMode(true);
+        const result = installGlobalSlashCommands(options.dryRun);
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log("");
+        if (options.dryRun) {
+            console.log(chalk.cyan.bold("  Dry Run - Would install:"));
+            console.log("");
+            for (const name of result.installed) {
+                console.log(`  ${chalk.green("+")} /${name}`);
+            }
+            for (const name of result.alreadyExisted) {
+                console.log(`  ${chalk.dim("○")} /${name} (already exists)`);
+            }
+        }
+        else {
+            if (result.installed.length > 0) {
+                console.log(chalk.green.bold("  ✓ Installed slash commands:"));
+                console.log("");
+                for (const name of result.installed) {
+                    console.log(`    /${name}`);
+                }
+            }
+            if (result.alreadyExisted.length > 0) {
+                console.log("");
+                console.log(chalk.dim(`  Already installed: ${result.alreadyExisted.map(c => `/${c}`).join(", ")}`));
+            }
+            if (result.installed.length === 0 && result.alreadyExisted.length > 0) {
+                console.log(chalk.dim("  All commands already installed"));
+            }
+        }
+        console.log("");
+        console.log(chalk.dim("  Commands installed to: ~/.claude/commands/"));
+        console.log(chalk.dim("  Restart Claude Code to use them"));
+        console.log("");
+    });
+    // dock plugins - Show and suggest scanners/plugins
+    const pluginsCmd = cmd
+        .command("plugins")
+        .description("Show available scanners and plugins");
+    pluginsCmd
+        .command("list")
+        .description("List available scanners and plugins")
+        .action(async () => {
+        console.log(chalk.bold('\nBuilt-in Scanners') + chalk.dim(' (always available)'));
+        console.log('');
+        for (const [_key, scannerInfo] of Object.entries(BUILTIN_SCANNERS)) {
+            console.log(`  ${chalk.green('✓')} ${chalk.cyan(scannerInfo.description)}`);
+            console.log(`    ${chalk.dim(`Detects: ${scannerInfo.detects}`)}`);
+            console.log();
+        }
+        console.log(chalk.bold('Optional Plugins'));
+        console.log('');
+        for (const [_key, pluginInfo] of Object.entries(PLUGIN_INFO)) {
+            console.log(`  ${chalk.dim('○')} ${chalk.cyan(pluginInfo.name)}`);
+            console.log(`    ${chalk.dim(pluginInfo.description)}`);
+            console.log();
+        }
+    });
+    pluginsCmd
+        .command("suggest")
+        .description("Suggest plugins based on detected frameworks")
+        .action(async () => {
+        try {
+            const detected = await detectFrameworks(process.cwd());
+            if (detected.length === 0) {
+                console.log(chalk.yellow('No frameworks detected.'));
+                return;
+            }
+            const builtIn = detected.filter(fw => fw.scanner);
+            const needsPlugin = detected.filter(fw => fw.plugin && !fw.scanner);
+            if (builtIn.length > 0) {
+                console.log(chalk.bold('\nDetected (built-in support):'));
+                for (const fw of builtIn) {
+                    console.log(`  ${chalk.green('✓')} ${fw.name} ${chalk.dim(`- ${fw.evidence}`)}`);
+                }
+            }
+            if (needsPlugin.length > 0) {
+                console.log(chalk.bold('\nDetected (optional plugin available):'));
+                for (const fw of needsPlugin) {
+                    console.log(`  ${chalk.yellow('○')} ${fw.name} ${chalk.dim(`- ${fw.evidence}`)}`);
+                }
+                const pluginNames = needsPlugin
+                    .map(fw => fw.plugin)
+                    .filter((p, i, arr) => arr.indexOf(p) === i);
+                console.log('\n' + chalk.bold('Install optional plugins:'));
+                console.log(`  ${chalk.cyan(getPluginInstallCommand(pluginNames))}`);
+            }
+        }
+        catch (err) {
+            console.error(chalk.red(`Failed to detect frameworks: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // dock tokens (with compare and import as subcommands)
+    const tokensCmd = createTokensCommand();
+    tokensCmd.addCommand(createCompareCommand());
+    tokensCmd.addCommand(createImportCommand());
+    cmd.addCommand(tokensCmd);
+    // dock graph (with learn as subcommand)
+    const graphCmd = createGraphCommand();
+    graphCmd.addCommand(createLearnCommand());
+    cmd.addCommand(graphCmd);
+    return cmd;
+}
+function listAvailableSlashCommands() {
+    const assetsDir = resolve(__dirname, "..", "..", "assets", "commands");
+    if (!existsSync(assetsDir))
+        return [];
+    return readdirSync(assetsDir)
+        .filter(f => f.endsWith(".md"))
+        .map(f => f.replace(".md", ""));
+}
+function installGlobalSlashCommands(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 });
+    }
+    const commandFiles = readdirSync(assetsDir).filter(f => f.endsWith(".md"));
+    for (const file of commandFiles) {
+        const srcPath = join(assetsDir, file);
+        const destPath = join(commandsDir, file);
+        if (existsSync(destPath)) {
+            alreadyExisted.push(file.replace(".md", ""));
+        }
+        else {
+            if (!dryRun) {
+                copyFileSync(srcPath, destPath);
+            }
+            installed.push(file.replace(".md", ""));
+        }
+    }
+    return { installed, alreadyExisted };
+}
+/**
+ * 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,
+    };
+    // Step 1: Check/create config
+    const configPath = getConfigPath();
+    if (!configPath) {
+        console.log(chalk.yellow("  ⚠ No .buoy.yaml 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;
+        }
+        else {
+            console.log("");
+            info("Run `buoy dock config` later to create config.");
+            console.log("");
+            return;
+        }
+    }
+    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;
+        }
+    }
+    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;
+        }
+    }
+    else {
+        console.log(`  ${chalk.green("✓")} Hooks configured`);
+        results.hooksSetup = true;
+    }
+    // Summary
+    console.log("");
+    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 {
+            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")}`);
+        }
+    }
+    console.log("");
+}
+/**
+ * Config dock - creates .buoy.yaml
+ */
+async function runConfigDock(options) {
+    const cwd = process.cwd();
+    const configFilePath = resolve(cwd, ".buoy.yaml");
+    if (existsSync(configFilePath) && !options.force) {
+        warning(`Config already exists at ${configFilePath}`);
+        info("Use --force to overwrite");
+        return;
+    }
+    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,
+        };
+    }
+    else {
+        const spin = ora("Scanning project...").start();
+        try {
+            const detector = new ProjectDetector(cwd);
+            project = await detector.detect();
+            // Also scan for token files using auto-detect patterns
+            // This catches files like theme.css, variables.css that ProjectDetector may miss
+            const tokenFiles = await findTokenFiles(cwd);
+            if (tokenFiles.length > 0) {
+                // Get existing token paths for deduplication
+                const existingPaths = new Set(project.tokens.map((t) => t.path));
+                // Add any new token files not already detected
+                for (const tokenPath of tokenFiles) {
+                    if (!existingPaths.has(tokenPath)) {
+                        project.tokens.push({
+                            path: tokenPath,
+                            type: tokenPath.endsWith(".json") ? "json" : "css",
+                            name: `Token file: ${tokenPath}`,
+                        });
+                    }
+                }
+            }
+            spin.stop();
+            printDetectionResults(project);
+        }
+        catch (err) {
+            spin.fail("Detection failed");
+            error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    }
+    // Show frameworks and offer plugin install
+    const detectedFrameworks = await detectFrameworks(cwd);
+    if (detectedFrameworks.length > 0) {
+        await showFrameworksAndPlugins(detectedFrameworks, options.yes);
+    }
+    // Generate and write config
+    const content = generateConfig(project);
+    try {
+        writeFileSync(configFilePath, content, "utf-8");
+        success("Created .buoy.yaml");
+    }
+    catch (err) {
+        error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+/**
+ * Agents dock - sets up AI agents (skills + context + commands)
+ */
+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 = {
+            agentsCreated: [],
+            commandsCreated: [],
+            skillCreated: false,
+            contextUpdated: false,
+            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;
+        }
+        // Create agents
+        const agentsDir = resolve(cwd, ".claude/agents");
+        const agents = generateAgents(projectName);
+        if (options.dryRun) {
+            console.log(chalk.dim("  Would create: .claude/agents/"));
+            for (const agent of agents) {
+                console.log(chalk.dim(`    - ${agent.filename}`));
+            }
+        }
+        else {
+            if (!existsSync(agentsDir))
+                mkdirSync(agentsDir, { recursive: true });
+            for (const agent of agents) {
+                writeFileSync(join(agentsDir, agent.filename), agent.content);
+                results.agentsCreated.push(agent.filename.replace(".md", ""));
+            }
+        }
+        // Create commands
+        const commandsDir = resolve(cwd, ".claude/commands");
+        const commands = generateCommands(projectName);
+        if (options.dryRun) {
+            console.log(chalk.dim("  Would create: .claude/commands/"));
+            for (const cmd of commands) {
+                console.log(chalk.dim(`    - ${cmd.filename}`));
+            }
+        }
+        else {
+            if (!existsSync(commandsDir))
+                mkdirSync(commandsDir, { recursive: true });
+            for (const cmd of commands) {
+                writeFileSync(join(commandsDir, cmd.filename), cmd.content);
+                results.commandsCreated.push(cmd.filename.replace(".md", ""));
+            }
+        }
+        // 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;
+            }
+        }
+        if (options.json) {
+            console.log(JSON.stringify(results, null, 2));
+        }
+        else if (!options.dryRun) {
+            console.log("");
+            if (results.agentsCreated.length > 0) {
+                console.log(`  ${chalk.green("✓")} Created agents: ${results.agentsCreated.join(", ")}`);
+            }
+            if (results.commandsCreated.length > 0) {
+                console.log(`  ${chalk.green("✓")} Created commands: ${results.commandsCreated.map((c) => `/${c}`).join(", ")}`);
+            }
+            if (results.skillCreated)
+                console.log(`  ${chalk.green("✓")} Created skill files`);
+            if (results.contextUpdated)
+                console.log(`  ${chalk.green("✓")} Updated CLAUDE.md`);
+            console.log("");
+        }
+    }
+    catch (err) {
+        spin.stop();
+        error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+/**
+ * Skills dock - creates skill files only
+ */
+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);
+    }
+}
+/**
+ * Context dock - generates CLAUDE.md section
+ */
+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 {
+                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);
+    }
+}
+/**
+ * Hooks dock - sets up hooks (interactive by default)
+ */
+async function runHooksDock(options) {
+    const cwd = process.cwd();
+    console.log("");
+    // If no flags provided, ask interactively
+    let setupCommit = options.commit;
+    let setupClaude = options.claude;
+    if (!setupCommit && !setupClaude) {
+        // Check if we're in an interactive terminal
+        if (!process.stdin.isTTY) {
+            // Non-interactive: skip hooks setup with a friendly message
+            info("Skipping interactive hooks setup (non-interactive terminal)");
+            console.log("");
+            console.log(chalk.dim("  To set up hooks later, run:"));
+            console.log(`    ${chalk.cyan("buoy dock hooks --commit")}   # Git pre-commit hooks`);
+            console.log(`    ${chalk.cyan("buoy dock hooks --claude")}   # Claude Code hooks`);
+            console.log(`    ${chalk.cyan("buoy dock hooks")}            # Interactive setup`);
+            console.log("");
+            return;
+        }
+        try {
+            const choice = await showMenu("Which hooks would you like to set up?", [
+                {
+                    label: "🔗 Claude Code hooks",
+                    value: "claude",
+                    description: "Inject design system context into every Claude session",
+                },
+                {
+                    label: "📝 Git pre-commit hooks",
+                    value: "commit",
+                    description: "Check for drift before each commit",
+                },
+                {
+                    label: "✨ Both",
+                    value: "both",
+                    description: "Set up Claude hooks and git pre-commit hooks",
+                },
+            ]);
+            if (choice === "commit" || choice === "both") {
+                setupCommit = true;
+            }
+            if (choice === "claude" || choice === "both") {
+                setupClaude = true;
+            }
+        }
+        catch (err) {
+            // Handle user closing the prompt (Ctrl+C, etc.) gracefully
+            if (err && typeof err === 'object' && 'name' in err && err.name === 'ExitPromptError') {
+                console.log("");
+                info("Hooks setup cancelled");
+                console.log(chalk.dim("  Run `buoy dock hooks` anytime to set up hooks"));
+                console.log("");
+                return;
+            }
+            throw err;
+        }
+    }
+    // Set up git pre-commit hooks
+    if (setupCommit) {
+        const hookSystem = detectHookSystem(cwd);
+        if (hookSystem) {
+            info(`Detected: ${hookSystem}`);
+            const hookResult = setupHooks(cwd);
+            if (hookResult.success) {
+                success(hookResult.message);
+            }
+            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 {
+                warning(standaloneResult.message);
+            }
+        }
+    }
+    // Set up Claude Code hooks
+    if (setupClaude) {
+        if (setupCommit)
+            console.log(""); // Add spacing if both
+        const { config, projectName } = await loadOrBuildConfig(cwd);
+        const orchestrator = new ScanOrchestrator(config, cwd);
+        const spin = spinner("Scanning design system for Claude context...");
+        const scanResult = await orchestrator.scan();
+        spin.stop();
+        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");
+            info("Your design system will be loaded at the start of each Claude session");
+        }
+        else {
+            warning(`Claude hooks failed: ${claudeResult.message}`);
+        }
+    }
+    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 generateConfig(project) {
+    const monorepoConfig = detectMonorepoConfig(project.root);
+    // Build the config object
+    const config = {
+        project: { name: project.name },
+        sources: {},
+    };
+    const sources = config.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;
+            sources[sourceKey] = {
+                enabled: true,
+                include: patterns,
+                exclude: ["**/*.test.*", "**/*.spec.*", "**/*.stories.*"],
+            };
+        }
+    }
+    if (project.tokens.length > 0) {
+        sources.tokens = {
+            enabled: true,
+            files: project.tokens.map((t) => t.path),
+        };
+    }
+    sources.figma = { enabled: false };
+    config.output = { format: "table", colors: true };
+    // Generate YAML with header comment
+    const header = `# Buoy Configuration
+# Auto-generated - customize to match your project
+# Docs: https://buoy.design/docs/configuration
+
+`;
+    return header + stringifyYaml(config, { indent: 2, lineWidth: 0 });
+}
+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");
+            }
+            catch {
+                warning("Plugin install failed");
+            }
+        }
+    }
+}
+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");
+        });
+    });
+}
+//# sourceMappingURL=dock.js.map