@fragments-sdk/cli 0.2.2

package/dist/bin.js

@@ -0,0 +1,4783 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  buildFragmentsDir,
+  buildSegments,
+  runAnalyzeCommand,
+  runDiffCommand,
+  runScreenshotCommand,
+  validateAll,
+  validateCoverage,
+  validateSchema
+} from "./chunk-4FDQSGKX.js";
+import {
+  scan
+} from "./chunk-7H2MMGYG.js";
+import {
+  FigmaClient,
+  StorageManager,
+  checkStorybookRunning,
+  createMetricsStore,
+  extractPropsFromFile,
+  generateComponentContext,
+  generatePromptContext,
+  generateSystemPrompt,
+  generateUserPrompt,
+  getScanStats,
+  parseAllStories,
+  renderAllComponentVariants,
+  scanCodebase,
+  shutdownSharedPool
+} from "./chunk-MUZ6CM66.js";
+import {
+  discoverSegmentFiles,
+  loadConfig,
+  loadSegmentFile
+} from "./chunk-OAENNG3G.js";
+import {
+  generateContext
+} from "./chunk-LY2CFFPY.js";
+import {
+  BRAND
+} from "./chunk-XHNKNI6J.js";
+
+// src/bin.ts
+import { Command } from "commander";
+import pc20 from "picocolors";
+
+// src/commands/validate.ts
+import pc from "picocolors";
+async function validate(options = {}) {
+  const { config, configDir } = await loadConfig(options.config);
+  console.log(pc.cyan(`
+${BRAND.name} Validator
+`));
+  let result;
+  if (options.schema) {
+    console.log(pc.dim("Running schema validation...\n"));
+    result = await validateSchema(config, configDir);
+  } else if (options.coverage) {
+    console.log(pc.dim("Running coverage validation...\n"));
+    result = await validateCoverage(config, configDir);
+  } else {
+    console.log(pc.dim("Running all validations...\n"));
+    result = await validateAll(config, configDir);
+  }
+  if (result.errors.length > 0) {
+    console.log(pc.red(pc.bold("Errors:")));
+    for (const error of result.errors) {
+      console.log(`  ${pc.red("\u2717")} ${pc.bold(error.file)}`);
+      console.log(`    ${error.message}`);
+      if (error.details) {
+        console.log(pc.dim(`    ${error.details}`));
+      }
+    }
+    console.log();
+  }
+  if (result.warnings.length > 0) {
+    console.log(pc.yellow(pc.bold("Warnings:")));
+    for (const warning of result.warnings) {
+      console.log(`  ${pc.yellow("\u26A0")} ${pc.bold(warning.file)}`);
+      console.log(`    ${warning.message}`);
+    }
+    console.log();
+  }
+  if (result.valid && result.warnings.length === 0) {
+    console.log(pc.green("\u2713 All validations passed\n"));
+  } else if (result.valid) {
+    console.log(
+      pc.yellow(`\u26A0 Passed with ${result.warnings.length} warning(s)
+`)
+    );
+  } else {
+    console.log(pc.red(`\u2717 Failed with ${result.errors.length} error(s)
+`));
+  }
+  return result;
+}
+
+// src/commands/build.ts
+import pc2 from "picocolors";
+async function build(options = {}) {
+  if (options.fromSource) {
+    console.log(pc2.cyan(`
+${BRAND.name} Build (from source)
+`));
+    console.log(pc2.dim("Using zero-config source extraction pipeline\n"));
+    const scanResult = await scan({
+      config: options.config,
+      output: options.output,
+      skipUsage: options.skipUsage,
+      skipStorybook: options.skipStorybook,
+      verbose: options.verbose
+    });
+    return {
+      success: scanResult.success,
+      segmentCount: scanResult.componentCount,
+      outputPath: scanResult.outputPath,
+      errors: scanResult.errors.map((e) => ({ file: e.component, error: e.error }))
+    };
+  }
+  const { config, configDir } = await loadConfig(options.config);
+  if (options.output) {
+    config.outFile = options.output;
+  }
+  console.log(pc2.cyan(`
+${BRAND.name} Build
+`));
+  const errors = [];
+  let segmentCount;
+  let outputPath;
+  let componentCount;
+  let registryPath;
+  let contextPath;
+  if (!options.registryOnly) {
+    console.log(pc2.dim("Compiling fragments...\n"));
+    const result = await buildSegments(config, configDir);
+    if (result.errors.length > 0) {
+      console.log(pc2.yellow("Build completed with errors:\n"));
+      for (const error of result.errors) {
+        console.log(`  ${pc2.red("\u2717")} ${error.file}: ${error.error}`);
+        errors.push(error);
+      }
+      console.log();
+    }
+    segmentCount = result.segmentCount;
+    outputPath = result.outputPath;
+    console.log(pc2.green(`\u2713 Built ${result.segmentCount} fragment(s)`));
+    console.log(pc2.dim(`  Output: ${result.outputPath}
+`));
+  }
+  if (options.registry || options.registryOnly) {
+    console.log(pc2.dim("Generating registry and context...\n"));
+    const fragmentsResult = await buildFragmentsDir(config, configDir);
+    if (fragmentsResult.errors.length > 0) {
+      console.log(pc2.yellow("Registry build completed with errors:\n"));
+      for (const error of fragmentsResult.errors) {
+        console.log(`  ${pc2.red("\u2717")} ${error.file}: ${error.error}`);
+        errors.push(error);
+      }
+      console.log();
+    }
+    componentCount = fragmentsResult.componentCount;
+    registryPath = fragmentsResult.registryPath;
+    contextPath = fragmentsResult.contextPath;
+    console.log(pc2.green(`\u2713 Generated registry with ${fragmentsResult.componentCount} component(s)`));
+    console.log(pc2.dim(`  Registry: ${fragmentsResult.registryPath}`));
+    console.log(pc2.dim(`  Context:  ${fragmentsResult.contextPath}
+`));
+  }
+  return {
+    success: errors.length === 0,
+    segmentCount,
+    outputPath,
+    componentCount,
+    registryPath,
+    contextPath,
+    errors
+  };
+}
+
+// src/commands/context.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import pc3 from "picocolors";
+async function context(options = {}) {
+  const {
+    format = "markdown",
+    compact = false,
+    includeCode = false,
+    includeRelations = false,
+    tokensOnly = false
+  } = options;
+  let segments;
+  if (options.input) {
+    const inputPath = resolve(process.cwd(), options.input);
+    const content2 = await readFile(inputPath, "utf-8");
+    const data = JSON.parse(content2);
+    segments = Object.values(data.segments);
+  } else {
+    const { config, configDir } = await loadConfig(options.config);
+    const result = await buildSegments(config, configDir);
+    if (result.errors.length > 0 && result.segmentCount === 0) {
+      console.error(pc3.red("Error: No segments found. Run `segments build` first or fix errors."));
+      return { success: false, tokenEstimate: 0 };
+    }
+    const content2 = await readFile(result.outputPath, "utf-8");
+    const data = JSON.parse(content2);
+    segments = Object.values(data.segments);
+  }
+  if (segments.length === 0) {
+    console.error(pc3.red("No segments found."));
+    return { success: false, tokenEstimate: 0 };
+  }
+  const { content, tokenEstimate } = generateContext(segments, {
+    format,
+    compact,
+    include: {
+      code: includeCode,
+      relations: includeRelations
+    }
+  });
+  if (tokensOnly) {
+    console.log(`Estimated tokens: ${tokenEstimate}`);
+  } else {
+    console.log(content);
+    console.error(pc3.dim(`
+[${tokenEstimate} tokens estimated]`));
+  }
+  return {
+    success: true,
+    content,
+    tokenEstimate
+  };
+}
+
+// src/commands/list.ts
+import pc4 from "picocolors";
+async function list(options = {}) {
+  const { config, configDir } = await loadConfig(options.config);
+  const files = await discoverSegmentFiles(config, configDir);
+  console.log(pc4.cyan(`
+${BRAND.name} - Discovered Fragments
+`));
+  if (files.length === 0) {
+    console.log(pc4.yellow("No fragment files found.\n"));
+    console.log(pc4.dim(`Looking for: ${config.include.join(", ")}`));
+    return { success: true, files: [] };
+  }
+  for (const file of files) {
+    console.log(`  ${pc4.dim("\u2022")} ${file.relativePath}`);
+  }
+  console.log(pc4.dim(`
+  ${files.length} fragment(s) found
+`));
+  return { success: true, files };
+}
+
+// src/commands/reset.ts
+import { stat, rm, unlink } from "fs/promises";
+import { join, relative } from "path";
+import pc5 from "picocolors";
+import fg from "fast-glob";
+async function reset(options = {}) {
+  const { yes = false, dryRun = false } = options;
+  console.log(pc5.cyan(`
+${BRAND.name} Reset
+`));
+  const projectRoot = process.cwd();
+  const filesToDelete = [];
+  const dirsToDelete = [];
+  const dataDir = join(projectRoot, BRAND.dataDir);
+  try {
+    const dataDirStat = await stat(dataDir);
+    if (dataDirStat.isDirectory()) {
+      dirsToDelete.push(dataDir);
+    }
+  } catch {
+  }
+  const defaultOutFile = join(projectRoot, "segments.json");
+  try {
+    const fileStat = await stat(defaultOutFile);
+    if (fileStat.isFile()) {
+      filesToDelete.push(defaultOutFile);
+    }
+  } catch {
+  }
+  let segmentPatterns = [`**/*${BRAND.fileExtension}`];
+  try {
+    const { config } = await loadConfig();
+    if (config.outFile && config.outFile !== "segments.json") {
+      const customOutFile = join(projectRoot, config.outFile);
+      try {
+        const fileStat = await stat(customOutFile);
+        if (fileStat.isFile()) {
+          filesToDelete.push(customOutFile);
+        }
+      } catch {
+      }
+    }
+    if (config.include && config.include.length > 0) {
+      segmentPatterns = config.include;
+    }
+  } catch {
+  }
+  console.log(pc5.dim("Scanning for generated files...\n"));
+  for (const pattern of segmentPatterns) {
+    const matches = await fg(pattern, {
+      cwd: projectRoot,
+      ignore: ["**/node_modules/**"],
+      absolute: true
+    });
+    for (const match of matches) {
+      if (!filesToDelete.includes(match)) {
+        filesToDelete.push(match);
+      }
+    }
+  }
+  const mdxFiles = await fg("**/Documentation.mdx", {
+    cwd: projectRoot,
+    ignore: ["**/node_modules/**"],
+    absolute: true
+  });
+  for (const mdxFile of mdxFiles) {
+    if (!filesToDelete.includes(mdxFile)) {
+      filesToDelete.push(mdxFile);
+    }
+  }
+  if (filesToDelete.length === 0 && dirsToDelete.length === 0) {
+    console.log(pc5.yellow("Nothing to reset. No generated files found.\n"));
+    return { success: true, deletedFiles: 0, deletedDirs: 0 };
+  }
+  console.log(pc5.dim("The following will be deleted:\n"));
+  for (const dir of dirsToDelete) {
+    const relativePath = relative(projectRoot, dir);
+    console.log(`  \u{1F4C1} ${relativePath}/`);
+  }
+  const segmentFiles = filesToDelete.filter((f) => f.endsWith(BRAND.fileExtension));
+  const mdxFilesFound = filesToDelete.filter((f) => f.endsWith(".mdx"));
+  const otherFiles = filesToDelete.filter(
+    (f) => !f.endsWith(BRAND.fileExtension) && !f.endsWith(".mdx")
+  );
+  if (segmentFiles.length > 0) {
+    console.log(`  \u{1F4C4} ${segmentFiles.length} segment file(s) (*${BRAND.fileExtension})`);
+    if (segmentFiles.length <= 5) {
+      for (const f of segmentFiles) {
+        console.log(pc5.dim(`     ${relative(projectRoot, f)}`));
+      }
+    } else {
+      for (const f of segmentFiles.slice(0, 3)) {
+        console.log(pc5.dim(`     ${relative(projectRoot, f)}`));
+      }
+      console.log(pc5.dim(`     ... and ${segmentFiles.length - 3} more`));
+    }
+  }
+  if (mdxFilesFound.length > 0) {
+    console.log(`  \u{1F4C4} ${mdxFilesFound.length} documentation file(s) (*.mdx)`);
+    if (mdxFilesFound.length <= 5) {
+      for (const f of mdxFilesFound) {
+        console.log(pc5.dim(`     ${relative(projectRoot, f)}`));
+      }
+    } else {
+      for (const f of mdxFilesFound.slice(0, 3)) {
+        console.log(pc5.dim(`     ${relative(projectRoot, f)}`));
+      }
+      console.log(pc5.dim(`     ... and ${mdxFilesFound.length - 3} more`));
+    }
+  }
+  for (const f of otherFiles) {
+    console.log(`  \u{1F4C4} ${relative(projectRoot, f)}`);
+  }
+  const totalCount = filesToDelete.length + dirsToDelete.length;
+  console.log(pc5.dim(`
+  Total: ${totalCount} item(s)
+`));
+  if (dryRun) {
+    console.log(pc5.yellow("[Dry run - no files were deleted]\n"));
+    return { success: true, deletedFiles: 0, deletedDirs: 0 };
+  }
+  let proceed = yes;
+  if (!proceed) {
+    const { confirm } = await import("@inquirer/prompts");
+    try {
+      proceed = await confirm({
+        message: `Delete ${totalCount} item(s)?`,
+        default: false
+      });
+    } catch {
+      proceed = false;
+    }
+  }
+  if (!proceed) {
+    console.log(pc5.dim("\nNo changes made.\n"));
+    return { success: true, deletedFiles: 0, deletedDirs: 0 };
+  }
+  console.log();
+  let deletedDirs = 0;
+  for (const dir of dirsToDelete) {
+    try {
+      const relativePath = relative(projectRoot, dir);
+      await rm(dir, { recursive: true, force: true });
+      console.log(`  ${pc5.green("\u2713")} Deleted ${relativePath}/`);
+      deletedDirs++;
+    } catch {
+      console.log(`  ${pc5.red("\u2717")} Failed: ${relative(projectRoot, dir)}`);
+    }
+  }
+  let deletedCount = 0;
+  let failedCount = 0;
+  for (const file of filesToDelete) {
+    try {
+      await unlink(file);
+      deletedCount++;
+    } catch {
+      failedCount++;
+    }
+  }
+  if (deletedCount > 0) {
+    console.log(`  ${pc5.green("\u2713")} Deleted ${deletedCount} file(s)`);
+  }
+  if (failedCount > 0) {
+    console.log(`  ${pc5.red("\u2717")} Failed to delete ${failedCount} file(s)`);
+  }
+  console.log(pc5.green(`
+\u2713 Reset complete
+`));
+  console.log(pc5.dim(`Config file retained: ${BRAND.configFile}`));
+  console.log(pc5.dim(`Run ${pc5.cyan(`${BRAND.cliCommand} init`)} to start fresh
+`));
+  return {
+    success: true,
+    deletedFiles: deletedCount,
+    deletedDirs
+  };
+}
+
+// src/commands/dev.ts
+import pc7 from "picocolors";
+
+// src/setup.ts
+import pc6 from "picocolors";
+
+// src/migrate/migrate.ts
+import { writeFile, mkdir, access, stat as stat2 } from "fs/promises";
+import { join as join2, dirname, relative as relative2 } from "path";
+import fg2 from "fast-glob";
+
+// src/migrate/parser.ts
+import { readFile as readFile2 } from "fs/promises";
+async function parseStoryFile(filePath) {
+  const content = await readFile2(filePath, "utf-8");
+  return parseStoryContent(content, filePath);
+}
+function parseStoryContent(content, filePath) {
+  const warnings = [];
+  const meta = parseMeta(content, filePath, warnings);
+  const argTypes = parseArgTypes(content, warnings);
+  const constDeclarations = extractConstDeclarations(content);
+  const stories = parseStories(content, meta.componentName, warnings, constDeclarations);
+  const confidence = calculateConfidence(meta, argTypes, stories, warnings);
+  return {
+    filePath,
+    meta,
+    argTypes,
+    stories,
+    warnings,
+    confidence
+  };
+}
+function calculateConfidence(meta, argTypes, stories, warnings) {
+  let score = 1;
+  score -= warnings.length * 0.1;
+  if (meta.componentName === "Unknown") {
+    score -= 0.3;
+  }
+  if (!meta.componentImport) {
+    score -= 0.1;
+  }
+  if (Object.keys(argTypes).length === 0) {
+    score -= 0.1;
+  }
+  if (stories.length === 0) {
+    score -= 0.3;
+  }
+  const customRenderCount = stories.filter((s) => s.hasCustomRender).length;
+  if (customRenderCount > 0) {
+    score -= customRenderCount / Math.max(stories.length, 1) * 0.2;
+  }
+  return Math.max(0, Math.min(1, score));
+}
+function extractConstDeclarations(content) {
+  const declarations = /* @__PURE__ */ new Map();
+  const constPattern = /const\s+(\w+)(?:\s*:\s*[^=]+)?\s*=\s*\{/g;
+  let match;
+  while ((match = constPattern.exec(content)) !== null) {
+    const varName = match[1];
+    if (varName === "meta" || varName === "default" || varName === "Template") {
+      continue;
+    }
+    const braceStart = match.index + match[0].length - 1;
+    const braceEnd = findMatchingBraceInContent(content, braceStart, "{", "}");
+    if (braceEnd === -1) {
+      continue;
+    }
+    const objectContent = content.slice(braceStart + 1, braceEnd);
+    const parsed = parseArgsSimple(objectContent);
+    if (Object.keys(parsed).length > 0) {
+      declarations.set(varName, parsed);
+    }
+  }
+  return declarations;
+}
+function parseArgsSimple(content) {
+  const args = {};
+  const pairs = splitAtTopLevelCommas(content);
+  for (const pair of pairs) {
+    const trimmed = pair.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("...")) {
+      continue;
+    }
+    if (/^\w+$/.test(trimmed)) {
+      args[trimmed] = `__REF__${trimmed}`;
+      continue;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex > 0) {
+      const key = trimmed.slice(0, colonIndex).trim();
+      const valueStr = trimmed.slice(colonIndex + 1).trim();
+      if (/^\w+$/.test(key)) {
+        args[key] = parseArgValue(valueStr);
+      }
+    }
+  }
+  return args;
+}
+function parseMeta(content, filePath, warnings) {
+  const result = {
+    title: "",
+    componentName: ""
+  };
+  const titleRegex = /title:\s*['"`]([^'"`]+)['"`]/g;
+  const titleMatches = [];
+  let match;
+  while ((match = titleRegex.exec(content)) !== null) {
+    titleMatches.push(match[1]);
+  }
+  const componentPathTitle = titleMatches.find((t) => t.includes("/"));
+  const selectedTitle = componentPathTitle ?? titleMatches[0];
+  if (selectedTitle) {
+    result.title = selectedTitle;
+    const segments = result.title.split("/");
+    result.componentName = segments[segments.length - 1];
+  }
+  const componentMatch = content.match(/component:\s*(\w+)/);
+  if (componentMatch) {
+    if (!result.componentName) {
+      result.componentName = componentMatch[1];
+    }
+    const importMatch = content.match(
+      new RegExp(
+        `import\\s*{[^}]*\\b${componentMatch[1]}\\b[^}]*}\\s*from\\s*['"\`]([^'"\`]+)['"\`]`
+      )
+    );
+    if (importMatch) {
+      result.componentImport = importMatch[1];
+    } else {
+      const defaultImportMatch = content.match(
+        new RegExp(
+          `import\\s+${componentMatch[1]}\\s+from\\s*['"\`]([^'"\`]+)['"\`]`
+        )
+      );
+      if (defaultImportMatch) {
+        result.componentImport = defaultImportMatch[1];
+      }
+    }
+  }
+  const tagsMatch = content.match(/tags:\s*\[([^\]]+)\]/);
+  if (tagsMatch) {
+    const tagsContent = tagsMatch[1];
+    result.tags = tagsContent.split(",").map((t) => t.trim().replace(/['"`]/g, "")).filter(Boolean);
+  }
+  const descMatch = content.match(
+    /description:\s*\{[^}]*component:\s*['"`]([^'"`]+)['"`]/
+  );
+  if (descMatch) {
+    result.description = descMatch[1];
+  }
+  if (!result.componentName) {
+    const match2 = filePath.match(/([^/\\]+)\.stories\.(tsx?|jsx?|mdx)$/);
+    if (match2) {
+      result.componentName = match2[1];
+    } else {
+      result.componentName = "Unknown";
+      warnings.push("Could not determine component name");
+    }
+  }
+  if (!result.title) {
+    result.title = `Components/${result.componentName}`;
+    warnings.push(`No title found, using default: ${result.title}`);
+  }
+  return result;
+}
+function parseArgTypes(content, warnings) {
+  const result = {};
+  const argTypesStart = content.indexOf("argTypes:");
+  if (argTypesStart === -1) {
+    return result;
+  }
+  const braceStart = content.indexOf("{", argTypesStart);
+  if (braceStart === -1) {
+    return result;
+  }
+  let depth = 1;
+  let braceEnd = braceStart + 1;
+  while (depth > 0 && braceEnd < content.length) {
+    if (content[braceEnd] === "{") depth++;
+    if (content[braceEnd] === "}") depth--;
+    braceEnd++;
+  }
+  const argTypesContent = content.slice(braceStart + 1, braceEnd - 1);
+  let pos = 0;
+  while (pos < argTypesContent.length) {
+    while (pos < argTypesContent.length && /[\s,]/.test(argTypesContent[pos])) {
+      pos++;
+    }
+    const nameMatch = argTypesContent.slice(pos).match(/^(\w+)\s*:\s*\{/);
+    if (!nameMatch) break;
+    const propName = nameMatch[1];
+    pos += nameMatch[0].length - 1;
+    let propDepth = 1;
+    const propStart = pos + 1;
+    pos++;
+    while (propDepth > 0 && pos < argTypesContent.length) {
+      if (argTypesContent[pos] === "{") propDepth++;
+      if (argTypesContent[pos] === "}") propDepth--;
+      pos++;
+    }
+    const propContent = argTypesContent.slice(propStart, pos - 1);
+    result[propName] = parseArgTypeContent(propContent, warnings);
+  }
+  return result;
+}
+function parseArgTypeContent(content, warnings) {
+  const result = {};
+  const controlMatch = content.match(/control:\s*['"`](\w+)['"`]/);
+  if (controlMatch) {
+    result.control = controlMatch[1];
+  } else {
+    const controlTypeMatch = content.match(/control:\s*\{[^}]*type:\s*['"`](\w+)['"`]/);
+    if (controlTypeMatch) {
+      result.control = controlTypeMatch[1];
+    }
+  }
+  const optionsMatch = content.match(/options:\s*\[([^\]]+)\]/);
+  if (optionsMatch) {
+    result.options = optionsMatch[1].split(",").map((o) => o.trim().replace(/['"`]/g, "")).filter(Boolean);
+  }
+  const descMatch = content.match(/description:\s*['"`]([^'"`]+)['"`]/);
+  if (descMatch) {
+    result.description = descMatch[1];
+  }
+  const defaultMatch = content.match(/defaultValue:\s*\{[^}]*summary:\s*['"`]([^'"`]+)['"`]/);
+  if (defaultMatch) {
+    result.defaultValue = defaultMatch[1];
+  } else {
+    const simpleDefaultMatch = content.match(/defaultValue:\s*['"`]?([^,\s'"`]+)['"`]?/);
+    if (simpleDefaultMatch && simpleDefaultMatch[1] !== "{") {
+      result.defaultValue = simpleDefaultMatch[1];
+    }
+  }
+  return result;
+}
+function parseStories(content, componentName, warnings, constDeclarations) {
+  const stories = [];
+  const storyNames = /* @__PURE__ */ new Set();
+  const csf3Pattern = /export\s+const\s+(\w+)(?::\s*\w+)?\s*=\s*\{([^;]*(?:\{[^}]*\}[^;]*)*)\}/g;
+  let match;
+  while ((match = csf3Pattern.exec(content)) !== null) {
+    const storyName = match[1];
+    const storyContent = match[2];
+    if (storyName === "default" || storyName === "meta") {
+      continue;
+    }
+    if (storyContent.includes("typeof")) {
+      continue;
+    }
+    const story = parseStoryContent2(storyName, storyContent, componentName, warnings, constDeclarations);
+    if (story) {
+      stories.push(story);
+      storyNames.add(storyName);
+    }
+  }
+  const csf2Pattern = /export\s+const\s+(\w+)\s*=\s*(\w+)\.bind\s*\(\s*\{\s*\}\s*\)/g;
+  while ((match = csf2Pattern.exec(content)) !== null) {
+    const storyName = match[1];
+    const templateName = match[2];
+    if (storyNames.has(storyName)) {
+      continue;
+    }
+    if (storyName === "default" || storyName === "meta") {
+      continue;
+    }
+    const argsContent = extractArgsContent(content, storyName);
+    const story = {
+      name: storyName,
+      args: argsContent ? parseArgs(argsContent, constDeclarations) : {},
+      hasCustomRender: isCustomTemplate(content, templateName)
+    };
+    const descPattern = new RegExp(
+      `${storyName}\\.parameters\\s*=\\s*\\{[^}]*docs:\\s*\\{[^}]*description:\\s*\\{[^}]*story:\\s*['"\`]([^'"\`]+)['"\`]`
+    );
+    const descMatch = content.match(descPattern);
+    if (descMatch) {
+      story.description = descMatch[1];
+    }
+    stories.push(story);
+    storyNames.add(storyName);
+  }
+  return stories;
+}
+function extractArgsContent(content, storyName) {
+  const argsAssignPattern = new RegExp(`${storyName}\\.args\\s*=\\s*\\{`);
+  const argsMatch = content.match(argsAssignPattern);
+  if (!argsMatch || argsMatch.index === void 0) {
+    return null;
+  }
+  const startPos = argsMatch.index + argsMatch[0].length - 1;
+  const closingIndex = findMatchingBraceInContent(content, startPos, "{", "}");
+  if (closingIndex === -1) {
+    return null;
+  }
+  return content.slice(startPos + 1, closingIndex);
+}
+function findMatchingBraceInContent(content, startIndex, openChar, closeChar) {
+  let depth = 0;
+  let inString = null;
+  for (let i = startIndex; i < content.length; i++) {
+    const char = content[i];
+    const prevChar = i > 0 ? content[i - 1] : "";
+    if ((char === '"' || char === "'" || char === "`") && prevChar !== "\\") {
+      if (inString === char) {
+        inString = null;
+      } else if (inString === null) {
+        inString = char;
+      }
+    }
+    if (inString === null) {
+      if (char === openChar) {
+        depth++;
+      } else if (char === closeChar) {
+        depth--;
+        if (depth === 0) {
+          return i;
+        }
+      }
+    }
+  }
+  return -1;
+}
+function isCustomTemplate(content, templateName) {
+  const templatePattern = new RegExp(
+    `const\\s+${templateName}[^=]*=\\s*\\([^)]*\\)\\s*=>\\s*([\\s\\S]*?)(?=\\n(?:export|const\\s+\\w+\\s*=)|$)`,
+    "m"
+  );
+  const match = content.match(templatePattern);
+  if (!match) {
+    return false;
+  }
+  const templateBody = match[1].trim();
+  const simplePatterns = [
+    /^<\w+\s+\{\.\.\.args\}\s*\/?>/,
+    // <Comp {...args} /> or <Comp {...args}>
+    /^\(\s*<\w+\s+\{\.\.\.args\}\s*\/?>\s*\)/
+    // (<Comp {...args} />)
+  ];
+  for (const pattern of simplePatterns) {
+    if (pattern.test(templateBody)) {
+      return false;
+    }
+  }
+  const customIndicators = [
+    "useState",
+    "useEffect",
+    "useRef",
+    "useCallback",
+    "useMemo",
+    "useContext",
+    "return ("
+    // Multi-line return with logic
+  ];
+  for (const indicator of customIndicators) {
+    if (templateBody.includes(indicator)) {
+      return true;
+    }
+  }
+  const bodyWithoutFirstLine = templateBody.split("\n").slice(1).join("\n");
+  if (/const\s+\w+\s*=/.test(bodyWithoutFirstLine)) {
+    return true;
+  }
+  if (templateBody.includes("{...args}") && !templateBody.includes("return")) {
+    return false;
+  }
+  return false;
+}
+function parseStoryContent2(name, content, componentName, warnings, constDeclarations) {
+  const result = {
+    name,
+    args: {}
+  };
+  const argsMatch = content.match(/args:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/);
+  if (argsMatch) {
+    result.args = parseArgs(argsMatch[1], constDeclarations);
+  }
+  if (content.includes("render:") || content.includes("render(")) {
+    result.hasCustomRender = true;
+  }
+  const descMatch = content.match(/parameters:\s*\{[^}]*docs:\s*\{[^}]*description:\s*\{[^}]*story:\s*['"`]([^'"`]+)['"`]/);
+  if (descMatch) {
+    result.description = descMatch[1];
+  }
+  return result;
+}
+function parseArgs(content, constDeclarations) {
+  const args = {};
+  const pairs = splitAtTopLevelCommas(content);
+  for (const pair of pairs) {
+    const trimmed = pair.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("...")) {
+      const spreadValue = trimmed.slice(3).trim();
+      if (constDeclarations && /^\w+$/.test(spreadValue)) {
+        const resolved = constDeclarations.get(spreadValue);
+        if (resolved) {
+          for (const [key, value] of Object.entries(resolved)) {
+            if (!(key in args)) {
+              args[key] = value;
+            }
+          }
+          continue;
+        }
+      }
+      args["__SPREAD__"] = `__REF__${spreadValue}`;
+      continue;
+    }
+    if (/^\w+$/.test(trimmed)) {
+      args[trimmed] = `__REF__${trimmed}`;
+      continue;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex > 0) {
+      const key = trimmed.slice(0, colonIndex).trim();
+      const valueStr = trimmed.slice(colonIndex + 1).trim();
+      if (/^\w+$/.test(key)) {
+        args[key] = parseArgValue(valueStr, constDeclarations);
+      }
+    }
+  }
+  return args;
+}
+function splitAtTopLevelCommas(content) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  let inString = null;
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
+    const prevChar = i > 0 ? content[i - 1] : "";
+    if ((char === '"' || char === "'" || char === "`") && prevChar !== "\\") {
+      if (inString === char) {
+        inString = null;
+      } else if (inString === null) {
+        inString = char;
+      }
+    }
+    if (inString === null) {
+      if (char === "{" || char === "[" || char === "(") {
+        depth++;
+      } else if (char === "}" || char === "]" || char === ")") {
+        depth--;
+      } else if (char === "," && depth === 0) {
+        parts.push(current);
+        current = "";
+        continue;
+      }
+    }
+    current += char;
+  }
+  if (current.trim()) {
+    parts.push(current);
+  }
+  return parts;
+}
+function resolveEscapeSequences(str) {
+  let result = "";
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] === "\\" && i + 1 < str.length) {
+      const next = str[i + 1];
+      switch (next) {
+        case "n":
+          result += "\n";
+          i += 2;
+          break;
+        case "t":
+          result += "	";
+          i += 2;
+          break;
+        case "r":
+          result += "\r";
+          i += 2;
+          break;
+        case "\\":
+          result += "\\";
+          i += 2;
+          break;
+        case '"':
+          result += '"';
+          i += 2;
+          break;
+        case "'":
+          result += "'";
+          i += 2;
+          break;
+        case "`":
+          result += "`";
+          i += 2;
+          break;
+        default:
+          result += str[i];
+          i += 1;
+      }
+    } else {
+      result += str[i];
+      i += 1;
+    }
+  }
+  return result;
+}
+function tryParseStringConcatenation(value) {
+  if (!value.includes("+")) {
+    return null;
+  }
+  const parts = [];
+  let current = "";
+  let inString = null;
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    const prevChar = i > 0 ? value[i - 1] : "";
+    if ((char === '"' || char === "'" || char === "`") && prevChar !== "\\") {
+      if (inString === char) {
+        inString = null;
+      } else if (inString === null) {
+        inString = char;
+      }
+    }
+    if (char === "+" && inString === null) {
+      const trimmed = current.trim();
+      if (trimmed) {
+        parts.push(trimmed);
+      }
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  const lastTrimmed = current.trim();
+  if (lastTrimmed) {
+    parts.push(lastTrimmed);
+  }
+  if (parts.length < 2) {
+    return null;
+  }
+  const stringParts = [];
+  for (const part of parts) {
+    if (part.startsWith('"') && part.endsWith('"') || part.startsWith("'") && part.endsWith("'")) {
+      stringParts.push(resolveEscapeSequences(part.slice(1, -1)));
+    } else if (part.startsWith("`") && part.endsWith("`")) {
+      if (!part.includes("${")) {
+        stringParts.push(resolveEscapeSequences(part.slice(1, -1)));
+      } else {
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+  return stringParts.join("");
+}
+function parseArgValue(value, constDeclarations) {
+  value = value.trim();
+  value = value.replace(/,\s*$/, "");
+  if (!value) return void 0;
+  const concatenationResult = tryParseStringConcatenation(value);
+  if (concatenationResult !== null) {
+    return concatenationResult;
+  }
+  const asConstMatch = value.match(/^(['"`])(.+?)\1\s+as\s+const$/);
+  if (asConstMatch) {
+    return resolveEscapeSequences(asConstMatch[2]);
+  }
+  if (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"')) {
+    return resolveEscapeSequences(value.slice(1, -1));
+  }
+  if (value.startsWith("`") && value.endsWith("`")) {
+    return resolveEscapeSequences(value.slice(1, -1));
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+(\.\d+)?$/.test(value)) {
+    return parseFloat(value);
+  }
+  if (value === "null") return null;
+  if (value === "undefined") return void 0;
+  if (value.startsWith("{")) {
+    const closingIndex = findMatchingBrace(value, 0, "{", "}");
+    if (closingIndex !== -1) {
+      const inner = value.slice(1, closingIndex).trim();
+      if (inner) {
+        return parseArgs(inner, constDeclarations);
+      }
+      return {};
+    }
+  }
+  if (value.startsWith("[")) {
+    const closingIndex = findMatchingBrace(value, 0, "[", "]");
+    if (closingIndex !== -1) {
+      const inner = value.slice(1, closingIndex).trim();
+      if (!inner) return [];
+      const items = splitAtTopLevelCommas(inner);
+      return items.map((item) => parseArgValue(item.trim(), constDeclarations)).filter((v) => v !== void 0);
+    }
+  }
+  if (value.startsWith("<")) {
+    const trimmed = value.trimEnd();
+    if (trimmed.endsWith("/>") || trimmed.endsWith(">")) {
+      return `__JSX__`;
+    }
+  }
+  if (value.includes("(") || value.includes("=>")) {
+    return `__EXPR__`;
+  }
+  if (/\s+as\s+[A-Z]/.test(value)) {
+    return `__EXPR__`;
+  }
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(value)) {
+    if (constDeclarations) {
+      const resolved = constDeclarations.get(value);
+      if (resolved !== void 0) {
+        return resolved;
+      }
+    }
+    return `__REF__${value}`;
+  }
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*(\??\.[a-zA-Z_$][a-zA-Z0-9_$]*)+$/.test(value)) {
+    if (constDeclarations) {
+      const parts = value.replace(/\?/g, "").split(".");
+      const baseVar = parts[0];
+      const resolved = constDeclarations.get(baseVar);
+      if (resolved !== void 0) {
+        let current = resolved;
+        for (let i = 1; i < parts.length && current !== void 0; i++) {
+          if (typeof current === "object" && current !== null) {
+            current = current[parts[i]];
+          } else {
+            current = void 0;
+          }
+        }
+        if (current !== void 0) {
+          return current;
+        }
+      }
+    }
+    return `__REF__${value}`;
+  }
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*(\??\.[a-zA-Z_$][a-zA-Z0-9_$]*)*\[\d+\]!?(\??\.[a-zA-Z_$][a-zA-Z0-9_$]*)*$/.test(value)) {
+    return `__REF__${value}`;
+  }
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*!$/.test(value)) {
+    return `__REF__${value}`;
+  }
+  return value;
+}
+function findMatchingBrace(content, startIndex, openChar, closeChar) {
+  let depth = 0;
+  let inString = null;
+  for (let i = startIndex; i < content.length; i++) {
+    const char = content[i];
+    const prevChar = i > 0 ? content[i - 1] : "";
+    if ((char === '"' || char === "'" || char === "`") && prevChar !== "\\") {
+      if (inString === char) {
+        inString = null;
+      } else if (inString === null) {
+        inString = char;
+      }
+    }
+    if (inString === null) {
+      if (char === openChar) {
+        depth++;
+      } else if (char === closeChar) {
+        depth--;
+        if (depth === 0) {
+          return i;
+        }
+      }
+    }
+  }
+  return -1;
+}
+function storyNameToTitle(name) {
+  return name.replace(/([A-Z])/g, " $1").trim().replace(/\s+/g, " ");
+}
+function extractCategory(title) {
+  const segments = title.split("/");
+  if (segments.length >= 2) {
+    const category = segments[segments.length - 2];
+    return category.toLowerCase();
+  }
+  return "components";
+}
+
+// src/migrate/converter.ts
+function sanitizeComponentName(name) {
+  return name.split(/[\s-_]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+function convertToSegment(parsed) {
+  const warnings = [...parsed.warnings];
+  const todos = [];
+  const category = extractCategory(parsed.meta.title);
+  const componentName = sanitizeComponentName(parsed.meta.componentName);
+  if (!parsed.meta.componentImport) {
+    warnings.push(`No importable component found - story may define component locally`);
+    const outputFile2 = parsed.filePath.replace(/\.stories\.(tsx?|jsx?|mdx)$/, ".segment.tsx");
+    return {
+      sourceFile: parsed.filePath,
+      outputFile: outputFile2,
+      code: "",
+      componentName,
+      category,
+      variantCount: 0,
+      propCount: 0,
+      confidence: 0,
+      todos: [],
+      warnings,
+      success: false
+    };
+  }
+  const props = convertArgTypesToProps(parsed.argTypes);
+  const variants = convertStoriesToVariants(parsed, componentName);
+  todos.push("Add usage.when - scenarios where this component is appropriate");
+  todos.push("Add usage.whenNot - scenarios where alternatives should be used");
+  todos.push("Add usage.guidelines - best practices");
+  todos.push("Add relations - related components");
+  if (Object.keys(props).length > 0) {
+    const propsWithoutConstraints = Object.entries(props).filter(([, p]) => !p.constraints?.length).map(([name]) => name);
+    if (propsWithoutConstraints.length > 0) {
+      todos.push(`Add constraints for props: ${propsWithoutConstraints.slice(0, 3).join(", ")}${propsWithoutConstraints.length > 3 ? "..." : ""}`);
+    }
+  }
+  const skippedVariants = variants.filter((v) => v.needsManualReview && v.skipReason).map((v) => ({ name: v.name, reason: v.skipReason }));
+  const code = generateSegmentCode({
+    componentName,
+    componentImport: parsed.meta.componentImport,
+    description: parsed.meta.description,
+    category,
+    tags: parsed.meta.tags,
+    props,
+    variants,
+    todos,
+    generated: {
+      source: "storybook",
+      sourceFile: parsed.filePath,
+      confidence: parsed.confidence,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      skippedVariants: skippedVariants.length > 0 ? skippedVariants : void 0
+    }
+  });
+  const outputFile = parsed.filePath.replace(/\.stories\.(tsx?|jsx?|mdx)$/, ".segment.tsx");
+  return {
+    sourceFile: parsed.filePath,
+    outputFile,
+    code,
+    componentName,
+    category,
+    variantCount: variants.length,
+    propCount: Object.keys(props).length,
+    confidence: parsed.confidence,
+    todos,
+    warnings,
+    success: true
+  };
+}
+function convertArgTypesToProps(argTypes) {
+  const props = {};
+  for (const [name, argType] of Object.entries(argTypes)) {
+    props[name] = convertArgType(name, argType);
+  }
+  return props;
+}
+function convertArgType(name, argType) {
+  const prop = {
+    type: inferPropType(argType)
+  };
+  if (argType.description) {
+    prop.description = argType.description;
+  }
+  if (argType.defaultValue !== void 0) {
+    prop.default = argType.defaultValue;
+  }
+  if (argType.required) {
+    prop.required = true;
+  }
+  if (argType.options && argType.options.length > 0) {
+    prop.type = "enum";
+    prop.values = argType.options;
+  }
+  return prop;
+}
+function inferPropType(argType) {
+  if (argType.type) {
+    const typeMap = {
+      string: "string",
+      number: "number",
+      boolean: "boolean",
+      object: "object",
+      array: "array",
+      function: "function"
+    };
+    return typeMap[argType.type.toLowerCase()] ?? "custom";
+  }
+  if (argType.control) {
+    const controlMap = {
+      text: "string",
+      number: "number",
+      boolean: "boolean",
+      select: "enum",
+      radio: "enum",
+      "inline-radio": "enum",
+      check: "boolean",
+      "inline-check": "boolean",
+      range: "number",
+      object: "object",
+      array: "array",
+      date: "string",
+      color: "string"
+    };
+    return controlMap[argType.control] ?? "custom";
+  }
+  if (argType.options && argType.options.length > 0) {
+    return "enum";
+  }
+  return "custom";
+}
+function convertStoriesToVariants(parsed, componentName) {
+  return parsed.stories.map((story) => {
+    const hasCustomRender = story.hasCustomRender === true;
+    const unrenderableReason = getUnrenderableReason(story.args);
+    const needsManualReview = hasCustomRender || unrenderableReason !== null;
+    let skipReason;
+    if (hasCustomRender) {
+      skipReason = "uses custom render function";
+    } else if (unrenderableReason) {
+      skipReason = unrenderableReason;
+    }
+    const renderCode = hasCustomRender ? `<${componentName} />` : generateRenderCode(componentName, story.args);
+    const description = story.description ?? `${storyNameToTitle(story.name)} variant`;
+    return {
+      name: storyNameToTitle(story.name),
+      description,
+      renderCode,
+      needsManualReview,
+      skipReason
+    };
+  });
+}
+function getUnrenderableReason(args, path = "") {
+  for (const [key, value] of Object.entries(args)) {
+    const currentPath = path ? `${path}.${key}` : key;
+    if (typeof value === "string") {
+      if (value === "__JSX__") {
+        return `JSX element in prop "${currentPath}"`;
+      }
+      if (value === "__EXPR__") {
+        return `expression in prop "${currentPath}"`;
+      }
+      if (value.startsWith("__REF__")) {
+        const ref = value.slice(7);
+        return `variable reference "${ref}" in prop "${currentPath}"`;
+      }
+      if (value === "__SPREAD__" || key === "__SPREAD__") {
+        return `spread syntax in args`;
+      }
+    }
+    if (typeof value === "object" && value !== null) {
+      const nestedReason = getUnrenderableReason(value, currentPath);
+      if (nestedReason) {
+        return nestedReason;
+      }
+    }
+  }
+  return null;
+}
+function generateRenderCode(componentName, args) {
+  const entries = Object.entries(args);
+  if (entries.length === 0) {
+    return `<${componentName} />`;
+  }
+  const children = args.children;
+  const otherArgs = Object.entries(args).filter(([k]) => k !== "children");
+  const propsString = otherArgs.map(([key, value]) => formatPropValue(key, value)).filter(Boolean).join(" ");
+  if (children !== void 0) {
+    const childrenStr = formatChildrenValue(children);
+    return propsString ? `<${componentName} ${propsString}>${childrenStr}</${componentName}>` : `<${componentName}>${childrenStr}</${componentName}>`;
+  }
+  return propsString ? `<${componentName} ${propsString} />` : `<${componentName} />`;
+}
+function formatChildrenValue(value) {
+  if (typeof value === "string") {
+    if (value === "__JSX__") return "{null /* JSX children */}";
+    if (value === "__EXPR__") return "{null /* expression */}";
+    if (value.startsWith("__REF__")) return `{${value.slice(7)}}`;
+    return value;
+  }
+  return String(value);
+}
+function formatPropValue(key, value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    if (value === "__JSX__") {
+      return `${key}={undefined /* JSX */}`;
+    }
+    if (value === "__EXPR__") {
+      return `${key}={undefined /* expression */}`;
+    }
+    if (value.startsWith("__REF__")) {
+      return `${key}={${value.slice(7)}}`;
+    }
+    if (value.includes('"') || value.includes("\\") || value.includes("\n")) {
+      return `${key}={"${escapeString(value)}"}`;
+    }
+    return `${key}="${value}"`;
+  }
+  if (typeof value === "boolean") {
+    return value ? key : `${key}={false}`;
+  }
+  if (typeof value === "number") {
+    return `${key}={${value}}`;
+  }
+  if (Array.isArray(value)) {
+    const formatted = formatArrayValue(value);
+    return `${key}={${formatted}}`;
+  }
+  if (typeof value === "object" && value !== null) {
+    const formatted = formatObjectValue(value);
+    return `${key}={${formatted}}`;
+  }
+  return `${key}={${JSON.stringify(value)}}`;
+}
+function formatObjectValue(obj) {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return "{}";
+  const props = entries.map(([k, v]) => {
+    const formatted = formatValueForObject(v);
+    return `${k}: ${formatted}`;
+  }).join(", ");
+  return `{ ${props} }`;
+}
+function formatArrayValue(arr) {
+  if (arr.length === 0) return "[]";
+  const items = arr.map((item) => formatValueForObject(item));
+  return `[${items.join(", ")}]`;
+}
+function formatValueForObject(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "string") {
+    if (value === "__JSX__") return "undefined /* JSX */";
+    if (value === "__EXPR__") return "undefined /* expression */";
+    if (value.startsWith("__REF__")) return value.slice(7);
+    return `"${escapeString(value)}"`;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return formatArrayValue(value);
+  }
+  if (typeof value === "object") {
+    return formatObjectValue(value);
+  }
+  return JSON.stringify(value);
+}
+function generateSegmentCode(options) {
+  const {
+    componentName,
+    componentImport,
+    description,
+    category,
+    tags,
+    props,
+    variants,
+    todos,
+    generated
+  } = options;
+  const propsCode = formatPropsCode(props);
+  const variantsCode = formatVariantsCode(componentName, variants);
+  const tagsCode = tags && tags.length > 0 ? `tags: [${tags.map((t) => `"${t}"`).join(", ")}],` : "";
+  const todosComments = todos.length > 0 ? todos.map((t) => `      // TODO: ${t}`).join("\n") + "\n" : "";
+  let generatedCode = "";
+  if (generated) {
+    const skippedCode = generated.skippedVariants && generated.skippedVariants.length > 0 ? `
+    skippedVariants: [
+${generated.skippedVariants.map((sv) => `      { name: "${escapeString(sv.name)}", reason: "${escapeString(sv.reason)}" },`).join("\n")}
+    ],` : "";
+    generatedCode = `
+  _generated: {
+    source: "${generated.source}",
+    sourceFile: "${escapeString(generated.sourceFile)}",
+    confidence: ${generated.confidence.toFixed(2)},
+    timestamp: "${generated.timestamp}",${skippedCode}
+  },
+`;
+  }
+  return `import { defineSegment } from "@fragments/core";
+import { ${componentName} } from "${componentImport}";
+
+export default defineSegment({
+  component: ${componentName},
+
+  meta: {
+    name: "${componentName}",
+    description: "${escapeString(description ?? `${componentName} component`)}",
+    category: "${category}",
+    ${tagsCode}
+    // status: undefined, // TODO: Set to stable/beta/deprecated/experimental
+  },
+
+  usage: {
+    // TODO: Add specific use cases - when should developers use this component?
+    when: [
+${todosComments}    ],
+    // TODO: Add anti-patterns - when should developers NOT use this component?
+    whenNot: [],
+  },
+
+${propsCode}
+
+  relations: [
+    // TODO: Add related components
+  ],
+
+${variantsCode}
+${generatedCode}});
+`;
+}
+function formatPropsCode(props) {
+  if (Object.keys(props).length === 0) {
+    return "  props: {},";
+  }
+  const entries = Object.entries(props).map(([name, prop]) => {
+    const lines = [];
+    lines.push(`    ${name}: {`);
+    lines.push(`      type: "${prop.type}",`);
+    if (prop.values && prop.values.length > 0) {
+      lines.push(`      values: [${prop.values.map((v) => `"${v}"`).join(", ")}],`);
+    }
+    if (prop.default !== void 0) {
+      const defaultVal = typeof prop.default === "string" ? `"${prop.default}"` : String(prop.default);
+      lines.push(`      default: ${defaultVal},`);
+    }
+    if (prop.required) {
+      lines.push(`      required: true,`);
+    }
+    if (prop.description) {
+      lines.push(`      description: "${escapeString(prop.description)}",`);
+    }
+    lines.push(`    },`);
+    return lines.join("\n");
+  });
+  return `  props: {
+${entries.join("\n")}
+  },`;
+}
+function formatVariantsCode(componentName, variants) {
+  const renderableVariants = variants.filter((v) => !v.needsManualReview);
+  if (renderableVariants.length === 0) {
+    return "  variants: [],";
+  }
+  const entries = renderableVariants.map((variant) => {
+    return `    {
+      name: "${variant.name}",
+      description: "${escapeString(variant.description)}",
+      render: () => ${variant.renderCode},
+    },`;
+  });
+  return `  variants: [
+${entries.join("\n")}
+  ],`;
+}
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+
+// src/migrate/detect.ts
+import { existsSync } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+import fg3 from "fast-glob";
+var CONFIG_FILES = [
+  ".storybook/main.ts",
+  ".storybook/main.mts",
+  ".storybook/main.js",
+  ".storybook/main.mjs",
+  ".storybook/main.cjs"
+];
+var DEFAULT_PATTERNS = [
+  "**/*.stories.@(ts|tsx|js|jsx|mdx)",
+  "**/*.story.@(ts|tsx|js|jsx|mdx)"
+];
+async function detectStorybookConfig(projectRoot) {
+  for (const configFile of CONFIG_FILES) {
+    const configPath = join3(projectRoot, configFile);
+    if (existsSync(configPath)) {
+      return parseStorybookConfig(configPath);
+    }
+  }
+  return null;
+}
+async function parseStorybookConfig(configPath) {
+  const errors = [];
+  let storyPatterns = [];
+  let framework;
+  let builder;
+  try {
+    const content = await readFile3(configPath, "utf-8");
+    const storiesMatch = content.match(
+      /stories:\s*\[([^\]]+)\]/s
+    );
+    if (storiesMatch) {
+      const storiesContent = storiesMatch[1];
+      const patterns = storiesContent.split(",").map((p) => p.trim()).map((p) => {
+        const cleaned = p.replace(/^['"`]|['"`]$/g, "").trim();
+        return cleaned;
+      }).filter((p) => p && !p.startsWith("//") && !p.startsWith("{"));
+      if (patterns.length > 0) {
+        storyPatterns = patterns;
+      }
+    }
+    const frameworkMatch = content.match(
+      /framework:\s*['"`]([^'"`]+)['"`]/
+    );
+    if (frameworkMatch) {
+      framework = frameworkMatch[1];
+    } else {
+      const frameworkNameMatch = content.match(
+        /framework:\s*\{[^}]*name:\s*['"`]([^'"`]+)['"`]/
+      );
+      if (frameworkNameMatch) {
+        framework = frameworkNameMatch[1];
+      }
+    }
+    const builderMatch = content.match(
+      /builder:\s*['"`]([^'"`]+)['"`]/
+    );
+    if (builderMatch) {
+      builder = builderMatch[1];
+    }
+  } catch (error) {
+    errors.push(
+      `Failed to parse config: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (storyPatterns.length === 0) {
+    storyPatterns = DEFAULT_PATTERNS;
+    errors.push("No story patterns found in config, using defaults");
+  }
+  return {
+    configPath,
+    storyPatterns,
+    framework,
+    builder,
+    valid: errors.length === 0 || storyPatterns.length > 0,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+async function discoverStoryFiles(projectRoot, patterns) {
+  if (!patterns || patterns.length === 0) {
+    const config = await detectStorybookConfig(projectRoot);
+    patterns = config?.storyPatterns ?? DEFAULT_PATTERNS;
+  }
+  const configDir = join3(projectRoot, ".storybook");
+  const resolvedPatterns = patterns.map((p) => {
+    if (p.startsWith("../")) {
+      return join3(configDir, p);
+    }
+    return join3(projectRoot, p);
+  });
+  const files = await fg3(resolvedPatterns, {
+    cwd: projectRoot,
+    absolute: true,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.storybook/**"
+    ]
+  });
+  return files.sort();
+}
+
+// src/setup.ts
+async function isSegmentsJsonStale(configDir, outFile) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const fg4 = await import("fast-glob");
+  const segmentsJsonPath = path.join(configDir, outFile);
+  try {
+    const segmentsJsonStat = await fs.stat(segmentsJsonPath);
+    const segmentFiles = await fg4.default(`**/*${BRAND.fileExtension}`, {
+      cwd: configDir,
+      ignore: ["**/node_modules/**"],
+      absolute: true
+    });
+    for (const file of segmentFiles) {
+      const stat3 = await fs.stat(file);
+      if (stat3.mtimeMs > segmentsJsonStat.mtimeMs) {
+        return { stale: true, missing: false };
+      }
+    }
+    return { stale: false, missing: false };
+  } catch {
+    return { stale: false, missing: true };
+  }
+}
+async function loadSegmentInfo(segmentFiles) {
+  const fs = await import("fs/promises");
+  const segments = [];
+  for (const file of segmentFiles) {
+    try {
+      const content = await fs.readFile(file.absolutePath, "utf-8");
+      const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
+      const hasFigma = /meta:\s*\{[^}]*figma:\s*['"]https?:/.test(content);
+      if (nameMatch) {
+        segments.push({
+          name: nameMatch[1],
+          filePath: file.absolutePath,
+          hasFigma
+        });
+      }
+    } catch {
+    }
+  }
+  return segments;
+}
+async function runSetup(options = {}) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const result = {
+    segmentFilesCreated: 0,
+    segmentsBuilt: 0,
+    figmaLinked: 0,
+    errors: []
+  };
+  const log = (msg) => {
+    if (!options.silent) console.log(msg);
+  };
+  try {
+    const { config, configDir } = await loadConfig(options.configPath);
+    log(pc6.dim("Checking for fragment files..."));
+    let segmentFiles = await discoverSegmentFiles(config, configDir);
+    if (segmentFiles.length === 0 && !options.skipStorybook) {
+      log(pc6.yellow("\n   No fragment files found"));
+      const sbConfig = await detectStorybookConfig(configDir);
+      if (sbConfig) {
+        log(pc6.dim(`   Found Storybook at ${sbConfig.configPath}`));
+        log(pc6.dim("   Converting stories to fragments...\n"));
+        const storyFiles = await discoverStoryFiles(configDir, sbConfig.storyPatterns);
+        if (storyFiles.length > 0) {
+          let converted = 0;
+          for (const storyFile of storyFiles) {
+            try {
+              const parsed = await parseStoryFile(storyFile);
+              const segmentResult = convertToSegment(parsed);
+              await fs.mkdir(path.dirname(segmentResult.outputFile), { recursive: true });
+              await fs.writeFile(segmentResult.outputFile, segmentResult.code);
+              converted++;
+            } catch {
+            }
+          }
+          result.segmentFilesCreated = converted;
+          log(pc6.green(`   Generated ${converted} fragment file(s)`));
+          segmentFiles = await discoverSegmentFiles(config, configDir);
+        }
+      } else {
+        log(pc6.dim("   No Storybook config found"));
+        log(pc6.dim(`   Run ${pc6.cyan(`${BRAND.cliCommand} add <ComponentName>`)} to create your first fragment`));
+      }
+    } else if (segmentFiles.length > 0) {
+      log(pc6.green(`   Found ${segmentFiles.length} fragment file(s)`));
+    }
+    if (segmentFiles.length > 0 && !options.skipBuild) {
+      const outFile = config.outFile || BRAND.outFile;
+      const { stale, missing } = await isSegmentsJsonStale(configDir, outFile);
+      if (missing || stale) {
+        const reason = missing ? "Building" : "Rebuilding";
+        log(pc6.dim(`
+${reason} ${BRAND.outFile}...`));
+        try {
+          const buildResult = await buildSegments(config, configDir);
+          result.segmentsBuilt = buildResult.segmentCount;
+          if (buildResult.errors.length > 0) {
+            for (const err of buildResult.errors) {
+              result.errors.push(`${err.file}: ${err.error}`);
+            }
+          }
+          log(pc6.green(`   Built ${buildResult.segmentCount} fragment(s)`));
+        } catch (error) {
+          result.errors.push(`Build failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+      } else {
+        log(pc6.dim(`
+   ${BRAND.outFile} is up to date`));
+      }
+    }
+    if (!options.skipFigma && config.figmaFile && process.env.FIGMA_ACCESS_TOKEN) {
+      const segments = await loadSegmentInfo(segmentFiles);
+      const linkedCount = segments.filter((s) => s.hasFigma).length;
+      if (linkedCount === 0 && segments.length > 0) {
+        log(pc6.dim("\n   Figma configured but no fragments linked"));
+        log(pc6.dim(`   Run ${pc6.cyan(`${BRAND.cliCommand} link figma --auto`)} to auto-link components`));
+      } else if (linkedCount > 0) {
+        log(pc6.dim(`
+   ${linkedCount}/${segments.length} fragment(s) linked to Figma`));
+      }
+    } else if (!options.skipFigma && config.figmaFile && !process.env.FIGMA_ACCESS_TOKEN) {
+      log(pc6.dim("\n   Figma file configured but FIGMA_ACCESS_TOKEN not set"));
+    }
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : "Unknown error");
+  }
+  return result;
+}
+
+// src/commands/dev.ts
+async function dev(options = {}) {
+  const {
+    port = 6006,
+    open = true,
+    skipSetup = false,
+    skipStorybook = false,
+    skipFigma = false,
+    skipBuild = false
+  } = options;
+  console.log(pc7.cyan(`
+${BRAND.name} Dev Server
+`));
+  if (!skipSetup) {
+    const setupResult = await runSetup({
+      skipStorybook,
+      skipFigma,
+      skipBuild
+    });
+    if (setupResult.errors.length > 0) {
+      console.log(pc7.yellow("\n   Setup completed with warnings:"));
+      for (const error of setupResult.errors) {
+        console.log(pc7.dim(`   ${error}`));
+      }
+    }
+  }
+  const { createDevServer } = await import("./viewer-YRF4SQE4.js");
+  console.log(pc7.dim("\nStarting dev server..."));
+  const parsedPort = typeof port === "string" ? parseInt(port, 10) : port;
+  try {
+    const server = await createDevServer({
+      port: parsedPort,
+      open,
+      projectRoot: process.cwd()
+    });
+    const address = server.httpServer?.address();
+    const actualPort = typeof address === "object" && address ? address.port : parsedPort;
+    console.log(pc7.green(`
+   Viewer running at http://localhost:${actualPort}/fragments/
+`));
+    console.log(pc7.dim("Press Ctrl+C to stop\n"));
+    return {
+      success: true,
+      port: typeof actualPort === "number" ? actualPort : parseInt(String(actualPort), 10)
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    if (errMsg.includes("EADDRINUSE") || errMsg.includes("address already in use")) {
+      console.error(pc7.red(`
+   Port ${parsedPort} is already in use.`));
+      console.error(pc7.dim(`   Try a different port: ${BRAND.cliCommand} dev --port ${parsedPort + 1}
+`));
+    } else if (errMsg.includes("EACCES")) {
+      console.error(pc7.red(`
+   Permission denied for port ${parsedPort}.`));
+      console.error(pc7.dim(`   Try a port above 1024: ${BRAND.cliCommand} dev --port 6006
+`));
+    } else {
+      console.error(pc7.red(`
+   Failed to start dev server: ${errMsg}
+`));
+    }
+    return { success: false };
+  }
+}
+
+// src/commands/compare.ts
+import pc8 from "picocolors";
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { resolve as resolve2, join as join4 } from "path";
+async function compare(component, options = {}) {
+  const {
+    variant,
+    figma: figmaUrl,
+    threshold = 1,
+    all = false,
+    output,
+    port = 6006
+  } = options;
+  if (!process.env.FIGMA_ACCESS_TOKEN) {
+    console.error(pc8.red("\nFIGMA_ACCESS_TOKEN environment variable required."));
+    console.log(pc8.dim("Generate at: https://www.figma.com/developers/api#access-tokens"));
+    console.log(pc8.dim("  export FIGMA_ACCESS_TOKEN=figd_xxx"));
+    process.exit(1);
+  }
+  const baseUrl = `http://localhost:${port}`;
+  console.log(pc8.cyan(`
+${BRAND.name} Design Verification
+`));
+  if (all) {
+    return compareAll(baseUrl, threshold, output);
+  }
+  let componentsToCompare = [];
+  if (component) {
+    componentsToCompare = [component];
+  } else {
+    componentsToCompare = await selectComponents(baseUrl);
+  }
+  if (componentsToCompare.length === 0) {
+    console.log(pc8.dim("\nNo components selected."));
+    return { success: true, passed: 0, failed: 0, skipped: 0 };
+  }
+  if (componentsToCompare.length === 1) {
+    console.log(pc8.dim(`Comparing ${componentsToCompare[0]} to Figma design...
+`));
+  } else {
+    console.log(pc8.dim(`Comparing ${componentsToCompare.length} components to Figma designs...
+`));
+  }
+  let passed = 0;
+  let failed = 0;
+  for (const comp of componentsToCompare) {
+    const response = await fetch(`${baseUrl}/segments/compare`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        component: comp,
+        variant,
+        figmaUrl,
+        threshold,
+        figmaToken: process.env.FIGMA_ACCESS_TOKEN
+      })
+    });
+    const result = await response.json();
+    if (result.error) {
+      failed++;
+      console.log(`${pc8.red("\u2717")} ${pc8.bold(comp)} - ${result.error}`);
+      continue;
+    }
+    if (result.match) {
+      passed++;
+      console.log(`${pc8.green("\u2713")} ${pc8.bold(comp)} ${pc8.dim(`${result.diffPercentage}%`)}`);
+    } else {
+      failed++;
+      console.log(`${pc8.red("\u2717")} ${pc8.bold(comp)} ${pc8.yellow(`${result.diffPercentage}%`)} ${pc8.dim(`(threshold: ${threshold}%)`)}`);
+    }
+    if (output && result.rendered && result.figma && result.diff) {
+      await saveImages(output, comp, result);
+    }
+  }
+  if (componentsToCompare.length > 1) {
+    console.log();
+    console.log(pc8.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`
+${pc8.green(`${passed} passed`)}, ${pc8.red(`${failed} failed`)}
+`);
+  } else {
+    console.log();
+  }
+  if (output && componentsToCompare.length > 0) {
+    console.log(pc8.dim(`Images saved to: ${output}/
+`));
+  }
+  return {
+    success: failed === 0,
+    passed,
+    failed,
+    skipped: 0
+  };
+}
+async function compareAll(baseUrl, threshold, output) {
+  console.log(pc8.dim("Comparing all components with Figma links...\n"));
+  const contextResp = await fetch(`${baseUrl}/segments/context?format=json`);
+  if (!contextResp.ok) {
+    throw new Error("Failed to fetch segments. Make sure dev server is running.");
+  }
+  const contextText = await contextResp.text();
+  let segments = [];
+  try {
+    const contextData = JSON.parse(contextText);
+    segments = contextData.components || [];
+  } catch {
+    segments = [];
+  }
+  if (segments.length === 0) {
+    console.log(pc8.yellow("No components found with Figma links."));
+    console.log(pc8.dim("Add figma field to your segment definitions:"));
+    console.log(pc8.dim('  meta: { figma: "https://figma.com/file/..." }'));
+    return { success: true, passed: 0, failed: 0, skipped: 0 };
+  }
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const seg of segments) {
+    if (!seg.figma) {
+      skipped++;
+      console.log(`${pc8.dim("\u23ED\uFE0F")}  ${pc8.dim(seg.name)} ${pc8.dim("(no figma link)")}`);
+      continue;
+    }
+    try {
+      const response = await fetch(`${baseUrl}/segments/compare`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          component: seg.name,
+          threshold,
+          figmaToken: process.env.FIGMA_ACCESS_TOKEN
+        })
+      });
+      const result = await response.json();
+      if (result.error) {
+        failed++;
+        console.log(`${pc8.red("\u2717")} ${pc8.bold(seg.name)} - ${result.error}`);
+      } else if (result.match) {
+        passed++;
+        console.log(`${pc8.green("\u2713")} ${pc8.bold(seg.name)} ${pc8.dim(`${result.diffPercentage}%`)}`);
+      } else {
+        failed++;
+        console.log(`${pc8.red("\u2717")} ${pc8.bold(seg.name)} ${pc8.yellow(`${result.diffPercentage}%`)} ${pc8.dim(`(threshold: ${threshold}%)`)}`);
+      }
+      if (output && result.rendered && result.figma && result.diff) {
+        await saveImages(output, seg.name, result);
+      }
+    } catch (error) {
+      failed++;
+      console.log(`${pc8.red("\u2717")} ${pc8.bold(seg.name)} - ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  console.log();
+  console.log(pc8.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(`
+${pc8.green(`${passed} passed`)}, ${pc8.red(`${failed} failed`)}, ${pc8.dim(`${skipped} skipped`)}
+`);
+  if (output) {
+    console.log(pc8.dim(`Images saved to: ${output}/
+`));
+  }
+  return {
+    success: failed === 0,
+    passed,
+    failed,
+    skipped
+  };
+}
+async function selectComponents(baseUrl) {
+  console.log(pc8.dim("Fetching components with Figma links...\n"));
+  const contextResp = await fetch(`${baseUrl}/segments/context?format=json`);
+  if (!contextResp.ok) {
+    throw new Error("Failed to fetch segments. Make sure dev server is running.");
+  }
+  const contextText = await contextResp.text();
+  let segments = [];
+  try {
+    const contextData = JSON.parse(contextText);
+    segments = (contextData.components || []).filter((s) => s.figma);
+  } catch {
+    segments = [];
+  }
+  if (segments.length === 0) {
+    console.log(pc8.yellow("No components found with Figma links."));
+    console.log(pc8.dim("Add figma field to your segment definitions:"));
+    console.log(pc8.dim('  meta: { figma: "https://figma.com/file/..." }'));
+    return [];
+  }
+  const { checkbox } = await import("@inquirer/prompts");
+  try {
+    const choices = segments.map((seg) => ({
+      name: seg.name,
+      value: seg.name,
+      checked: true
+    }));
+    return await checkbox({
+      message: "Select components to compare:",
+      choices,
+      pageSize: 15
+    });
+  } catch {
+    console.log(pc8.dim("\nNo changes made."));
+    return [];
+  }
+}
+async function saveImages(outputDir, component, result) {
+  const dir = resolve2(process.cwd(), outputDir);
+  await mkdir2(dir, { recursive: true });
+  const saveImage = async (data, filename) => {
+    const base64 = data.replace("data:image/png;base64,", "");
+    await writeFile2(join4(dir, filename), Buffer.from(base64, "base64"));
+  };
+  if (result.rendered) {
+    await saveImage(result.rendered, `${component}-rendered.png`);
+  }
+  if (result.figma) {
+    await saveImage(result.figma, `${component}-figma.png`);
+  }
+  if (result.diff) {
+    await saveImage(result.diff, `${component}-diff.png`);
+  }
+}
+
+// src/commands/verify.ts
+import pc10 from "picocolors";
+
+// src/shared/dev-server-client.ts
+var DevServerClient = class {
+  baseUrl;
+  timeout;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.timeout = options.timeout ?? 3e4;
+  }
+  /**
+   * Check if the dev server is reachable
+   */
+  async ping() {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(`${this.baseUrl}/segments/context?format=json`, {
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get all segments from the context endpoint
+   */
+  async getSegments() {
+    const response = await this.fetch("/segments/context?format=json");
+    const data = await response.json();
+    const components = data.components || {};
+    return Object.entries(components).map(([name, info]) => ({
+      name,
+      category: info.category || "components",
+      description: info.description,
+      status: info.status,
+      figma: info.figma
+    }));
+  }
+  /**
+   * Get compliance data for a component
+   */
+  async getCompliance(request) {
+    const response = await this.fetch("/segments/compliance", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(request)
+    });
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Get accessibility results for a component
+   */
+  async getA11y(component, variant) {
+    const response = await this.fetch("/fragments/a11y", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ component, variant })
+    });
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Internal fetch wrapper with error handling
+   */
+  async fetch(path, options) {
+    const url = `${this.baseUrl}${path}`;
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => "");
+        throw new DevServerError(
+          `Server returned ${response.status}: ${response.statusText}`,
+          response.status,
+          errorBody
+        );
+      }
+      return response;
+    } catch (error) {
+      if (error instanceof DevServerError) {
+        throw error;
+      }
+      const errMsg = error instanceof Error && error.cause ? String(error.cause.code || error.message) : error instanceof Error ? error.message : "Unknown error";
+      if (errMsg.includes("ECONNREFUSED") || errMsg.includes("fetch failed")) {
+        throw new DevServerConnectionError(
+          `Cannot connect to dev server at ${this.baseUrl}`,
+          this.baseUrl
+        );
+      }
+      throw error;
+    }
+  }
+};
+var DevServerError = class extends Error {
+  constructor(message, statusCode, body) {
+    super(message);
+    this.statusCode = statusCode;
+    this.body = body;
+    this.name = "DevServerError";
+  }
+};
+var DevServerConnectionError = class extends Error {
+  constructor(message, serverUrl) {
+    super(message);
+    this.serverUrl = serverUrl;
+    this.name = "DevServerConnectionError";
+  }
+};
+function createDevServerClient(port = 6006) {
+  return new DevServerClient({
+    baseUrl: `http://localhost:${port}`
+  });
+}
+
+// src/shared/command-wrapper.ts
+import pc9 from "picocolors";
+
+// src/commands/verify.ts
+async function verify(component, options = {}) {
+  const { config: configPath, ci = false, port = 6006 } = options;
+  const { config } = await loadConfig(configPath);
+  const minCompliance = options.minCompliance ?? config.ci?.minCompliance ?? 80;
+  const client = createDevServerClient(port);
+  const results = [];
+  let totalCompliance = 0;
+  let componentCount = 0;
+  if (!ci) {
+    console.log(pc10.cyan(`
+${BRAND.name} Compliance Verification
+`));
+    console.log(pc10.dim(`Minimum compliance: ${minCompliance}%
+`));
+  }
+  const isReachable = await client.ping();
+  if (!isReachable) {
+    throw new DevServerConnectionError(
+      `Cannot connect to dev server at http://localhost:${port}`,
+      `http://localhost:${port}`
+    );
+  }
+  let segments = await client.getSegments();
+  if (component) {
+    segments = segments.filter(
+      (s) => s.name.toLowerCase() === component.toLowerCase()
+    );
+    if (segments.length === 0) {
+      const error = { error: `Component "${component}" not found` };
+      if (ci) {
+        console.log(JSON.stringify(error));
+      } else {
+        console.log(pc10.red(error.error));
+      }
+      process.exit(1);
+    }
+  }
+  for (const seg of segments) {
+    try {
+      const complianceResult = await client.getCompliance({
+        component: seg.name
+      });
+      const passed = complianceResult.compliance >= minCompliance;
+      results.push({
+        component: seg.name,
+        compliance: complianceResult.compliance,
+        passed,
+        violations: complianceResult.violations,
+        totalProperties: complianceResult.totalProperties,
+        hardcoded: complianceResult.hardcoded,
+        usingTokens: complianceResult.usingTokens
+      });
+      totalCompliance += complianceResult.compliance;
+      componentCount++;
+      if (!ci) {
+        const icon = passed ? pc10.green("\u2713") : pc10.red("\u2717");
+        const complianceStr = passed ? pc10.green(`${complianceResult.compliance}%`) : pc10.red(`${complianceResult.compliance}%`);
+        console.log(`  ${icon} ${seg.name} ${complianceStr}`);
+        if (!passed && complianceResult.violations.length > 0) {
+          const violationsToShow = complianceResult.violations.slice(0, 3);
+          for (const v of violationsToShow) {
+            console.log(pc10.dim(`     - ${v.property}: ${v.issue}`));
+            if (v.suggestion) {
+              console.log(pc10.dim(`       ${pc10.cyan("\u2192")} ${v.suggestion}`));
+            }
+          }
+          if (complianceResult.violations.length > 3) {
+            console.log(pc10.dim(`     ... and ${complianceResult.violations.length - 3} more`));
+          }
+        }
+      }
+    } catch (error) {
+      results.push({
+        component: seg.name,
+        compliance: 0,
+        passed: false,
+        violations: [{
+          property: "unknown",
+          issue: error instanceof Error ? error.message : "Unknown error",
+          severity: "error"
+        }],
+        totalProperties: 0,
+        hardcoded: 0,
+        usingTokens: 0
+      });
+      if (!ci) {
+        console.log(`  ${pc10.red("\u2717")} ${seg.name} ${pc10.red("error")}`);
+      }
+    }
+  }
+  const averageCompliance = componentCount > 0 ? totalCompliance / componentCount : 100;
+  const allPassed = results.every((r) => r.passed);
+  const summary = {
+    passed: allPassed,
+    compliance: Math.round(averageCompliance * 100) / 100,
+    threshold: minCompliance,
+    totalComponents: componentCount,
+    passedComponents: results.filter((r) => r.passed).length,
+    failedComponents: results.filter((r) => !r.passed).length,
+    results,
+    violations: results.flatMap((r) => r.violations.map((v) => ({
+      component: r.component,
+      ...v
+    })))
+  };
+  if (ci) {
+    console.log(JSON.stringify(summary, null, 2));
+  } else {
+    console.log();
+    if (allPassed) {
+      console.log(pc10.green(`\u2713 All ${componentCount} component(s) meet ${minCompliance}% compliance threshold`));
+    } else {
+      const failedCount = results.filter((r) => !r.passed).length;
+      console.log(pc10.red(`\u2717 ${failedCount} component(s) below ${minCompliance}% compliance threshold`));
+    }
+    console.log(pc10.dim(`  Average compliance: ${summary.compliance}%
+`));
+  }
+  return summary;
+}
+
+// src/commands/audit.ts
+import pc11 from "picocolors";
+async function audit(options = {}) {
+  const { config: configPath, json = false, sort = "compliance", port = 6006 } = options;
+  await loadConfig(configPath);
+  const client = createDevServerClient(port);
+  const audits = [];
+  if (!json) {
+    console.log(pc11.cyan(`
+${BRAND.name} Design System Audit
+`));
+  }
+  const isReachable = await client.ping();
+  if (!isReachable) {
+    throw new DevServerConnectionError(
+      `Cannot connect to dev server at http://localhost:${port}`,
+      `http://localhost:${port}`
+    );
+  }
+  const segments = await client.getSegments();
+  if (segments.length === 0) {
+    if (json) {
+      console.log(JSON.stringify({ error: "No fragments found", components: [] }));
+    } else {
+      console.log(pc11.yellow("No fragments found.\n"));
+    }
+    return {
+      totalComponents: 0,
+      averageCompliance: 100,
+      worstOffenders: [],
+      components: [],
+      stats: {
+        totalHardcoded: 0,
+        totalTokenMismatches: 0,
+        totalProperties: 0
+      }
+    };
+  }
+  if (!json) {
+    console.log(pc11.dim(`Auditing ${segments.length} component(s)...
+`));
+  }
+  for (const seg of segments) {
+    try {
+      const complianceResult = await client.getCompliance({
+        component: seg.name
+      });
+      audits.push({
+        name: seg.name,
+        category: seg.category || "uncategorized",
+        compliance: complianceResult.compliance,
+        hardcoded: complianceResult.hardcoded,
+        tokenMismatches: complianceResult.violations.filter(
+          (v) => v.issue.includes("mismatch")
+        ).length,
+        totalProperties: complianceResult.totalProperties
+      });
+    } catch (error) {
+      audits.push({
+        name: seg.name,
+        category: seg.category || "uncategorized",
+        compliance: 0,
+        hardcoded: 0,
+        tokenMismatches: 0,
+        totalProperties: 0
+      });
+    }
+  }
+  audits.sort((a, b) => {
+    switch (sort) {
+      case "name":
+        return a.name.localeCompare(b.name);
+      case "hardcoded":
+        return b.hardcoded - a.hardcoded;
+      // Most hardcoded first
+      case "compliance":
+      default:
+        return a.compliance - b.compliance;
+    }
+  });
+  const summary = {
+    totalComponents: audits.length,
+    averageCompliance: audits.length > 0 ? Math.round(audits.reduce((sum, a) => sum + a.compliance, 0) / audits.length * 100) / 100 : 100,
+    worstOffenders: audits.slice(0, 5),
+    components: audits,
+    stats: {
+      totalHardcoded: audits.reduce((sum, a) => sum + a.hardcoded, 0),
+      totalTokenMismatches: audits.reduce((sum, a) => sum + a.tokenMismatches, 0),
+      totalProperties: audits.reduce((sum, a) => sum + a.totalProperties, 0)
+    }
+  };
+  if (json) {
+    console.log(JSON.stringify(summary, null, 2));
+  } else {
+    console.log(pc11.bold("Component".padEnd(30) + "Compliance".padEnd(12) + "Hardcoded".padEnd(12) + "Properties"));
+    console.log(pc11.dim("\u2500".repeat(66)));
+    for (const auditItem of audits) {
+      const complianceColor = auditItem.compliance >= 90 ? pc11.green : auditItem.compliance >= 70 ? pc11.yellow : pc11.red;
+      console.log(
+        auditItem.name.padEnd(30) + complianceColor(`${auditItem.compliance}%`.padEnd(12)) + String(auditItem.hardcoded).padEnd(12) + String(auditItem.totalProperties)
+      );
+    }
+    console.log(pc11.dim("\u2500".repeat(66)));
+    console.log();
+    console.log(pc11.bold("Summary:"));
+    console.log(`  Total components: ${audits.length}`);
+    console.log(`  Average compliance: ${summary.averageCompliance}%`);
+    console.log(`  Total hardcoded values: ${summary.stats.totalHardcoded}`);
+    console.log(`  Total properties checked: ${summary.stats.totalProperties}`);
+    if (audits.some((a) => a.compliance < 100)) {
+      console.log();
+      console.log(pc11.dim(`Run ${pc11.cyan(`${BRAND.cliCommand} verify <component>`)} for detailed compliance info.`));
+    }
+    console.log();
+  }
+  return summary;
+}
+
+// src/commands/a11y.ts
+import pc12 from "picocolors";
+async function a11y(options = {}) {
+  const { config: configPath, json = false, ci = false, component, port = 6006 } = options;
+  await loadConfig(configPath);
+  const client = createDevServerClient(port);
+  const componentResults = [];
+  if (!json) {
+    console.log(pc12.cyan(`
+${BRAND.name} Accessibility Report
+`));
+  }
+  const isReachable = await client.ping();
+  if (!isReachable) {
+    throw new DevServerConnectionError(
+      `Cannot connect to dev server at http://localhost:${port}`,
+      `http://localhost:${port}`
+    );
+  }
+  const segments = await client.getSegments();
+  if (segments.length === 0) {
+    if (json) {
+      console.log(JSON.stringify({ error: "No fragments found", components: [] }));
+    } else {
+      console.log(pc12.yellow("No fragments found.\n"));
+    }
+    return {
+      totalComponents: 0,
+      accessibleComponents: 0,
+      accessiblePercent: 100,
+      components: [],
+      totalViolations: 0,
+      totalCritical: 0,
+      totalSerious: 0,
+      totalModerate: 0,
+      totalMinor: 0,
+      passed: true
+    };
+  }
+  const componentsToCheck = component ? segments.filter((s) => s.name.toLowerCase() === component.toLowerCase()) : segments;
+  if (component && componentsToCheck.length === 0) {
+    const error = `Component '${component}' not found. Available: ${segments.map((s) => s.name).join(", ")}`;
+    if (json) {
+      console.log(JSON.stringify({ error }));
+    } else {
+      console.log(pc12.red(error));
+    }
+    throw new Error(error);
+  }
+  if (!json) {
+    console.log(pc12.dim(`Checking ${componentsToCheck.length} component(s) for accessibility issues...
+`));
+  }
+  for (const seg of componentsToCheck) {
+    try {
+      const a11yResult = await client.getA11y(seg.name);
+      let totalViolations2 = 0;
+      let totalCritical2 = 0;
+      let totalSerious2 = 0;
+      for (const result of a11yResult.results) {
+        totalViolations2 += result.summary.total;
+        totalCritical2 += result.summary.critical;
+        totalSerious2 += result.summary.serious;
+      }
+      let status = "PASS";
+      if (totalCritical2 > 0 || totalSerious2 > 0) {
+        status = "FAIL";
+      } else if (totalViolations2 > 0) {
+        status = "WARN";
+      }
+      componentResults.push({
+        component: seg.name,
+        results: a11yResult.results,
+        status,
+        totalViolations: totalViolations2,
+        totalCritical: totalCritical2,
+        totalSerious: totalSerious2
+      });
+    } catch (error) {
+      componentResults.push({
+        component: seg.name,
+        results: [],
+        status: "FAIL",
+        totalViolations: 0,
+        totalCritical: 0,
+        totalSerious: 0
+      });
+    }
+  }
+  const accessibleComponents = componentResults.filter((c) => c.status !== "FAIL").length;
+  const totalViolations = componentResults.reduce((sum, c) => sum + c.totalViolations, 0);
+  const totalCritical = componentResults.reduce((sum, c) => sum + c.totalCritical, 0);
+  const totalSerious = componentResults.reduce((sum, c) => sum + c.totalSerious, 0);
+  let totalModerate = 0;
+  let totalMinor = 0;
+  for (const comp of componentResults) {
+    for (const result of comp.results) {
+      totalModerate += result.summary.moderate;
+      totalMinor += result.summary.minor;
+    }
+  }
+  const summary = {
+    totalComponents: componentResults.length,
+    accessibleComponents,
+    accessiblePercent: componentResults.length > 0 ? Math.round(accessibleComponents / componentResults.length * 100) : 100,
+    components: componentResults,
+    totalViolations,
+    totalCritical,
+    totalSerious,
+    totalModerate,
+    totalMinor,
+    passed: totalCritical === 0 && totalSerious === 0
+  };
+  if (json) {
+    console.log(JSON.stringify(summary, null, 2));
+  } else {
+    console.log(pc12.bold(
+      "Component".padEnd(20) + "Variants".padEnd(10) + "Violations".padEnd(12) + "Critical".padEnd(10) + "Serious".padEnd(10) + "Status"
+    ));
+    console.log(pc12.dim("\u2500".repeat(72)));
+    for (const result of componentResults) {
+      const statusColor = result.status === "PASS" ? pc12.green : result.status === "WARN" ? pc12.yellow : pc12.red;
+      const variantCount = result.results.length || 1;
+      console.log(
+        result.component.padEnd(20) + String(variantCount).padEnd(10) + String(result.totalViolations).padEnd(12) + String(result.totalCritical).padEnd(10) + String(result.totalSerious).padEnd(10) + statusColor(result.status)
+      );
+    }
+    console.log(pc12.dim("\u2500".repeat(72)));
+    console.log();
+    console.log(pc12.bold("Summary:"));
+    console.log(`  ${accessibleComponents}/${componentResults.length} components accessible (${summary.accessiblePercent}%)`);
+    console.log(`  Total violations: ${totalViolations} (${totalCritical} critical, ${totalSerious} serious, ${totalModerate} moderate, ${totalMinor} minor)`);
+    if (!summary.passed) {
+      console.log();
+      console.log(pc12.red("\u2717 Accessibility check failed - critical/serious violations found"));
+    } else if (totalViolations > 0) {
+      console.log();
+      console.log(pc12.yellow("\u26A0 Minor/moderate violations found - consider fixing for better accessibility"));
+    } else {
+      console.log();
+      console.log(pc12.green("\u2713 All components pass accessibility checks"));
+    }
+    console.log();
+  }
+  if (ci && !summary.passed) {
+    throw new Error(`Accessibility check failed: ${totalCritical} critical, ${totalSerious} serious violations found`);
+  }
+  return summary;
+}
+
+// src/commands/storygen.ts
+import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { resolve as resolve3, join as join5, relative as relative3 } from "path";
+import pc13 from "picocolors";
+async function storygen(options = {}) {
+  const { config: configPath, output = ".storybook/generated", watch = false } = options;
+  const { config, configDir } = await loadConfig(configPath);
+  console.log(pc13.cyan(`
+${BRAND.name} Story Generator
+`));
+  const segmentFiles = await discoverSegmentFiles(config, configDir);
+  if (segmentFiles.length === 0) {
+    console.log(pc13.yellow("No segment files found.\n"));
+    return { success: true, generated: 0, outputDir: output };
+  }
+  const outputDir = resolve3(configDir, output);
+  await mkdir3(outputDir, { recursive: true });
+  let generated = 0;
+  const generateStory = async (file) => {
+    try {
+      const segment = await loadSegmentFile(file.absolutePath);
+      if (!segment) return false;
+      const storyContent = generateCSF3Story(segment, file.relativePath);
+      const storyName = `${segment.meta.name}.stories.tsx`;
+      const storyPath = join5(outputDir, storyName);
+      await writeFile3(storyPath, storyContent);
+      console.log(`${pc13.green("\u2713")} Generated ${storyName}`);
+      return true;
+    } catch (error) {
+      console.log(`${pc13.red("\u2717")} Failed: ${file.relativePath} - ${error instanceof Error ? error.message : error}`);
+      return false;
+    }
+  };
+  console.log(pc13.dim(`Generating stories to ${relative3(process.cwd(), outputDir)}/
+`));
+  for (const file of segmentFiles) {
+    if (await generateStory(file)) {
+      generated++;
+    }
+  }
+  console.log();
+  console.log(pc13.green(`\u2713 Generated ${generated} story file(s)
+`));
+  if (watch) {
+    console.log(pc13.dim("Watching for segment changes... (Ctrl+C to stop)\n"));
+    const chokidar = await import("chokidar");
+    const patterns = segmentFiles.map((f) => f.absolutePath);
+    const watcher = chokidar.watch(patterns, {
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 100 }
+    });
+    watcher.on("change", async (changedPath) => {
+      const file = segmentFiles.find((f) => f.absolutePath === changedPath);
+      if (file) {
+        console.log(pc13.dim(`
+Changed: ${relative3(process.cwd(), changedPath)}`));
+        await generateStory(file);
+      }
+    });
+    watcher.on("add", async (addedPath) => {
+      console.log(pc13.dim(`
+Added: ${relative3(process.cwd(), addedPath)}`));
+      const newFiles = await discoverSegmentFiles(config, configDir);
+      const file = newFiles.find((f) => f.absolutePath === addedPath);
+      if (file) {
+        segmentFiles.push(file);
+        await generateStory(file);
+      }
+    });
+    await new Promise(() => {
+    });
+  }
+  return { success: true, generated, outputDir };
+}
+function generateCSF3Story(segment, relativePath) {
+  const { meta, variants, props, usage } = segment;
+  const componentName = meta.name;
+  const argTypes = [];
+  if (props) {
+    for (const [propName, propDef] of Object.entries(props)) {
+      let controlType = "text";
+      let controlOptions = "";
+      if (propDef.type === "enum" && propDef.values) {
+        controlType = "select";
+        controlOptions = `,
+        options: ${JSON.stringify(propDef.values)}`;
+      } else if (propDef.type === "boolean") {
+        controlType = "boolean";
+      } else if (propDef.type === "number") {
+        controlType = "number";
+      }
+      argTypes.push(`    ${propName}: {
+      control: '${controlType}'${controlOptions},
+      description: ${JSON.stringify(propDef.description || "")},
+      ${propDef.default !== void 0 ? `defaultValue: ${JSON.stringify(propDef.default)},` : ""}
+    }`);
+    }
+  }
+  const storyExports = [];
+  for (const variant of variants) {
+    const storyName = variant.name.replace(/[^a-zA-Z0-9]/g, "");
+    storyExports.push(`
+export const ${storyName}: Story = {
+  name: ${JSON.stringify(variant.name)},
+  ${variant.description ? `parameters: { docs: { description: { story: ${JSON.stringify(variant.description)} } } },` : ""}
+};`);
+  }
+  const usageDoc = usage ? `When to use:
+${usage.when?.map((w) => `- ${w}`).join("\n") || ""}
+
+When not to use:
+${usage.whenNot?.map((w) => `- ${w}`).join("\n") || ""}` : "";
+  return `/**
+ * Auto-generated Storybook stories from ${relativePath}
+ *
+ * DO NOT EDIT - regenerate with: segments storygen
+ */
+
+import type { Meta, StoryObj } from '@storybook/react';
+import { ${componentName} } from '${relativePath.replace(/\.segment\.tsx$/, "/index.js")}';
+
+const meta: Meta<typeof ${componentName}> = {
+  title: '${meta.category ? `${meta.category.charAt(0).toUpperCase() + meta.category.slice(1)}/` : ""}${componentName}',
+  component: ${componentName},
+  tags: ['autodocs'],
+  parameters: {
+    docs: {
+      description: {
+        component: ${JSON.stringify(meta.description || "")},
+      },
+    },
+  },
+  argTypes: {
+${argTypes.join(",\n")}
+  },
+};
+
+export default meta;
+type Story = StoryObj<typeof meta>;
+${storyExports.join("\n")}
+`;
+}
+
+// src/commands/metrics.ts
+import pc14 from "picocolors";
+async function metrics(component, options = {}) {
+  const { config: configPath, days = 30, json = false } = options;
+  const { configDir } = await loadConfig(configPath);
+  const store = createMetricsStore(configDir);
+  console.log(pc14.cyan(`
+${BRAND.name} Compliance Metrics
+`));
+  const trend = await store.getTrend(component || "all", {
+    days,
+    groupBy: days > 14 ? "week" : "day"
+  });
+  if (json) {
+    console.log(JSON.stringify(trend, null, 2));
+    return { success: true, trend };
+  }
+  const title = component ? `Component: ${component}` : "System-wide";
+  console.log(pc14.bold(title));
+  console.log(pc14.dim(`Last ${days} days
+`));
+  if (trend.dataPoints.length === 0) {
+    console.log(pc14.yellow("No metrics data found.\n"));
+    console.log(pc14.dim("Metrics are recorded automatically when running verification commands."));
+    console.log(pc14.dim(`Try running: ${pc14.cyan(`${BRAND.cliCommand} verify --ci`)}
+`));
+    return { success: true, trend };
+  }
+  const sparkline = store.generateSparkline(trend.dataPoints);
+  console.log(pc14.bold("Trend: ") + sparkline);
+  console.log();
+  const trendColor = trend.trend === "improving" ? pc14.green : trend.trend === "declining" ? pc14.red : pc14.dim;
+  const trendIcon = trend.trend === "improving" ? "\u2191" : trend.trend === "declining" ? "\u2193" : "\u2192";
+  console.log(`  Average compliance: ${pc14.bold(`${trend.averageCompliance}%`)}`);
+  console.log(`  Direction: ${trendColor(`${trendIcon} ${trend.trend}`)}`);
+  console.log(`  Data points: ${trend.dataPoints.length}`);
+  console.log();
+  const recent = trend.dataPoints.slice(-5);
+  if (recent.length > 0) {
+    console.log(pc14.dim("Recent data:"));
+    for (const point of recent) {
+      const complianceColor = point.compliance >= 90 ? pc14.green : point.compliance >= 70 ? pc14.yellow : pc14.red;
+      console.log(`  ${pc14.dim(point.date)} ${complianceColor(`${point.compliance}%`)} ${pc14.dim(`(${point.violations} violations)`)}`);
+    }
+    console.log();
+  }
+  return { success: true, trend };
+}
+
+// src/commands/baseline.ts
+import { readdir as readdir3, rm as rm2 } from "fs/promises";
+import { join as join6, relative as relative4 } from "path";
+import pc15 from "picocolors";
+async function baseline(action, component, options = {}) {
+  const { config: configPath, variant, all = false, theme = "light", port = 6006 } = options;
+  const { config, configDir } = await loadConfig(configPath);
+  const storage = new StorageManager({
+    projectRoot: configDir,
+    viewport: config.screenshots?.viewport
+  });
+  await storage.initialize();
+  console.log(pc15.cyan(`
+${BRAND.name} Baseline Manager
+`));
+  const baseUrl = `http://localhost:${port}`;
+  switch (action) {
+    case "update":
+      return updateBaseline(component, options, config, configDir, baseUrl);
+    case "list":
+      return listBaselines(configDir);
+    case "delete":
+      return deleteBaseline(component, options, configDir);
+    default:
+      console.log(pc15.red(`Unknown action: ${action}`));
+      console.log(pc15.dim("Available actions: update, list, delete\n"));
+      process.exit(1);
+  }
+}
+async function updateBaseline(component, options, config, configDir, baseUrl) {
+  const { variant, all = false, theme = "light" } = options;
+  if (!component && !all) {
+    const { select } = await import("@inquirer/prompts");
+    const contextResp = await fetch(`${baseUrl}/fragments/context?format=json`);
+    if (!contextResp.ok) {
+      throw new Error("Failed to fetch fragments. Make sure dev server is running.");
+    }
+    const contextData = JSON.parse(await contextResp.text());
+    const segments = contextData.components || [];
+    if (segments.length === 0) {
+      console.log(pc15.yellow("No components found.\n"));
+      return { success: true, action: "update", count: 0 };
+    }
+    component = await select({
+      message: "Select component to update:",
+      choices: segments.map((s) => ({
+        name: s.name,
+        value: s.name
+      }))
+    });
+  }
+  if (all) {
+    console.log(pc15.dim("Updating all baselines...\n"));
+    await runScreenshotCommand(config, configDir, {
+      theme
+    });
+    console.log(pc15.green("\n\u2713 All baselines updated\n"));
+  } else if (component) {
+    console.log(pc15.dim(`Updating baselines for ${component}...
+`));
+    await runScreenshotCommand(config, configDir, {
+      component,
+      variant,
+      theme
+    });
+    console.log(pc15.green(`
+\u2713 Baselines updated for ${component}
+`));
+  }
+  const baselinesDir = join6(configDir, BRAND.dataDir, "baselines");
+  console.log(pc15.dim(`Baselines directory: ${relative4(process.cwd(), baselinesDir)}
+`));
+  return { success: true, action: "update" };
+}
+async function listBaselines(configDir) {
+  const baselinesDir = join6(configDir, BRAND.dataDir, "baselines");
+  try {
+    const files = await readdir3(baselinesDir, { recursive: true });
+    const pngFiles = files.filter((f) => f.endsWith(".png"));
+    if (pngFiles.length === 0) {
+      console.log(pc15.yellow("No baselines found.\n"));
+      console.log(pc15.dim(`Run ${pc15.cyan(`${BRAND.cliCommand} screenshot`)} to capture baselines.
+`));
+      return { success: true, action: "list", count: 0 };
+    }
+    console.log(pc15.bold("Baselines:\n"));
+    for (const file of pngFiles) {
+      console.log(`  ${file}`);
+    }
+    console.log();
+    console.log(pc15.dim(`Total: ${pngFiles.length} baseline(s)
+`));
+    return { success: true, action: "list", count: pngFiles.length };
+  } catch {
+    console.log(pc15.yellow("No baselines directory found.\n"));
+    console.log(pc15.dim(`Run ${pc15.cyan(`${BRAND.cliCommand} screenshot`)} to capture baselines.
+`));
+    return { success: true, action: "list", count: 0 };
+  }
+}
+async function deleteBaseline(component, options, configDir) {
+  const { all = false } = options;
+  const baselinesDir = join6(configDir, BRAND.dataDir, "baselines");
+  if (all) {
+    const { confirm } = await import("@inquirer/prompts");
+    const confirmed = await confirm({
+      message: "Delete ALL baselines? This cannot be undone.",
+      default: false
+    });
+    if (!confirmed) {
+      console.log(pc15.dim("\nNo changes made.\n"));
+      return { success: true, action: "delete", count: 0 };
+    }
+    await rm2(baselinesDir, { recursive: true, force: true });
+    console.log(pc15.green("\n\u2713 All baselines deleted\n"));
+    return { success: true, action: "delete" };
+  } else if (component) {
+    const componentDir = join6(baselinesDir, component);
+    try {
+      await rm2(componentDir, { recursive: true, force: true });
+      console.log(pc15.green(`\u2713 Baselines deleted for ${component}
+`));
+      return { success: true, action: "delete" };
+    } catch {
+      console.log(pc15.yellow(`No baselines found for ${component}.
+`));
+      return { success: true, action: "delete", count: 0 };
+    }
+  } else {
+    console.log(pc15.yellow("Specify a component name or use --all flag.\n"));
+    return { success: false, action: "delete" };
+  }
+}
+
+// src/commands/add.ts
+import { writeFile as writeFile4, mkdir as mkdir5, access as access2 } from "fs/promises";
+import { resolve as resolve4, join as join7, relative as relative5 } from "path";
+import pc16 from "picocolors";
+async function add(name, options = {}) {
+  console.log(pc16.cyan(`
+${BRAND.name} Component Scaffold
+`));
+  let componentName = name;
+  let category = options.category;
+  let template = options.template;
+  let dir = options.dir;
+  const generateComponent = options.component !== false;
+  if (!componentName || !category || !template || !dir) {
+    const { input, select } = await import("@inquirer/prompts");
+    try {
+      if (!componentName) {
+        componentName = await input({
+          message: "Component name:",
+          validate: (value) => {
+            if (!value.trim()) return "Component name is required";
+            if (!/^[A-Za-z][A-Za-z0-9]*$/.test(value)) return "Use PascalCase (e.g., Button, TextField)";
+            return true;
+          }
+        });
+      }
+      if (!template) {
+        template = await select({
+          message: "What type of component is this?",
+          choices: [
+            { name: "Display - Shows information or status", value: "display" },
+            { name: "Action - Triggers an action (button, link)", value: "action" },
+            { name: "Form Input - Accepts user input", value: "form-input" },
+            { name: "Layout - Organizes content structure", value: "layout" }
+          ],
+          default: "display"
+        });
+      }
+      if (!category) {
+        category = await input({
+          message: "Category:",
+          default: template === "form-input" ? "forms" : template === "layout" ? "layout" : "components"
+        });
+      }
+      if (!dir) {
+        dir = await input({
+          message: "Output directory:",
+          default: "src/components"
+        });
+      }
+    } catch {
+      console.log(pc16.dim("\nNo changes made."));
+      process.exit(0);
+    }
+  }
+  componentName = componentName.charAt(0).toUpperCase() + componentName.slice(1);
+  category = category || "components";
+  template = template || "display";
+  dir = dir || "src/components";
+  const componentDir = resolve4(process.cwd(), dir, componentName);
+  const componentFile = join7(componentDir, `${componentName}.tsx`);
+  const segmentFile = join7(componentDir, `${componentName}${BRAND.fileExtension}`);
+  const indexFile = join7(componentDir, "index.ts");
+  try {
+    await access2(componentDir);
+    console.log(pc16.yellow(`Directory already exists: ${relative5(process.cwd(), componentDir)}`));
+    console.log(pc16.dim("Use a different name or remove the existing directory."));
+    process.exit(1);
+  } catch {
+  }
+  await mkdir5(componentDir, { recursive: true });
+  if (generateComponent) {
+    const componentCode = generateComponentStub(componentName, template);
+    await writeFile4(componentFile, componentCode);
+    console.log(`${pc16.green("\u2713")} Created ${relative5(process.cwd(), componentFile)}`);
+  }
+  const segmentCode = generateSegmentStub(componentName, category, template);
+  await writeFile4(segmentFile, segmentCode);
+  console.log(`${pc16.green("\u2713")} Created ${relative5(process.cwd(), segmentFile)}`);
+  const indexCode = `export { ${componentName} } from './${componentName}.js';
+`;
+  await writeFile4(indexFile, indexCode);
+  console.log(`${pc16.green("\u2713")} Created ${relative5(process.cwd(), indexFile)}`);
+  console.log(pc16.green(`
+\u2713 Scaffolded ${componentName}
+`));
+  console.log(pc16.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(pc16.bold("\nNext steps:"));
+  if (generateComponent) {
+    console.log(`  1. Implement ${componentName}.tsx`);
+  }
+  console.log(`  2. Fill in usage.when and usage.whenNot in the fragment file`);
+  console.log(`  3. Add variants with different prop combinations`);
+  console.log(`  4. Run ${pc16.cyan(`${BRAND.cliCommand} dev`)} to preview`);
+  console.log();
+  return {
+    success: true,
+    componentPath: generateComponent ? componentFile : void 0,
+    segmentPath: segmentFile,
+    indexPath: indexFile
+  };
+}
+function generateComponentStub(name, _template) {
+  const propsInterface = `export interface ${name}Props {
+  /** Content to display */
+  children?: React.ReactNode;
+  /** Additional CSS classes */
+  className?: string;
+}`;
+  return `import React from 'react';
+
+${propsInterface}
+
+/**
+ * ${name} component
+ *
+ * TODO: Implement this component
+ */
+export function ${name}({ children, className }: ${name}Props) {
+  return (
+    <div className={className}>
+      {children}
+    </div>
+  );
+}
+`;
+}
+function generateSegmentStub(name, category, template) {
+  const usageHints = {
+    action: {
+      when: ["User needs to trigger an action", "Form submission is required"],
+      whenNot: ["Navigation is needed (use Link)", "Action is destructive without confirmation"]
+    },
+    "form-input": {
+      when: ["User needs to enter data", "Form field is required"],
+      whenNot: ["Display-only data is shown", "Rich text editing is needed"]
+    },
+    layout: {
+      when: ["Content needs to be organized", "Responsive layout is required"],
+      whenNot: ["Simple inline content is displayed", "Scroll container is needed"]
+    },
+    display: {
+      when: ["Information needs to be presented", "Status or feedback is shown"],
+      whenNot: ["User interaction is required", "Data input is needed"]
+    }
+  };
+  const hints = usageHints[template] || usageHints.display;
+  const scenarioTagHints = {
+    action: ["action.primary", "action.secondary", "form.submit"],
+    "form-input": ["form.input", "form.field", "form.text"],
+    layout: ["layout.container", "layout.section", "content.group"],
+    display: ["display.info", "display.status", "content.text"]
+  };
+  const scenarioTags = scenarioTagHints[template] || scenarioTagHints.display;
+  return `import React from 'react';
+import { defineSegment } from '@fragments/core';
+import { ${name} } from './index.js';
+
+export default defineSegment({
+  component: ${name},
+
+  meta: {
+    name: '${name}',
+    description: 'TODO: Add description',
+    category: '${category}',
+    status: 'experimental',
+    tags: ['${category}'],
+  },
+
+  usage: {
+    when: [
+      '${hints.when[0]}',
+      '${hints.when[1]}',
+    ],
+    whenNot: [
+      '${hints.whenNot[0]}',
+      '${hints.whenNot[1]}',
+    ],
+    guidelines: [
+      // TODO: Add best practices
+    ],
+    accessibility: [
+      // TODO: Add accessibility guidelines
+    ],
+  },
+
+  props: {
+    children: {
+      type: 'node',
+      description: 'Content to display',
+    },
+    className: {
+      type: 'string',
+      description: 'Additional CSS classes',
+    },
+    // TODO: Add more props
+  },
+
+  relations: [
+    // TODO: Add related components
+    // { component: 'RelatedComponent', relationship: 'alternative', note: 'Use for...' },
+  ],
+
+  contract: {
+    propsSummary: [
+      'children: ReactNode - content to display',
+      'className: string - additional CSS classes',
+      // TODO: Add prop summaries
+    ],
+    scenarioTags: [
+      '${scenarioTags[0]}',
+      '${scenarioTags[1]}',
+      // TODO: Add scenario tags for AI agent queries
+    ],
+    a11yRules: [
+      // TODO: Add accessibility rule IDs
+    ],
+  },
+
+  variants: [
+    {
+      name: 'Default',
+      description: 'Default ${name} appearance',
+      render: () => <${name}>Example content</${name}>,
+    },
+    // TODO: Add more variants
+    // {
+    //   name: 'WithProps',
+    //   description: '${name} with additional props',
+    //   render: () => <${name} someProp="value">Content</${name}>,
+    // },
+  ],
+});
+`;
+}
+
+// src/commands/link/figma.ts
+import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+import pc17 from "picocolors";
+async function linkFigma(figmaUrl, options = {}) {
+  const { config: configPath, auto = false, dryRun = false, variants = true } = options;
+  if (!process.env.FIGMA_ACCESS_TOKEN) {
+    console.error(pc17.red("\nFIGMA_ACCESS_TOKEN environment variable required."));
+    console.log(pc17.dim("Generate at: https://www.figma.com/developers/api#access-tokens"));
+    console.log(pc17.dim("  export FIGMA_ACCESS_TOKEN=figd_xxx"));
+    process.exit(1);
+  }
+  console.log(pc17.cyan(`
+${BRAND.name} Link Wizard
+`));
+  const { config, configDir } = await loadConfig(configPath);
+  let fileUrl = figmaUrl || config.figmaFile;
+  if (!fileUrl) {
+    const { input } = await import("@inquirer/prompts");
+    console.log(pc17.dim("Tip: Add `figmaFile` to fragments.config.ts to skip this prompt\n"));
+    try {
+      fileUrl = await input({
+        message: "Enter Figma file URL:",
+        validate: (value) => {
+          if (!value.trim()) return "URL is required";
+          if (!value.includes("figma.com")) return "Please enter a valid Figma URL";
+          return true;
+        }
+      });
+    } catch {
+      console.log(pc17.dim("\nNo changes made."));
+      process.exit(0);
+    }
+  } else if (config.figmaFile && !figmaUrl) {
+    console.log(pc17.dim(`Using Figma file from config: ${config.figmaFile}
+`));
+  }
+  const figmaClient = new FigmaClient({ accessToken: process.env.FIGMA_ACCESS_TOKEN });
+  console.log(pc17.dim("Parsing Figma URL..."));
+  const { fileKey } = figmaClient.parseFileUrl(fileUrl);
+  console.log(pc17.dim("Fetching components from Figma..."));
+  const figmaData = await figmaClient.getFileComponents(fileKey);
+  const allFigmaComponents = figmaData.componentSets.length > 0 ? figmaData.componentSets : figmaData.components;
+  if (allFigmaComponents.length === 0) {
+    console.log(pc17.yellow("\nNo components found in Figma file."));
+    console.log(pc17.dim("Make sure the file contains published components."));
+    process.exit(0);
+  }
+  const componentType = figmaData.componentSets.length > 0 ? "component set" : "component";
+  console.log(pc17.green(`\u2713 Found ${allFigmaComponents.length} Figma ${componentType}(s) in "${figmaData.fileName}"`));
+  if (figmaData.components.length > 0 && figmaData.componentSets.length > 0) {
+    console.log(pc17.dim(`  (${figmaData.components.length} individual components also available)
+`));
+  } else {
+    console.log();
+  }
+  const segmentFiles = await discoverSegmentFiles(config, configDir);
+  if (segmentFiles.length === 0) {
+    console.log(pc17.yellow("No segment files found in codebase."));
+    console.log(pc17.dim(`Looking for: ${config.include.join(", ")}`));
+    process.exit(0);
+  }
+  console.log(pc17.dim(`Found ${segmentFiles.length} segment file(s)
+`));
+  const segments = [];
+  for (const file of segmentFiles) {
+    try {
+      const content = await readFile4(file.absolutePath, "utf-8");
+      const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
+      const hasFigma = /meta:\s*\{[^}]*figma:\s*['"]https?:/.test(content);
+      const segmentVariants = extractVariants(content, nameMatch?.[1]);
+      if (nameMatch) {
+        segments.push({
+          name: nameMatch[1],
+          filePath: file.absolutePath,
+          relativePath: file.relativePath,
+          hasFigma,
+          variants: segmentVariants
+        });
+      }
+    } catch {
+    }
+  }
+  const matches = [];
+  const unmatchedSegments = [];
+  for (const segment of segments) {
+    let bestMatch = null;
+    let bestScore = 0;
+    for (const figmaComp of allFigmaComponents) {
+      const score = calculateMatchScore(segment.name, figmaComp.name);
+      if (score > bestScore) {
+        bestMatch = figmaComp;
+        bestScore = score;
+        if (score === 100) break;
+      }
+    }
+    if (bestMatch && bestScore >= 65) {
+      const alreadyLinked = segment.hasFigma;
+      if (alreadyLinked && !auto) {
+        console.log(pc17.dim(`\u23ED\uFE0F  ${segment.name} (already linked)`));
+      }
+      matches.push({ segment, figmaComponent: bestMatch, score: bestScore, alreadyLinked });
+    } else {
+      unmatchedSegments.push(segment);
+    }
+  }
+  if (unmatchedSegments.length > 0) {
+    console.log(pc17.dim("Unmatched segments:"));
+    for (const seg of unmatchedSegments) {
+      console.log(`  ${pc17.dim("\u2022")} ${seg.name}`);
+    }
+    console.log();
+  }
+  const newMatches = matches.filter((m) => !m.alreadyLinked);
+  const alreadyLinkedMatches = matches.filter((m) => m.alreadyLinked);
+  if (matches.length === 0) {
+    console.log(pc17.yellow("\nNo automatic matches found."));
+    console.log(pc17.dim("You can manually add figma URLs to your segment definitions."));
+    process.exit(0);
+  }
+  if (dryRun) {
+    if (newMatches.length > 0) {
+      console.log(pc17.bold("\nMatched Components:\n"));
+      for (const match of newMatches) {
+        const scoreColor = match.score === 100 ? pc17.green : pc17.yellow;
+        console.log(
+          `  ${pc17.green("\u2713")} ${pc17.bold(match.segment.name)} \u2192 ${match.figmaComponent.name} ${scoreColor(`(${Math.round(match.score)}%)`)}`
+        );
+      }
+    }
+    console.log(pc17.yellow("\n[Dry run - no files were updated]"));
+    return { success: true, updated: 0, variantUpdates: 0 };
+  }
+  let selectedMatches = newMatches;
+  if (newMatches.length > 0) {
+    if (auto) {
+      console.log(pc17.bold("\nMatched Components:\n"));
+      for (const match of newMatches) {
+        const scoreColor = match.score === 100 ? pc17.green : pc17.yellow;
+        console.log(
+          `  ${pc17.green("\u2713")} ${pc17.bold(match.segment.name)} \u2192 ${match.figmaComponent.name} ${scoreColor(`(${Math.round(match.score)}%)`)}`
+        );
+      }
+    } else {
+      const { checkbox } = await import("@inquirer/prompts");
+      console.log(pc17.bold("\nMatched Components:\n"));
+      console.log(pc17.dim("Use \u2191/\u2193 to navigate, Space to toggle, Enter to confirm\n"));
+      const choices = newMatches.map((match) => {
+        const scoreColor = match.score === 100 ? pc17.green : pc17.yellow;
+        return {
+          name: `${pc17.bold(match.segment.name)} \u2192 ${match.figmaComponent.name} ${scoreColor(`(${Math.round(match.score)}%)`)}`,
+          value: match,
+          checked: true
+        };
+      });
+      try {
+        selectedMatches = await checkbox({
+          message: "Select components to link:",
+          choices,
+          pageSize: 20
+        });
+      } catch {
+        console.log(pc17.dim("\nNo changes made."));
+        return { success: true, updated: 0, variantUpdates: 0 };
+      }
+    }
+  }
+  const allSelectedMatches = [...selectedMatches, ...alreadyLinkedMatches];
+  let updated = 0;
+  for (const match of selectedMatches) {
+    if (match.alreadyLinked) continue;
+    try {
+      let content = await readFile4(match.segment.filePath, "utf-8");
+      const figmaUrlToInsert = figmaClient.buildNodeUrl(
+        match.figmaComponent.file_key,
+        match.figmaComponent.node_id,
+        figmaData.fileName
+      );
+      if (/meta:\s*\{[^}]*figma:/.test(content)) {
+        content = content.replace(
+          /(meta:\s*\{[^}]*figma:\s*['"])([^'"]*)['"]/,
+          `$1${figmaUrlToInsert}'`
+        );
+      } else {
+        content = content.replace(
+          /(meta:\s*\{[^}]*category:\s*['"][^'"]*['"],?)/,
+          `$1
+    figma: '${figmaUrlToInsert}',`
+        );
+      }
+      await writeFile5(match.segment.filePath, content);
+      updated++;
+      console.log(`  ${pc17.green("\u2713")} Updated ${match.segment.relativePath}`);
+    } catch (error) {
+      console.log(`  ${pc17.red("\u2717")} Failed to update ${match.segment.relativePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  if (updated > 0) {
+    console.log(pc17.green(`
+\u2713 Updated ${updated} segment file(s)
+`));
+  }
+  let variantUpdates = 0;
+  if (variants && figmaData.componentSets.length > 0) {
+    variantUpdates = await linkVariants(
+      allSelectedMatches,
+      figmaData,
+      figmaClient,
+      fileKey
+    );
+  }
+  console.log(pc17.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(pc17.bold("\nNext steps:"));
+  console.log(`  1. Run ${pc17.cyan(`${BRAND.cliCommand} compare --all`)} to verify designs`);
+  console.log(`  2. Add figmaProps mappings for prop-level linking`);
+  console.log();
+  return { success: true, updated, variantUpdates };
+}
+function extractVariants(content, componentName) {
+  const variants = [];
+  const variantsArrayMatch = content.match(/variants:\s*\[/);
+  if (variantsArrayMatch && variantsArrayMatch.index !== void 0) {
+    const variantsStart = variantsArrayMatch.index + variantsArrayMatch[0].length;
+    let bracketCount = 1;
+    let variantsEnd = variantsStart;
+    while (bracketCount > 0 && variantsEnd < content.length) {
+      if (content[variantsEnd] === "[") bracketCount++;
+      if (content[variantsEnd] === "]") bracketCount--;
+      variantsEnd++;
+    }
+    const variantsSection = content.slice(variantsStart, variantsEnd - 1);
+    const variantNameRegex = /\{\s*\n?\s*name:\s*['"]([^'"]+)['"]/g;
+    let variantMatch;
+    while ((variantMatch = variantNameRegex.exec(variantsSection)) !== null) {
+      const variantName = variantMatch[1];
+      if (componentName && variantName === componentName) continue;
+      const objectStart = variantMatch.index;
+      let braceCount = 1;
+      let objectEnd = objectStart + 1;
+      while (braceCount > 0 && objectEnd < variantsSection.length) {
+        if (variantsSection[objectEnd] === "{") braceCount++;
+        if (variantsSection[objectEnd] === "}") braceCount--;
+        objectEnd++;
+      }
+      const objectContent = variantsSection.slice(objectStart, objectEnd);
+      const variantHasFigma = /figma:\s*['"]https?:/.test(objectContent);
+      variants.push({
+        name: variantName,
+        hasFigma: variantHasFigma
+      });
+    }
+  }
+  return variants;
+}
+function calculateMatchScore(segmentName, figmaName) {
+  const normalizeForMatch = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const normalizedSegment = normalizeForMatch(segmentName);
+  const normalizedFigma = normalizeForMatch(figmaName);
+  if (normalizedSegment === normalizedFigma) {
+    return 100;
+  }
+  if (normalizedFigma.startsWith(normalizedSegment)) {
+    const coverage = normalizedSegment.length / normalizedFigma.length;
+    return Math.max(85, coverage * 100);
+  }
+  if (normalizedSegment.startsWith(normalizedFigma)) {
+    const coverage = normalizedFigma.length / normalizedSegment.length;
+    return Math.max(80, coverage * 100);
+  }
+  const getWords = (s) => {
+    return s.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[^a-zA-Z0-9]+/g, " ").toLowerCase().split(/\s+/).filter((w) => w.length > 0);
+  };
+  const segmentWords = getWords(segmentName);
+  const figmaWords = getWords(figmaName);
+  const allSegmentWordsInFigma = segmentWords.every(
+    (sw) => figmaWords.some((fw) => fw === sw || fw.startsWith(sw) || sw.startsWith(fw))
+  );
+  if (allSegmentWordsInFigma && segmentWords.length > 0) {
+    const wordOverlap = segmentWords.length / Math.max(segmentWords.length, figmaWords.length);
+    return Math.max(75, wordOverlap * 95);
+  }
+  if (normalizedFigma.includes(normalizedSegment)) {
+    return 70;
+  }
+  if (normalizedSegment.includes(normalizedFigma)) {
+    return 65;
+  }
+  return 0;
+}
+async function linkVariants(matches, figmaData, figmaClient, fileKey) {
+  console.log(pc17.bold("\nLinking variants...\n"));
+  const matchedComponentSets = matches.map((m) => m.figmaComponent).filter((c) => figmaData.componentSets.some((cs) => cs.key === c.key));
+  if (matchedComponentSets.length === 0) {
+    return 0;
+  }
+  console.log(pc17.dim("Fetching Figma variants..."));
+  const componentSetVariants = await figmaClient.getComponentSetVariants(fileKey, matchedComponentSets);
+  let variantUpdates = 0;
+  const { select } = await import("@inquirer/prompts");
+  const normalizeForMatch = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const match of matches) {
+    const csWithVariants = componentSetVariants.find(
+      (cs) => cs.componentSet.key === match.figmaComponent.key
+    );
+    if (!csWithVariants || csWithVariants.variants.length === 0) {
+      continue;
+    }
+    const segmentVariants = match.segment.variants.filter((v) => !v.hasFigma);
+    if (segmentVariants.length === 0) {
+      console.log(pc17.dim(`  \u23ED\uFE0F  ${match.segment.name}: all variants already linked`));
+      continue;
+    }
+    console.log(pc17.dim(`  ${match.segment.name}: ${csWithVariants.variants.length} Figma variants`));
+    for (const segmentVariant of segmentVariants) {
+      const variantMatches = [];
+      for (const fv of csWithVariants.variants) {
+        const normalizedSegment = normalizeForMatch(segmentVariant.name);
+        for (const value of fv.values) {
+          const normalizedValue = normalizeForMatch(value);
+          if (normalizedSegment === normalizedValue) {
+            variantMatches.push({ figmaVariant: fv, score: 100 });
+            break;
+          } else if (normalizedValue.includes(normalizedSegment)) {
+            variantMatches.push({ figmaVariant: fv, score: 85 });
+          } else if (normalizedSegment.includes(normalizedValue)) {
+            variantMatches.push({ figmaVariant: fv, score: 75 });
+          }
+        }
+      }
+      variantMatches.sort((a, b) => b.score - a.score);
+      if (variantMatches.length > 0 && variantMatches[0].score === 100) {
+        const bestMatch = variantMatches[0];
+        const variantUrl = figmaClient.buildNodeUrl(
+          match.figmaComponent.file_key,
+          bestMatch.figmaVariant.node_id,
+          figmaData.fileName
+        );
+        try {
+          let content = await readFile4(match.segment.filePath, "utf-8");
+          const namePattern = new RegExp(
+            `(name:\\s*['"]${escapeRegExp(segmentVariant.name)}['"],?)`,
+            "g"
+          );
+          let replaced = false;
+          content = content.replace(namePattern, (matchedStr) => {
+            if (replaced) return matchedStr;
+            replaced = true;
+            return `${matchedStr}
+      figma: '${variantUrl}',`;
+          });
+          await writeFile5(match.segment.filePath, content);
+          variantUpdates++;
+          console.log(
+            `    ${pc17.green("\u2713")} ${segmentVariant.name} \u2192 ${bestMatch.figmaVariant.name}`
+          );
+        } catch (error) {
+          console.log(
+            `    ${pc17.red("\u2717")} ${segmentVariant.name}: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      } else if (variantMatches.length > 0) {
+        const choices = [
+          ...variantMatches.slice(0, 4).map((m) => ({
+            name: `${m.figmaVariant.name} (${m.score}%)`,
+            value: m.figmaVariant
+          })),
+          { name: "Skip this variant", value: null }
+        ];
+        try {
+          const selectedVariant = await select({
+            message: `  Match for "${segmentVariant.name}":`,
+            choices
+          });
+          if (selectedVariant) {
+            const variantUrl = figmaClient.buildNodeUrl(
+              match.figmaComponent.file_key,
+              selectedVariant.node_id,
+              figmaData.fileName
+            );
+            let content = await readFile4(match.segment.filePath, "utf-8");
+            const namePattern = new RegExp(
+              `(name:\\s*['"]${escapeRegExp(segmentVariant.name)}['"],?)`,
+              "g"
+            );
+            let replaced = false;
+            content = content.replace(namePattern, (matchedStr) => {
+              if (replaced) return matchedStr;
+              replaced = true;
+              return `${matchedStr}
+      figma: '${variantUrl}',`;
+            });
+            await writeFile5(match.segment.filePath, content);
+            variantUpdates++;
+            console.log(
+              `    ${pc17.green("\u2713")} ${segmentVariant.name} \u2192 ${selectedVariant.name}`
+            );
+          } else {
+            console.log(`    ${pc17.dim("\u23ED\uFE0F")} ${segmentVariant.name} (skipped)`);
+          }
+        } catch {
+          console.log(`    ${pc17.dim("\u23ED\uFE0F")} ${segmentVariant.name} (cancelled)`);
+        }
+      } else {
+        console.log(`    ${pc17.yellow("?")} ${segmentVariant.name}: no matching Figma variant`);
+      }
+    }
+  }
+  if (variantUpdates > 0) {
+    console.log(pc17.green(`
+\u2713 Linked ${variantUpdates} variant(s)
+`));
+  } else {
+    console.log(pc17.dim("\nNo variant updates made.\n"));
+  }
+  return variantUpdates;
+}
+
+// src/commands/link/storybook.ts
+import { writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
+import { join as join8, dirname as dirname3, relative as relative6 } from "path";
+import pc18 from "picocolors";
+async function linkStorybook(options = {}) {
+  const { out, yes = false, dryRun = false, verbose = false } = options;
+  console.log(pc18.cyan(`
+${BRAND.name} Storybook Link
+`));
+  const projectRoot = process.cwd();
+  console.log(pc18.dim("Detecting Storybook configuration..."));
+  const sbConfig = await detectStorybookConfig(projectRoot);
+  if (!sbConfig) {
+    console.log(pc18.yellow("\nNo Storybook configuration found."));
+    console.log(pc18.dim("Looking for: .storybook/main.ts, .storybook/main.js, etc."));
+    console.log(pc18.dim("\nUse --config to specify a custom path."));
+    process.exit(1);
+  }
+  console.log(pc18.green(`\u2713 Found: ${sbConfig.configPath}`));
+  if (sbConfig.framework) {
+    console.log(pc18.dim(`  Framework: ${sbConfig.framework}`));
+  }
+  if (sbConfig.errors?.length) {
+    for (const err of sbConfig.errors) {
+      console.log(pc18.yellow(`  Warning: ${err}`));
+    }
+  }
+  console.log(pc18.dim("\nDiscovering story files..."));
+  const storyFiles = await discoverStoryFiles(projectRoot, sbConfig.storyPatterns);
+  if (storyFiles.length === 0) {
+    console.log(pc18.yellow("\nNo story files found."));
+    console.log(pc18.dim(`Patterns: ${sbConfig.storyPatterns.join(", ")}`));
+    process.exit(1);
+  }
+  console.log(pc18.green(`\u2713 Found ${storyFiles.length} story file(s)
+`));
+  const previews = [];
+  let parseErrors = 0;
+  const total = storyFiles.length;
+  console.log(pc18.dim(`Analyzing ${total} stories...
+`));
+  for (let i = 0; i < storyFiles.length; i++) {
+    const storyFile = storyFiles[i];
+    const relativePath = relative6(projectRoot, storyFile);
+    process.stdout.write(`\r  ${pc18.dim(`[${i + 1}/${total}]`)} ${relativePath.slice(0, 60).padEnd(60)}`);
+    try {
+      const parsed = await parseStoryFile(storyFile);
+      const result = convertToSegment(parsed);
+      const outputFile = out ? join8(out, relativePath.replace(/\.stories\.(tsx?|jsx?)$/, BRAND.fileExtension)) : result.outputFile;
+      previews.push({
+        componentName: result.componentName,
+        sourceFile: relativePath,
+        outputFile: relative6(projectRoot, outputFile),
+        variantCount: result.variantCount,
+        propCount: result.propCount,
+        confidence: result.confidence,
+        warnings: result.warnings
+      });
+    } catch (error) {
+      parseErrors++;
+      if (verbose) {
+        process.stdout.write("\n");
+        console.log(pc18.red(`\u2717 ${relativePath}: ${error instanceof Error ? error.message : "Parse error"}`));
+      }
+    }
+  }
+  process.stdout.write("\r" + " ".repeat(80) + "\r");
+  console.log(pc18.bold("Preview:\n"));
+  console.log(pc18.dim("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  console.log(pc18.dim("\u2502") + " Component".padEnd(20) + pc18.dim("\u2502") + " Stories".padEnd(10) + pc18.dim("\u2502") + " Props".padEnd(8) + pc18.dim("\u2502") + " Confidence".padEnd(13) + pc18.dim("\u2502"));
+  console.log(pc18.dim("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"));
+  for (const item of previews) {
+    const confColor = item.confidence >= 0.8 ? pc18.green : item.confidence >= 0.5 ? pc18.yellow : pc18.red;
+    const confLabel = item.confidence >= 0.8 ? "high" : item.confidence >= 0.5 ? "medium" : "low";
+    console.log(
+      pc18.dim("\u2502") + ` ${item.componentName}`.padEnd(20).slice(0, 20) + pc18.dim("\u2502") + ` ${item.variantCount}`.padEnd(10) + pc18.dim("\u2502") + ` ${item.propCount}`.padEnd(8) + pc18.dim("\u2502") + ` ${confColor(confLabel)}`.padEnd(13 + (confColor === pc18.green ? 10 : confColor === pc18.yellow ? 11 : 9)) + pc18.dim("\u2502")
+    );
+  }
+  console.log(pc18.dim("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+  if (parseErrors > 0) {
+    console.log(pc18.yellow(`
+${parseErrors} file(s) could not be parsed (use --verbose for details)`));
+  }
+  if (previews.length === 0) {
+    console.log(pc18.yellow("\nNo stories could be parsed successfully."));
+    return { success: true, generated: 0 };
+  }
+  if (dryRun) {
+    console.log(pc18.dim(`
+${previews.length} segment file(s) would be created`));
+    console.log(pc18.yellow("\n[Dry run - no files were written]"));
+    return { success: true, generated: 0 };
+  }
+  let selectedPreviews = previews;
+  if (yes) {
+    console.log(pc18.dim(`
+${previews.length} segment file(s) will be created`));
+  } else {
+    const { checkbox } = await import("@inquirer/prompts");
+    console.log(pc18.dim("\nUse \u2191/\u2193 to navigate, Space to toggle, Enter to confirm\n"));
+    const choices = previews.map((item) => {
+      const confColor = item.confidence >= 0.8 ? pc18.green : item.confidence >= 0.5 ? pc18.yellow : pc18.red;
+      const confLabel = item.confidence >= 0.8 ? "high" : item.confidence >= 0.5 ? "medium" : "low";
+      return {
+        name: `${pc18.bold(item.componentName)} ${pc18.dim(`(${item.variantCount} stories, ${confLabel} confidence)`)}`,
+        value: item,
+        checked: true
+      };
+    });
+    try {
+      selectedPreviews = await checkbox({
+        message: "Select stories to convert:",
+        choices,
+        pageSize: 15
+      });
+    } catch {
+      console.log(pc18.dim("\nNo changes made."));
+      return { success: true, generated: 0 };
+    }
+    if (selectedPreviews.length === 0) {
+      console.log(pc18.dim("\nNo stories selected. No changes made."));
+      return { success: true, generated: 0 };
+    }
+  }
+  const genTotal = selectedPreviews.length;
+  console.log(pc18.dim(`
+Generating ${genTotal} segment file(s)...
+`));
+  let generated = 0;
+  let genErrors = 0;
+  for (let i = 0; i < selectedPreviews.length; i++) {
+    const preview = selectedPreviews[i];
+    const storyFile = join8(projectRoot, preview.sourceFile);
+    try {
+      const parsed = await parseStoryFile(storyFile);
+      const result = convertToSegment(parsed);
+      const outputFile = out ? join8(projectRoot, out, preview.sourceFile.replace(/\.stories\.(tsx?|jsx?)$/, BRAND.fileExtension)) : result.outputFile;
+      await mkdir6(dirname3(outputFile), { recursive: true });
+      await writeFile6(outputFile, result.code);
+      generated++;
+      console.log(`${pc18.dim(`[${i + 1}/${genTotal}]`)} ${pc18.green("\u2713")} ${result.componentName}`);
+    } catch (error) {
+      genErrors++;
+      console.log(`${pc18.dim(`[${i + 1}/${genTotal}]`)} ${pc18.red("\u2717")} ${preview.componentName}`);
+    }
+  }
+  console.log(pc18.green(`
+\u2713 Generated ${generated} segment file(s)
+`));
+  console.log(pc18.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(pc18.bold("\nNext steps:"));
+  console.log(`  1. Review generated ${BRAND.fileExtension} files`);
+  console.log(`  2. Fill in usage.when and usage.whenNot fields`);
+  console.log(`  3. Run ${pc18.cyan(`${BRAND.cliCommand} build`)} to compile`);
+  console.log(`  4. Run ${pc18.cyan(`${BRAND.cliCommand} dev`)} to view your design system`);
+  console.log();
+  return { success: true, generated };
+}
+
+// src/commands/enhance.ts
+import pc19 from "picocolors";
+import { readFile as readFile5, writeFile as writeFile7 } from "fs/promises";
+import { resolve as resolve5, relative as relative7, join as join9 } from "path";
+var DEFAULT_MODELS = {
+  anthropic: "claude-sonnet-4-20250514",
+  openai: "gpt-4o",
+  none: ""
+};
+async function enhance(options = {}) {
+  const {
+    config: configPath,
+    component,
+    yes = false,
+    dryRun = false,
+    format = "interactive",
+    provider = detectProvider(options),
+    apiKey = getApiKey(provider, options.apiKey),
+    model = options.model || DEFAULT_MODELS[provider],
+    root = process.cwd(),
+    contextOnly = false,
+    renderVariants = false,
+    storybookUrl = "http://localhost:6006"
+  } = options;
+  const isInteractive = format === "interactive";
+  const isQuiet = format === "quiet";
+  const isContextMode = contextOnly || format === "context" || provider === "none";
+  const config = await loadConfig(configPath);
+  const rootDir = resolve5(root);
+  if (isInteractive) {
+    console.log(pc19.cyan(`
+${BRAND.name} AI Enhancement
+`));
+    if (isContextMode) {
+      console.log(pc19.dim("Running in context-only mode (for use with IDE AI like Cursor)\n"));
+    } else {
+      console.log(pc19.dim(`Using ${provider} API with model: ${model}
+`));
+    }
+  }
+  if (!isContextMode && !apiKey) {
+    const envVar = provider === "openai" ? "OPENAI_API_KEY" : "ANTHROPIC_API_KEY";
+    const error = `API key required. Set ${envVar} or use --api-key, or use --context-only for IDE AI mode`;
+    if (format === "json") {
+      console.log(JSON.stringify({ success: false, error }));
+    } else if (!isQuiet) {
+      console.error(pc19.red("Error:"), error);
+      console.log(pc19.dim("\nTip: Use --context-only to generate prompts for Cursor/Copilot/etc."));
+    }
+    return { success: false, enhanced: [], totalTokens: 0, estimatedCost: 0 };
+  }
+  if (isInteractive) {
+    console.log(pc19.dim("Phase 1: Scanning codebase for usage patterns..."));
+  }
+  let usageAnalysis;
+  try {
+    usageAnalysis = await scanCodebase({
+      rootDir,
+      useCache: true,
+      onProgress: (progress) => {
+        if (isInteractive && progress.phase === "scanning") {
+          const pct = Math.round(progress.current / progress.total * 100);
+          process.stdout.write(`\r  Scanning: ${pct}% (${progress.current}/${progress.total})`);
+        }
+      }
+    });
+    if (isInteractive) {
+      process.stdout.write("\r" + " ".repeat(60) + "\r");
+      const stats = getScanStats(usageAnalysis);
+      console.log(pc19.green(`  Found ${stats.totalUsages} usages across ${stats.totalFiles} files`));
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (format === "json") {
+      console.log(JSON.stringify({ success: false, error: `Scan failed: ${msg}` }));
+    } else if (!isQuiet) {
+      console.error(pc19.red("Scan failed:"), msg);
+    }
+    return { success: false, enhanced: [], totalTokens: 0, estimatedCost: 0 };
+  }
+  if (isInteractive) {
+    console.log(pc19.dim("Phase 2: Parsing Storybook stories..."));
+  }
+  let storyFiles;
+  try {
+    storyFiles = await parseAllStories(rootDir);
+    if (isInteractive) {
+      console.log(pc19.green(`  Found ${storyFiles.size} story files`));
+    }
+  } catch {
+    storyFiles = /* @__PURE__ */ new Map();
+    if (isInteractive) {
+      console.log(pc19.yellow("  No Storybook stories found"));
+    }
+  }
+  if (isInteractive) {
+    console.log(pc19.dim("Phase 3: Loading fragment files..."));
+  }
+  const segmentFiles = await findSegmentFiles(rootDir);
+  if (segmentFiles.length === 0) {
+    const msg = "No fragment files found";
+    if (format === "json") {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else if (!isQuiet) {
+      console.log(pc19.yellow(msg));
+    }
+    return { success: false, enhanced: [], totalTokens: 0, estimatedCost: 0 };
+  }
+  if (isInteractive) {
+    console.log(pc19.green(`  Found ${segmentFiles.length} fragment files`));
+  }
+  let componentsToEnhance;
+  if (component && component !== "all") {
+    componentsToEnhance = [component];
+  } else {
+    componentsToEnhance = segmentFiles.map((f) => extractComponentName(f));
+  }
+  if (isInteractive) {
+    console.log(pc19.dim("Phase 4: Extracting props from TypeScript interfaces..."));
+  }
+  const propsExtractions = /* @__PURE__ */ new Map();
+  for (const compName of componentsToEnhance) {
+    const segmentFile = segmentFiles.find((f) => extractComponentName(f) === compName);
+    if (!segmentFile) continue;
+    const segmentDir = segmentFile.replace(/\.segment\.(tsx?|jsx?)$/, "");
+    const possiblePaths = [
+      `${segmentDir}.tsx`,
+      `${segmentDir}.ts`,
+      `${segmentDir}/index.tsx`,
+      `${segmentDir}/index.ts`,
+      join9(rootDir, "src", "components", `${compName}.tsx`),
+      join9(rootDir, "src", "components", compName, `${compName}.tsx`),
+      join9(rootDir, "src", "components", compName, "index.tsx")
+    ];
+    for (const srcPath of possiblePaths) {
+      try {
+        const fs = await import("fs");
+        if (fs.existsSync(srcPath)) {
+          const extraction = await extractPropsFromFile(srcPath, {
+            propsTypeName: `${compName}Props`
+          });
+          if (extraction.success) {
+            propsExtractions.set(compName, extraction);
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (isInteractive) {
+    const propsCount = Array.from(propsExtractions.values()).reduce((sum, ext) => sum + ext.props.length, 0);
+    console.log(pc19.green(`  Extracted ${propsCount} props from ${propsExtractions.size} component files`));
+  }
+  const renderedVariants = /* @__PURE__ */ new Map();
+  if (renderVariants) {
+    if (isInteractive) {
+      console.log(pc19.dim("Phase 5: Rendering variants from Storybook..."));
+    }
+    const storybookRunning = await checkStorybookRunning(storybookUrl);
+    if (!storybookRunning) {
+      if (isInteractive) {
+        console.log(pc19.yellow(`  Storybook not running at ${storybookUrl}. Skipping variant rendering.`));
+        console.log(pc19.dim(`  Start Storybook with: npm run storybook (or yarn storybook)`));
+      }
+    } else {
+      let totalVariants = 0;
+      let failedVariants = 0;
+      for (const compName of componentsToEnhance) {
+        try {
+          const result = await renderAllComponentVariants(storybookUrl, compName);
+          if (result.variants.length > 0) {
+            renderedVariants.set(compName, result.variants);
+            totalVariants += result.variants.length;
+          }
+          failedVariants += result.failed.length;
+        } catch (err) {
+          if (isInteractive) {
+            console.log(pc19.dim(`  ${compName}: Failed to render (${err.message})`));
+          }
+        }
+      }
+      if (isInteractive) {
+        if (totalVariants > 0) {
+          console.log(pc19.green(`  Rendered ${totalVariants} variants from ${renderedVariants.size} components`));
+        }
+        if (failedVariants > 0) {
+          console.log(pc19.yellow(`  ${failedVariants} variant(s) failed to render`));
+        }
+      }
+      await shutdownSharedPool();
+    }
+  }
+  const contexts = [];
+  for (const compName of componentsToEnhance) {
+    const analysis = usageAnalysis.components[compName];
+    const stories = storyFiles.get(compName);
+    const segmentFile = segmentFiles.find((f) => extractComponentName(f) === compName);
+    const propsExtraction = propsExtractions.get(compName);
+    if (!segmentFile) continue;
+    const context2 = generateComponentContext(
+      compName,
+      analysis,
+      void 0,
+      stories,
+      propsExtraction
+    );
+    contexts.push({ name: compName, context: context2, segmentFile });
+  }
+  if (isContextMode) {
+    return handleContextOnlyMode(contexts, format, isInteractive);
+  }
+  if (isInteractive) {
+    console.log(pc19.dim(`
+Phase 6: Generating AI enhancements for ${componentsToEnhance.length} component(s)...
+`));
+  }
+  const enhanced = [];
+  let totalTokens = 0;
+  const aiClient = await createAIClient(provider, apiKey);
+  for (const { name: compName, context: context2, segmentFile } of contexts) {
+    if (!context2.usageAnalysis || context2.usageAnalysis.totalUsages < 2) {
+      enhanced.push({
+        componentName: compName,
+        added: { when: [], whenNot: [] },
+        confidence: 0,
+        tokensUsed: 0,
+        skipped: true,
+        reason: context2.usageAnalysis?.totalUsages === 1 ? "Only 1 usage found" : "No usage data found"
+      });
+      if (isInteractive) {
+        console.log(pc19.dim(`  ${compName}: Skipped (insufficient data)`));
+      }
+      continue;
+    }
+    if (isInteractive) {
+      process.stdout.write(`  ${compName}: Generating...`);
+    }
+    try {
+      const result = await generateEnhancement(aiClient, provider, model, context2);
+      enhanced.push({
+        componentName: compName,
+        added: result.suggestions,
+        confidence: result.confidence,
+        tokensUsed: result.tokensUsed,
+        skipped: false
+      });
+      totalTokens += result.tokensUsed;
+      if (isInteractive) {
+        process.stdout.write(`\r  ${compName}: ${pc19.green("Done")} (${result.suggestions.when.length} when, ${result.suggestions.whenNot.length} whenNot)
+`);
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      enhanced.push({
+        componentName: compName,
+        added: { when: [], whenNot: [] },
+        confidence: 0,
+        tokensUsed: 0,
+        skipped: true,
+        reason: `AI error: ${msg}`
+      });
+      if (isInteractive) {
+        process.stdout.write(`\r  ${compName}: ${pc19.red("Failed")} - ${msg}
+`);
+      }
+    }
+  }
+  const estimatedCost = calculateCost(provider, totalTokens);
+  if (!dryRun) {
+    if (isInteractive) {
+      console.log(pc19.dim("\nPhase 7: Updating segment files..."));
+    }
+    for (const result of enhanced) {
+      if (result.skipped || result.added.when.length === 0 && result.added.whenNot.length === 0) {
+        continue;
+      }
+      const segmentFile = segmentFiles.find((f) => extractComponentName(f) === result.componentName);
+      if (!segmentFile) continue;
+      try {
+        await updateSegmentFile(segmentFile, result.added);
+        if (isInteractive) {
+          console.log(pc19.green(`  Updated: ${relative7(rootDir, segmentFile)}`));
+        }
+      } catch {
+        if (isInteractive) {
+          console.log(pc19.red(`  Failed to update: ${relative7(rootDir, segmentFile)}`));
+        }
+      }
+    }
+  }
+  const successCount = enhanced.filter((e) => !e.skipped).length;
+  if (format === "json") {
+    console.log(JSON.stringify({
+      success: true,
+      enhanced,
+      totalTokens,
+      estimatedCost
+    }, null, 2));
+  } else if (isInteractive) {
+    console.log();
+    console.log(pc19.bold("Summary:"));
+    console.log(`  Components processed: ${componentsToEnhance.length}`);
+    console.log(`  Successfully enhanced: ${successCount}`);
+    console.log(`  Skipped: ${enhanced.filter((e) => e.skipped).length}`);
+    console.log(`  Total tokens used: ${totalTokens}`);
+    console.log(`  Estimated cost: $${estimatedCost.toFixed(4)}`);
+    if (dryRun) {
+      console.log();
+      console.log(pc19.yellow("Dry run - no files were modified"));
+    }
+    console.log();
+  }
+  return {
+    success: true,
+    enhanced,
+    totalTokens,
+    estimatedCost
+  };
+}
+function handleContextOnlyMode(contexts, format, isInteractive) {
+  const systemPrompt = generateSystemPrompt();
+  const componentContexts = [];
+  for (const { name, context: context2 } of contexts) {
+    if (!context2.usageAnalysis || context2.usageAnalysis.totalUsages < 2) {
+      continue;
+    }
+    componentContexts.push(generatePromptContext(context2));
+  }
+  if (componentContexts.length === 0) {
+    if (format === "json") {
+      console.log(JSON.stringify({ success: false, error: "No components with sufficient usage data" }));
+    } else if (isInteractive) {
+      console.log(pc19.yellow("\nNo components with sufficient usage data to analyze."));
+    }
+    return { success: false, enhanced: [], totalTokens: 0, estimatedCost: 0 };
+  }
+  const fullContext = `${systemPrompt}
+
+---
+
+${componentContexts.join("\n\n---\n\n")}
+
+---
+
+Based on the usage analysis above, generate "when" and "whenNot" documentation for each component.
+
+For each component, provide your response in JSON format:
+\`\`\`json
+{
+  "componentName": "...",
+  "when": ["scenario 1", "scenario 2", ...],
+  "whenNot": ["anti-pattern 1", ...]
+}
+\`\`\``;
+  if (format === "json") {
+    console.log(JSON.stringify({
+      success: true,
+      context: fullContext,
+      instructions: "Copy this prompt into your IDE AI (Cursor, Copilot, etc.) to generate suggestions"
+    }, null, 2));
+  } else {
+    console.log(pc19.bold("\n\u{1F4CB} AI Context Generated\n"));
+    console.log(pc19.dim("Copy the following prompt into your IDE AI (Cursor, Copilot, etc.):\n"));
+    console.log(pc19.dim("\u2500".repeat(60)));
+    console.log(fullContext);
+    console.log(pc19.dim("\u2500".repeat(60)));
+    console.log();
+    console.log(pc19.green("Tip: In Cursor, press Cmd+L to open chat and paste this prompt."));
+    console.log(pc19.dim("After getting suggestions, manually update your segment files."));
+    console.log();
+  }
+  return {
+    success: true,
+    enhanced: [],
+    totalTokens: 0,
+    estimatedCost: 0,
+    context: fullContext
+  };
+}
+function detectProvider(options) {
+  if (options.contextOnly) return "none";
+  if (options.provider) return options.provider;
+  if (options.apiKey) {
+    if (options.apiKey.startsWith("sk-ant-")) return "anthropic";
+    if (options.apiKey.startsWith("sk-")) return "openai";
+  }
+  if (process.env.ANTHROPIC_API_KEY) return "anthropic";
+  if (process.env.OPENAI_API_KEY) return "openai";
+  return "none";
+}
+function getApiKey(provider, explicitKey) {
+  if (explicitKey) return explicitKey;
+  if (provider === "anthropic") return process.env.ANTHROPIC_API_KEY;
+  if (provider === "openai") return process.env.OPENAI_API_KEY;
+  return void 0;
+}
+async function createAIClient(provider, apiKey) {
+  if (provider === "anthropic") {
+    const Anthropic = (await import("@anthropic-ai/sdk")).default;
+    return new Anthropic({ apiKey });
+  }
+  if (provider === "openai") {
+    const OpenAI = (await import("openai")).default;
+    return new OpenAI({ apiKey });
+  }
+  throw new Error(`Unknown provider: ${provider}`);
+}
+async function generateEnhancement(client, provider, model, context2) {
+  const systemPrompt = generateSystemPrompt();
+  const userPrompt = generateUserPrompt(context2);
+  if (provider === "anthropic") {
+    return generateWithAnthropic(client, model, systemPrompt, userPrompt, context2);
+  }
+  if (provider === "openai") {
+    return generateWithOpenAI(client, model, systemPrompt, userPrompt, context2);
+  }
+  throw new Error(`Unknown provider: ${provider}`);
+}
+async function generateWithAnthropic(client, model, systemPrompt, userPrompt, context2) {
+  const anthropic = client;
+  const response = await anthropic.messages.create({
+    model,
+    max_tokens: 1024,
+    system: systemPrompt,
+    messages: [{ role: "user", content: userPrompt }]
+  });
+  const content = response.content[0];
+  if (content.type !== "text") {
+    throw new Error("Unexpected response type");
+  }
+  const suggestions = parseAIResponse(content.text);
+  const tokensUsed = (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0);
+  return {
+    suggestions,
+    confidence: calculateConfidence2(context2, suggestions),
+    tokensUsed
+  };
+}
+async function generateWithOpenAI(client, model, systemPrompt, userPrompt, context2) {
+  const openai = client;
+  const response = await openai.chat.completions.create({
+    model,
+    max_tokens: 1024,
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt }
+    ]
+  });
+  const content = response.choices[0]?.message?.content;
+  if (!content) {
+    throw new Error("No response from OpenAI");
+  }
+  const suggestions = parseAIResponse(content);
+  const tokensUsed = (response.usage?.prompt_tokens || 0) + (response.usage?.completion_tokens || 0);
+  return {
+    suggestions,
+    confidence: calculateConfidence2(context2, suggestions),
+    tokensUsed
+  };
+}
+function parseAIResponse(text) {
+  try {
+    const jsonMatch = text.match(/```json\n?([\s\S]*?)\n?```/) || text.match(/\{[\s\S]*\}/);
+    const jsonStr = jsonMatch ? jsonMatch[1] || jsonMatch[0] : text;
+    const parsed = JSON.parse(jsonStr);
+    return {
+      when: Array.isArray(parsed.when) ? parsed.when : [],
+      whenNot: Array.isArray(parsed.whenNot) ? parsed.whenNot : []
+    };
+  } catch {
+    return extractSuggestionsFromText(text);
+  }
+}
+function extractSuggestionsFromText(text) {
+  const when = [];
+  const whenNot = [];
+  const lines = text.split("\n");
+  let currentSection = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^(when|use when|when to use)/i.test(trimmed)) {
+      currentSection = "when";
+      continue;
+    }
+    if (/^(when not|do not use|avoid|whenNot)/i.test(trimmed)) {
+      currentSection = "whenNot";
+      continue;
+    }
+    if (currentSection && /^[-*]\s+/.test(trimmed)) {
+      const item = trimmed.replace(/^[-*]\s+/, "").trim();
+      if (item && item.length > 10) {
+        if (currentSection === "when") {
+          when.push(item);
+        } else {
+          whenNot.push(item);
+        }
+      }
+    }
+  }
+  return { when, whenNot };
+}
+function calculateConfidence2(context2, suggestions) {
+  let confidence = 50;
+  if (context2.usageAnalysis.totalUsages > 10) confidence += 20;
+  if (context2.storybook && context2.storybook.stories.length > 0) confidence += 15;
+  if (suggestions.when.length >= 2) confidence += 10;
+  if (suggestions.whenNot.length >= 1) confidence += 5;
+  return Math.min(confidence, 100);
+}
+function calculateCost(provider, tokens) {
+  const costsPer1M = {
+    anthropic: 3,
+    // Claude Sonnet
+    openai: 5,
+    // GPT-4o
+    none: 0
+  };
+  return tokens / 1e6 * costsPer1M[provider];
+}
+async function findSegmentFiles(dir) {
+  const fg4 = await import("fast-glob");
+  return fg4.default(["**/*.segment.tsx", "**/*.segment.ts"], {
+    cwd: dir,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+}
+function extractComponentName(filePath) {
+  const match = filePath.match(/([^/\\]+)\.segment\.(tsx?|jsx?)$/);
+  return match ? match[1] : "";
+}
+async function updateSegmentFile(filePath, suggestions) {
+  const content = await readFile5(filePath, "utf-8");
+  let updated = content;
+  if (suggestions.when.length > 0) {
+    const whenItems = suggestions.when.map((s) => `    "${s}"`).join(",\n");
+    const whenMatch = updated.match(/when:\s*\[\s*([^\]]*)\]/);
+    if (whenMatch) {
+      const existingContent = whenMatch[1].trim();
+      if (existingContent) {
+        updated = updated.replace(
+          /when:\s*\[\s*([^\]]*)\]/,
+          `when: [
+${existingContent},
+${whenItems}
+  ]`
+        );
+      } else {
+        updated = updated.replace(
+          /when:\s*\[\s*\]/,
+          `when: [
+${whenItems}
+  ]`
+        );
+      }
+    }
+  }
+  if (suggestions.whenNot.length > 0) {
+    const whenNotItems = suggestions.whenNot.map((s) => `    "${s}"`).join(",\n");
+    const whenNotMatch = updated.match(/whenNot:\s*\[\s*([^\]]*)\]/);
+    if (whenNotMatch) {
+      const existingContent = whenNotMatch[1].trim();
+      if (existingContent) {
+        updated = updated.replace(
+          /whenNot:\s*\[\s*([^\]]*)\]/,
+          `whenNot: [
+${existingContent},
+${whenNotItems}
+  ]`
+        );
+      } else {
+        updated = updated.replace(
+          /whenNot:\s*\[\s*\]/,
+          `whenNot: [
+${whenNotItems}
+  ]`
+        );
+      }
+    }
+  }
+  if (updated !== content) {
+    await writeFile7(filePath, updated, "utf-8");
+  }
+}
+
+// src/bin.ts
+var program = new Command();
+program.name(BRAND.cliCommand).description(`${BRAND.name} - Design system documentation and compliance tool`).version("0.1.0");
+program.command("validate").description("Validate fragment files").option("-c, --config <path>", "Path to config file").option("--schema", "Validate fragment schema only").option("--coverage", "Validate coverage only").action(async (options) => {
+  try {
+    const result = await validate(options);
+    if (!result.valid) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("build").description(`Build compiled ${BRAND.outFile} and ${BRAND.dataDir}/ directory`).option("-c, --config <path>", "Path to config file").option("-o, --output <path>", "Output file path").option("--registry", `Also generate ${BRAND.dataDir}/${BRAND.registryFile} and ${BRAND.contextFile}`).option("--registry-only", `Only generate ${BRAND.dataDir}/ directory (skip ${BRAND.outFile})`).option("--from-source", "Build from source code (zero-config, no fragment files needed)").option("--skip-usage", "Skip usage analysis when building from source").option("--skip-storybook", "Skip Storybook parsing when building from source").option("-v, --verbose", "Verbose output").action(async (options) => {
+  try {
+    const result = await build({
+      config: options.config,
+      output: options.output,
+      registry: options.registry,
+      registryOnly: options.registryOnly,
+      fromSource: options.fromSource,
+      skipUsage: options.skipUsage,
+      skipStorybook: options.skipStorybook,
+      verbose: options.verbose
+    });
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("context").description("Generate AI-ready context for your design system").option("-c, --config <path>", "Path to config file").option("-i, --input <path>", `Path to ${BRAND.outFile} (builds if not provided)`).option("-f, --format <format>", "Output format (markdown/json)", "markdown").option("--compact", "Minimal output for token efficiency").option("--code", "Include code examples").option("--relations", "Include component relationships").option("--tokens", "Only output token estimate").action(async (options) => {
+  try {
+    const result = await context({
+      config: options.config,
+      input: options.input,
+      format: options.format,
+      compact: options.compact,
+      includeCode: options.code,
+      includeRelations: options.relations,
+      tokensOnly: options.tokens
+    });
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("ai").description("Generate context optimized for AI assistants (Claude Desktop)").option("-c, --config <path>", "Path to config file").option("--live", "Connect to running dev server for live data").option("-p, --port <port>", "Dev server port", "6006").action(async (options) => {
+  try {
+    if (options.live) {
+      const baseUrl = `http://localhost:${options.port}`;
+      const response = await fetch(`${baseUrl}/${BRAND.nameLower}/context?format=markdown`);
+      if (!response.ok) {
+        throw new Error("Failed to fetch context. Make sure dev server is running.");
+      }
+      const contextContent = await response.text();
+      console.log(contextContent);
+    } else {
+      const result = await context({
+        config: options.config,
+        format: "markdown",
+        compact: false,
+        includeCode: true,
+        includeRelations: true
+      });
+      if (!result.success) {
+        process.exit(1);
+      }
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("list").description("List all discovered fragment files").option("-c, --config <path>", "Path to config file").action(async (options) => {
+  try {
+    await list(options);
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("reset").description("Reset to initial state (delete all generated files)").option("-y, --yes", "Skip confirmation prompt").option("--dry-run", "Show what would be deleted without deleting").action(async (options) => {
+  try {
+    await reset(options);
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+var linkCommand = program.command("link").description("Link external resources (Figma designs, Storybook stories) to fragments");
+linkCommand.command("figma").argument("[figma-url]", "Figma file URL to link components from").description("Interactive wizard to link Figma components to code").option("-c, --config <path>", "Path to config file").option("--auto", "Auto-link matching components without prompts").option("--dry-run", "Show matches without updating files").option("--no-variants", "Skip linking individual variants to their Figma frames").action(async (figmaUrl, options) => {
+  try {
+    await linkFigma(figmaUrl, {
+      config: options.config,
+      auto: options.auto,
+      dryRun: options.dryRun,
+      variants: options.variants
+    });
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+linkCommand.command("storybook").description("Bootstrap fragments from existing Storybook stories").option("-c, --config <path>", "Path to .storybook/main.* config").option("-o, --out <dir>", "Output directory for fragment files").option("--yes", "Skip confirmation prompts").option("--dry-run", "Preview what would be generated without writing files").option("--include <glob>", "Only process stories matching glob").option("--exclude <glob>", "Skip stories matching glob").action(async (options) => {
+  try {
+    await linkStorybook({
+      config: options.config,
+      out: options.out,
+      yes: options.yes,
+      dryRun: options.dryRun,
+      include: options.include,
+      exclude: options.exclude
+    });
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("dev").description("Start the development server with live component rendering").option("-p, --port <port>", "Port to run on", "6006").option("--no-open", "Do not open browser").option("--skip-setup", "Skip auto-setup (Storybook import, build, Figma link)").option("--skip-storybook", "Skip auto-importing from Storybook").option("--skip-figma", "Skip Figma link check").option("--skip-build", `Skip auto-building ${BRAND.outFile}`).action(async (options) => {
+  try {
+    await dev({
+      port: options.port,
+      open: options.open,
+      skipSetup: options.skipSetup,
+      skipStorybook: options.skipStorybook,
+      skipFigma: options.skipFigma,
+      skipBuild: options.skipBuild
+    });
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    if (error instanceof Error && error.stack) {
+      console.error(pc20.dim(error.stack));
+    }
+    process.exit(1);
+  }
+});
+program.command("screenshot").description("Capture screenshots of component variants").option("-c, --config <path>", "Path to config file").option("--component <name>", "Capture specific component only").option("--variant <name>", "Capture specific variant only").option("--theme <theme>", "Theme to capture (light/dark)", "light").option("--update", "Update existing baselines").option("--width <pixels>", "Viewport width", parseInt).option("--height <pixels>", "Viewport height", parseInt).option("--ci", "CI mode - no interactive prompts").action(async (options) => {
+  try {
+    const { config, configDir } = await loadConfig(options.config);
+    const result = await runScreenshotCommand(config, configDir, {
+      component: options.component,
+      variant: options.variant,
+      theme: options.theme,
+      update: options.update,
+      ci: options.ci,
+      width: options.width,
+      height: options.height
+    });
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("diff").argument("[component]", "Component name to diff (optional)").description("Compare current renders against baselines").option("-c, --config <path>", "Path to config file").option("--variant <name>", "Compare specific variant only").option("--theme <theme>", "Theme to compare (light/dark)", "light").option("--threshold <percent>", "Diff threshold percentage", parseFloat).option("--ci", "CI mode - exit 1 on differences").option("--open", "Open diff images").action(async (component, options) => {
+  try {
+    const { config, configDir } = await loadConfig(options.config);
+    const result = await runDiffCommand(config, configDir, {
+      component,
+      variant: options.variant,
+      theme: options.theme,
+      threshold: options.threshold,
+      ci: options.ci,
+      open: options.open
+    });
+    if (!result.success && options.ci) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("compare").argument("[component]", "Component name to compare").description("Compare component renders against Figma designs").option("-c, --config <path>", "Path to config file").option("--variant <name>", "Compare specific variant").option("--figma <url>", "Figma frame URL (uses fragment figma link if not provided)").option("--threshold <percent>", "Diff threshold percentage", parseFloat, 1).option("--all", "Compare all components with Figma links").option("--output <dir>", "Save diff images to directory").option("-p, --port <port>", "Dev server port", "6006").action(async (component, options) => {
+  try {
+    const result = await compare(component, {
+      config: options.config,
+      variant: options.variant,
+      figma: options.figma,
+      threshold: options.threshold,
+      all: options.all,
+      output: options.output,
+      port: options.port
+    });
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    console.log(pc20.dim(`
+Make sure the dev server is running: ${BRAND.cliCommand} dev`));
+    process.exit(1);
+  }
+});
+program.command("analyze").description("Analyze design system and generate report").option("-c, --config <path>", "Path to config file").option("-f, --format <format>", "Output format (html/json/console)", "html").option("-o, --output <path>", "Output file path").option("--open", "Open report in browser after generation").option("--ci", "CI mode - exit with code based on score").option("--min-score <score>", "Minimum score to pass in CI mode", parseFloat).action(async (options) => {
+  try {
+    const { config, configDir } = await loadConfig(options.config);
+    const result = await runAnalyzeCommand(config, configDir, {
+      format: options.format,
+      output: options.output,
+      open: options.open,
+      ci: options.ci,
+      minScore: options.minScore
+    });
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("verify").argument("[component]", "Component name to verify (optional, verifies all if omitted)").description("Verify component compliance for CI pipelines").option("-c, --config <path>", "Path to config file").option("--ci", "CI mode - output JSON and exit non-zero on failure").option("--min-compliance <percent>", "Minimum compliance percentage (default: 80)", parseFloat, 80).option("-p, --port <port>", "Dev server port", "6006").action(async (component, options) => {
+  try {
+    const summary = await verify(component, {
+      config: options.config,
+      ci: options.ci,
+      minCompliance: options.minCompliance,
+      port: options.port
+    });
+    if (!summary.passed && options.ci) {
+      process.exit(1);
+    }
+  } catch (error) {
+    if (options.ci) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : "Verification failed" }));
+    } else {
+      console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    }
+    process.exit(1);
+  }
+});
+program.command("audit").description("Scan all fragments and show compliance metrics across the design system").option("-c, --config <path>", "Path to config file").option("--json", "Output machine-readable JSON format").option("--sort <field>", "Sort by field: compliance, name, hardcoded (default: compliance)", "compliance").option("-p, --port <port>", "Dev server port", "6006").action(async (options) => {
+  try {
+    await audit({
+      config: options.config,
+      json: options.json,
+      sort: options.sort,
+      port: options.port
+    });
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : "Audit failed" }));
+    } else {
+      console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    }
+    process.exit(1);
+  }
+});
+program.command("a11y").description("Run accessibility checks on all component variants").option("-c, --config <path>", "Path to config file").option("--json", "Output results as JSON").option("--ci", "CI mode (exit code 1 if any critical/serious violations)").option("--component <name>", "Check specific component only").option("-p, --port <port>", "Dev server port", "6006").action(async (options) => {
+  try {
+    await a11y({
+      config: options.config,
+      json: options.json,
+      ci: options.ci,
+      component: options.component,
+      port: options.port
+    });
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : "A11y check failed" }));
+    } else {
+      console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    }
+    process.exit(1);
+  }
+});
+program.command("enhance").description("AI-powered documentation generation from codebase analysis").option("-c, --config <path>", "Path to config file").option("--component <name>", 'Enhance specific component (or "all")').option("--yes", "Skip confirmation prompts").option("--dry-run", "Only analyze, do not modify files").option("--format <format>", "Output format: interactive, json, quiet, context", "interactive").option("--provider <provider>", "AI provider: anthropic, openai (auto-detected from API key)").option("--api-key <key>", "API key (or use ANTHROPIC_API_KEY/OPENAI_API_KEY env)").option("--model <model>", "AI model to use (default: claude-sonnet-4 for anthropic, gpt-4o for openai)").option("--root <dir>", "Root directory to scan", process.cwd()).option("--context-only", "Output context for IDE AI (Cursor, Copilot) without calling API").action(async (options) => {
+  try {
+    await enhance({
+      config: options.config,
+      component: options.component,
+      yes: options.yes,
+      dryRun: options.dryRun,
+      format: options.format,
+      provider: options.provider,
+      apiKey: options.apiKey,
+      model: options.model,
+      root: options.root,
+      contextOnly: options.contextOnly
+    });
+  } catch (error) {
+    if (options.format === "json") {
+      console.log(JSON.stringify({ success: false, error: error instanceof Error ? error.message : "Enhance failed" }));
+    } else {
+      console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    }
+    process.exit(1);
+  }
+});
+program.command("scan").description(`Zero-config ${BRAND.outFile} generation from source code`).option("-c, --config <path>", "Path to config file").option("-o, --output <path>", "Output file path", BRAND.outFile).option("--patterns <patterns...>", "Component file patterns to scan").option("--barrel <files...>", "Barrel export files to parse").option("--usage-dir <dir>", "Directory to scan for usage patterns").option("--skip-usage", "Skip usage pattern analysis").option("--skip-storybook", "Skip Storybook story parsing").option("-v, --verbose", "Verbose output").action(async (options) => {
+  try {
+    const result = await scan({
+      config: options.config,
+      output: options.output,
+      componentPatterns: options.patterns,
+      barrelFiles: options.barrel,
+      usageDir: options.usageDir,
+      skipUsage: options.skipUsage,
+      skipStorybook: options.skipStorybook,
+      verbose: options.verbose
+    });
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("storygen").description("Generate Storybook stories from fragment definitions").option("-c, --config <path>", "Path to config file").option("-o, --output <dir>", "Output directory", ".storybook/generated").option("--watch", "Watch for segment changes and regenerate").option("--format <format>", "Story format (csf3)", "csf3").action(async (options) => {
+  try {
+    await storygen({
+      config: options.config,
+      output: options.output,
+      watch: options.watch,
+      format: options.format
+    });
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("metrics").argument("[component]", "Component name (optional, shows system-wide if omitted)").description("View compliance trends over time").option("-c, --config <path>", "Path to config file").option("--days <number>", "Number of days to look back", parseInt, 30).option("--json", "Output JSON format").action(async (component, options) => {
+  try {
+    await metrics(component, {
+      config: options.config,
+      days: options.days,
+      json: options.json
+    });
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("baseline").description("Manage visual regression baselines").argument("<action>", "Action to perform: update, list, delete").argument("[component]", "Component name (optional for update/delete)").option("-c, --config <path>", "Path to config file").option("--variant <name>", "Specific variant to update").option("--all", "Update/delete all baselines").option("--theme <theme>", "Theme for baseline (light/dark)", "light").option("-p, --port <port>", "Dev server port", "6006").action(async (action, component, options) => {
+  try {
+    await baseline(action, component, {
+      config: options.config,
+      variant: options.variant,
+      all: options.all,
+      theme: options.theme,
+      port: options.port
+    });
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    if (action === "update") {
+      console.log(pc20.dim(`
+Make sure the dev server is running: ${BRAND.cliCommand} dev`));
+    }
+    process.exit(1);
+  }
+});
+program.command("view").description(`Generate a static HTML viewer for ${BRAND.outFile}`).option("-i, --input <path>", `Path to ${BRAND.outFile}`, BRAND.outFile).option("-o, --output <path>", "Output HTML file path", BRAND.viewerHtmlFile).option("--open", "Open in browser after generation").action(async (options) => {
+  try {
+    const { generateViewerFromJson } = await import("./static-viewer-MIPGZ4Z7.js");
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const inputPath = path.resolve(process.cwd(), options.input);
+    const outputPath = path.resolve(process.cwd(), options.output);
+    console.log(pc20.cyan(`
+${BRAND.name} Viewer Generator
+`));
+    try {
+      await fs.access(inputPath);
+    } catch {
+      console.log(pc20.red(`Error: ${options.input} not found.`));
+      console.log(pc20.dim(`
+Run ${pc20.cyan(`${BRAND.cliCommand} build`)} first to generate ${BRAND.outFile}
+`));
+      process.exit(1);
+    }
+    console.log(pc20.dim(`Reading: ${options.input}`));
+    const html = await generateViewerFromJson(inputPath);
+    await fs.writeFile(outputPath, html);
+    console.log(pc20.green(`
+\u2713 Generated: ${options.output}
+`));
+    if (options.open) {
+      const { exec } = await import("child_process");
+      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      exec(`${openCmd} "${outputPath}"`);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("add").argument("[name]", 'Component name (e.g., "Button", "TextField")').description("Scaffold a new component with fragment file").option("-c, --category <category>", "Component category").option("-d, --dir <directory>", "Output directory").option("-t, --template <template>", "Template to use (action, form-input, layout, display)").option("--no-component", "Only generate fragment file, skip component stub").action(async (name, options) => {
+  try {
+    await add(name, {
+      category: options.category,
+      dir: options.dir,
+      template: options.template,
+      component: options.component
+    });
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("init").description("Initialize fragments in a project (interactive by default)").option("--force", "Overwrite existing config").option("-y, --yes", "Non-interactive mode - auto-detect and use defaults").action(async (options) => {
+  try {
+    const { init } = await import("./init-EMVI47QG.js");
+    const result = await init({
+      projectRoot: process.cwd(),
+      force: options.force,
+      yes: options.yes
+    });
+    if (!result.success) {
+      console.error(pc20.red("\nInit failed with errors:"));
+      for (const error of result.errors) {
+        console.error(pc20.red(`  - ${error}`));
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("tokens").description("Discover and list design tokens from CSS/SCSS files").option("-c, --config <path>", "Path to config file").option("--json", "Output as JSON").option("--categories", "Group tokens by category").option("--theme <theme>", "Filter by theme name").option("--category <category>", "Filter by category (color, spacing, typography, etc.)").option("--verbose", "Show all tokens (no truncation)").action(async (options) => {
+  try {
+    const { tokens } = await import("./tokens-HSGMYK64.js");
+    const result = await tokens({
+      config: options.config,
+      json: options.json,
+      categories: options.categories,
+      theme: options.theme,
+      category: options.category,
+      verbose: options.verbose
+    });
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("generate").description("Generate fragment files from component source code").argument("[component]", "Specific component name to generate (optional)").option("--force", "Overwrite existing fragment files").option("--pattern <glob>", "Pattern for component files", "src/components/**/*.tsx").action(async (component, options) => {
+  try {
+    const { generate } = await import("./generate-4LQNJ7SX.js");
+    const result = await generate({
+      projectRoot: process.cwd(),
+      component,
+      force: options.force,
+      componentPattern: options.pattern
+    });
+    if (!result.success) {
+      console.error(pc20.red("\nGenerate completed with errors"));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("test").description("Run interaction tests for fragments with play functions").option("-c, --config <path>", "Path to config file").option("--component <name>", "Filter by component name").option("--tags <tags>", "Filter by tags (comma-separated)").option("--grep <pattern>", "Filter by variant name pattern").option("--exclude <pattern>", "Exclude tests matching pattern").option("--parallel <count>", "Number of parallel browser contexts", parseInt, 4).option("--timeout <ms>", "Timeout per test in milliseconds", parseInt, 3e4).option("--retries <count>", "Number of retries for failed tests", parseInt, 0).option("--bail", "Stop on first failure").option("--browser <name>", "Browser to use (chromium, firefox, webkit)", "chromium").option("--headed", "Run in headed mode (show browser)").option("--a11y", "Run accessibility checks with axe-core").option("--visual", "Capture screenshots for visual regression").option("--update-snapshots", "Update visual snapshots").option("--watch", "Watch mode - re-run on file changes").option("--reporters <names>", "Reporters to use (console, junit, json)", "console").option("-o, --output <dir>", "Output directory for results", "./test-results").option("--server-url <url>", "URL of running dev server (skips starting server)").option("-p, --port <port>", "Port for dev server", parseInt, 6006).option("--ci", "CI mode - non-interactive, exit with code 1 on failure").option("--list", "List available tests without running them").action(async (options) => {
+  try {
+    const { config, configDir } = await loadConfig(options.config);
+    const { runTestCommand, listTests } = await import("./test-SQ5ZHXWU.js");
+    if (options.list) {
+      await listTests(config, configDir, {
+        component: options.component,
+        tags: options.tags,
+        grep: options.grep,
+        exclude: options.exclude
+      });
+      return;
+    }
+    const exitCode = await runTestCommand(config, configDir, {
+      component: options.component,
+      tags: options.tags,
+      grep: options.grep,
+      exclude: options.exclude,
+      parallel: options.parallel,
+      timeout: options.timeout,
+      retries: options.retries,
+      bail: options.bail,
+      browser: options.browser,
+      headless: !options.headed,
+      a11y: options.a11y,
+      visual: options.visual,
+      updateSnapshots: options.updateSnapshots,
+      watch: options.watch,
+      reporters: options.reporters,
+      output: options.output,
+      serverUrl: options.serverUrl,
+      port: options.port,
+      ci: options.ci
+    });
+    process.exit(exitCode);
+  } catch (error) {
+    console.error(pc20.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=bin.js.map