@fragments-sdk/cli 0.5.2 → 0.7.0

package/dist/chunk-U4GQ2JTD.js

@@ -1,832 +0,0 @@
-import { createRequire } from 'module'; const require = createRequire(import.meta.url);
-import {
-  BrowserPool,
-  CaptureEngine,
-  DiffEngine,
-  StorageManager,
-  analyzeDesignSystem,
-  formatMs,
-  generateHtmlReport,
-  getGrade
-} from "./chunk-IOJE35DZ.js";
-import {
-  discoverBlockFiles,
-  discoverComponentFiles,
-  discoverSegmentFiles,
-  discoverTokenFiles,
-  extractComponentName,
-  generateContextMd,
-  generateRegistry,
-  loadSegmentFile,
-  parseSegmentFile
-} from "./chunk-2H2JAA3U.js";
-import {
-  compileBlock,
-  parseTokenFile
-} from "./chunk-V7YLRR4C.js";
-import {
-  BRAND,
-  DEFAULTS,
-  segmentDefinitionSchema
-} from "./chunk-ICAIQ57V.js";
-
-// src/validators.ts
-async function validateSchema(config, configDir) {
-  const files = await discoverSegmentFiles(config, configDir);
-  const errors = [];
-  const warnings = [];
-  for (const file of files) {
-    try {
-      const segment = await loadSegmentFile(file.absolutePath);
-      if (!segment) {
-        errors.push({
-          file: file.relativePath,
-          message: "No default export found",
-          details: `Segment files must have a default export from defineSegment()`
-        });
-        continue;
-      }
-      const result = segmentDefinitionSchema.safeParse(segment);
-      if (!result.success) {
-        const details = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
-        errors.push({
-          file: file.relativePath,
-          message: "Invalid segment schema",
-          details
-        });
-      }
-    } catch (error) {
-      errors.push({
-        file: file.relativePath,
-        message: "Failed to load segment file",
-        details: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-async function validateCoverage(config, configDir) {
-  const segmentFiles = await discoverSegmentFiles(config, configDir);
-  const componentFiles = await discoverComponentFiles(config, configDir);
-  const errors = [];
-  const warnings = [];
-  const documentedComponents = /* @__PURE__ */ new Set();
-  for (const file of segmentFiles) {
-    try {
-      const segment = await loadSegmentFile(file.absolutePath);
-      if (segment?.meta?.name) {
-        documentedComponents.add(segment.meta.name);
-      }
-    } catch {
-    }
-  }
-  for (const file of componentFiles) {
-    const componentName = extractComponentName(file.relativePath);
-    const segmentPath = file.relativePath.replace(
-      /\.(tsx?|jsx?)$/,
-      BRAND.fileExtension
-    );
-    const hasSegmentFile = segmentFiles.some(
-      (s) => s.relativePath === segmentPath
-    );
-    if (!hasSegmentFile && !documentedComponents.has(componentName)) {
-      warnings.push({
-        file: file.relativePath,
-        message: `Component "${componentName}" has no segment documentation`
-      });
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-async function validateAll(config, configDir) {
-  const [schemaResult, coverageResult] = await Promise.all([
-    validateSchema(config, configDir),
-    validateCoverage(config, configDir)
-  ]);
-  return {
-    valid: schemaResult.valid && coverageResult.valid,
-    errors: [...schemaResult.errors, ...coverageResult.errors],
-    warnings: [...schemaResult.warnings, ...coverageResult.warnings]
-  };
-}
-
-// src/build.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { resolve, join } from "path";
-import { existsSync } from "fs";
-async function buildSegments(config, configDir) {
-  const files = await discoverSegmentFiles(config, configDir);
-  const errors = [];
-  const warnings = [];
-  const segments = {};
-  for (const file of files) {
-    try {
-      const content = await readFile(file.absolutePath, "utf-8");
-      const parsed = parseSegmentFile(content, file.relativePath);
-      for (const warning of parsed.warnings) {
-        warnings.push({ file: file.relativePath, warning });
-      }
-      if (!parsed.meta.name) {
-        errors.push({
-          file: file.relativePath,
-          error: "Missing meta.name in fragment definition"
-        });
-        continue;
-      }
-      const compiled = {
-        filePath: file.relativePath,
-        meta: {
-          name: parsed.meta.name,
-          description: parsed.meta.description ?? "",
-          category: parsed.meta.category ?? "Uncategorized",
-          status: parsed.meta.status,
-          tags: parsed.meta.tags,
-          since: parsed.meta.since,
-          figma: parsed.meta.figma
-        },
-        usage: {
-          when: parsed.usage.when ?? [],
-          whenNot: parsed.usage.whenNot ?? [],
-          guidelines: parsed.usage.guidelines,
-          accessibility: parsed.usage.accessibility
-        },
-        props: Object.fromEntries(
-          Object.entries(parsed.props).map(([name, prop]) => [
-            name,
-            {
-              type: prop.type ?? "custom",
-              description: prop.description ?? "",
-              default: prop.default,
-              required: prop.required,
-              values: prop.values,
-              constraints: prop.constraints
-            }
-          ])
-        ),
-        relations: parsed.relations.map((rel) => ({
-          component: rel.component,
-          relationship: rel.relationship,
-          note: rel.note
-        })),
-        variants: parsed.variants.map((v) => ({
-          name: v.name,
-          description: v.description,
-          ...v.code && { code: v.code },
-          ...v.figma && { figma: v.figma },
-          ...v.args && { args: v.args }
-        })),
-        // Include AI metadata if present
-        ...parsed.ai && { ai: parsed.ai }
-      };
-      segments[parsed.meta.name] = compiled;
-    } catch (error) {
-      errors.push({
-        file: file.relativePath,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  const blocks = {};
-  try {
-    const blockFiles = await discoverBlockFiles(configDir, config.exclude);
-    for (const file of blockFiles) {
-      try {
-        let raw = await loadSegmentFile(file.absolutePath);
-        if (raw && "default" in raw && typeof raw.default === "object") {
-          raw = raw.default;
-        }
-        const def = raw;
-        if (def && typeof def === "object" && "name" in def && "code" in def && "components" in def) {
-          const compiled = compileBlock(def, file.relativePath);
-          blocks[compiled.name] = compiled;
-        }
-      } catch (error) {
-        warnings.push({
-          file: file.relativePath,
-          warning: `Failed to load block: ${error instanceof Error ? error.message : String(error)}`
-        });
-      }
-    }
-  } catch {
-  }
-  let tokens;
-  try {
-    const tokenPatterns = config.tokens?.include;
-    const tokenFiles = await discoverTokenFiles(configDir, tokenPatterns, config.exclude);
-    if (tokenFiles.length > 0) {
-      const mergedCategories = {};
-      let prefix = "--";
-      let total = 0;
-      for (const file of tokenFiles) {
-        const content = await readFile(file.absolutePath, "utf-8");
-        const parsed = parseTokenFile(content, file.relativePath);
-        prefix = parsed.prefix;
-        total += parsed.total;
-        for (const [cat, catTokens] of Object.entries(parsed.categories)) {
-          if (!mergedCategories[cat]) {
-            mergedCategories[cat] = [];
-          }
-          for (const t of catTokens) {
-            if (!mergedCategories[cat].some((e) => e.name === t.name)) {
-              mergedCategories[cat].push({ name: t.name, description: t.description });
-            }
-          }
-        }
-      }
-      if (total > 0) {
-        tokens = { prefix, total, categories: mergedCategories };
-      }
-    }
-  } catch {
-  }
-  let packageName;
-  const pkgJsonPath = resolve(configDir, "package.json");
-  if (existsSync(pkgJsonPath)) {
-    try {
-      const pkg = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
-      if (pkg.name) packageName = pkg.name;
-    } catch {
-    }
-  }
-  const output = {
-    version: "1.0.0",
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...packageName && { packageName },
-    segments,
-    ...Object.keys(blocks).length > 0 && { blocks },
-    ...tokens && { tokens }
-  };
-  const outputPath = resolve(configDir, config.outFile ?? BRAND.outFile);
-  await writeFile(outputPath, JSON.stringify(output));
-  return {
-    success: errors.length === 0,
-    outputPath,
-    segmentCount: Object.keys(segments).length,
-    errors,
-    warnings
-  };
-}
-async function buildFragmentsDir(config, configDir) {
-  const fragmentsDir = join(configDir, BRAND.dataDir);
-  const componentsDir = join(fragmentsDir, BRAND.componentsDir);
-  await mkdir(fragmentsDir, { recursive: true });
-  await mkdir(componentsDir, { recursive: true });
-  const registryResult = await generateRegistry({
-    projectRoot: configDir,
-    componentPatterns: config.components || ["src/**/*.tsx", "src/**/*.ts"],
-    storyPatterns: config.include || ["src/**/*.stories.tsx"],
-    fragmentsDir,
-    registryOptions: config.registry || {}
-  });
-  const errors = [...registryResult.errors];
-  const warnings = [...registryResult.warnings];
-  const indexPath = join(fragmentsDir, "index.json");
-  await writeFile(indexPath, JSON.stringify(registryResult.index, null, 2));
-  const registryPath = join(fragmentsDir, BRAND.registryFile);
-  await writeFile(registryPath, JSON.stringify(registryResult.registry, null, 2));
-  const contextResult = generateContextMd(registryResult.registry, {
-    format: "markdown",
-    compact: false,
-    include: {
-      props: false,
-      // AI can read TypeScript directly
-      relations: true,
-      code: false
-    }
-  });
-  const contextPath = join(fragmentsDir, BRAND.contextFile);
-  await writeFile(contextPath, contextResult.content);
-  return {
-    success: errors.length === 0,
-    indexPath,
-    registryPath,
-    contextPath,
-    componentCount: registryResult.registry.componentCount,
-    errors,
-    warnings
-  };
-}
-
-// src/screenshot.ts
-import pc from "picocolors";
-async function runScreenshotCommand(config, configDir, options = {}) {
-  const startTime = Date.now();
-  const errors = [];
-  const storage = new StorageManager({
-    projectRoot: configDir,
-    viewport: options.width && options.height ? { width: options.width, height: options.height } : config.screenshots?.viewport
-  });
-  await storage.initialize();
-  const segmentFiles = await discoverSegmentFiles(config, configDir);
-  if (segmentFiles.length === 0) {
-    console.log(pc.yellow("No segment files found."));
-    return {
-      success: true,
-      captured: 0,
-      skipped: 0,
-      errors: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const segments = [];
-  for (const file of segmentFiles) {
-    try {
-      const segment = await loadSegmentFile(file.absolutePath);
-      if (segment) {
-        segments.push({ path: file.relativePath, segment });
-      }
-    } catch (error) {
-      errors.push({
-        component: file.relativePath,
-        variant: "",
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  const filteredSegments = options.component ? segments.filter((s) => s.segment.meta.name === options.component) : segments;
-  if (options.component && filteredSegments.length === 0) {
-    console.log(pc.yellow(`Component "${options.component}" not found.`));
-    return {
-      success: false,
-      captured: 0,
-      skipped: 0,
-      errors: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const variantsToCapture = [];
-  for (const { segment } of filteredSegments) {
-    const variants = options.variant ? segment.variants.filter((v) => v.name === options.variant) : segment.variants;
-    for (const variant of variants) {
-      variantsToCapture.push({
-        component: segment.meta.name,
-        variant: variant.name,
-        render: variant.render
-      });
-    }
-  }
-  if (variantsToCapture.length === 0) {
-    console.log(pc.yellow("No variants to capture."));
-    return {
-      success: true,
-      captured: 0,
-      skipped: 0,
-      errors: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const theme = options.theme ?? DEFAULTS.theme;
-  const viewport = {
-    width: options.width ?? config.screenshots?.viewport?.width ?? DEFAULTS.viewport.width,
-    height: options.height ?? config.screenshots?.viewport?.height ?? DEFAULTS.viewport.height
-  };
-  console.log(pc.cyan(`
-${BRAND.name} Screenshot
-`));
-  console.log(pc.dim(`Capturing variants (theme: ${theme}, viewport: ${viewport.width}x${viewport.height}):
-`));
-  const pool = new BrowserPool({
-    viewport
-  });
-  const viewerPort = DEFAULTS.port;
-  const baseUrl = `http://localhost:${viewerPort}`;
-  const captureEngine = new CaptureEngine(pool, baseUrl);
-  let captured = 0;
-  let skipped = 0;
-  const captureOptions = {
-    theme,
-    viewport,
-    delay: config.screenshots?.delay ?? DEFAULTS.captureDelayMs
-  };
-  try {
-    console.log(pc.dim("Starting browser..."));
-    await pool.warmup();
-    console.log(pc.dim("Browser ready.\n"));
-    for (const { component, variant } of variantsToCapture) {
-      const hasExisting = storage.hasBaseline(component, variant, theme);
-      if (hasExisting && !options.update) {
-        console.log(`  ${pc.dim("\u25CB")} ${component}/${variant} ${pc.dim("(skipped)")}`);
-        skipped++;
-        continue;
-      }
-      try {
-        const screenshot = await captureEngine.captureVariant(
-          component,
-          variant,
-          captureOptions
-        );
-        await storage.saveBaseline(screenshot);
-        const totalTime = screenshot.metadata.renderTimeMs + screenshot.metadata.captureTimeMs;
-        console.log(
-          `  ${pc.green("\u2713")} ${component}/${variant} ${pc.dim(formatMs(totalTime))}`
-        );
-        captured++;
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        console.log(`  ${pc.red("\u2717")} ${component}/${variant} ${pc.dim(errorMsg)}`);
-        errors.push({ component, variant, error: errorMsg });
-      }
-    }
-  } finally {
-    await pool.shutdown();
-  }
-  const totalTimeMs = Date.now() - startTime;
-  console.log();
-  if (errors.length === 0) {
-    console.log(pc.green(`\u2713 Captured ${captured} screenshot(s) in ${formatMs(totalTimeMs)}`));
-  } else {
-    console.log(pc.yellow(`\u26A0 Captured ${captured} screenshot(s) with ${errors.length} error(s)`));
-  }
-  if (skipped > 0) {
-    console.log(pc.dim(`  ${skipped} skipped (use --update to recapture)`));
-  }
-  console.log(pc.dim(`  Stored in ${storage.screenshotsDirPath}
-`));
-  return {
-    success: errors.length === 0,
-    captured,
-    skipped,
-    errors,
-    totalTimeMs
-  };
-}
-
-// src/diff.ts
-import pc2 from "picocolors";
-async function runDiffCommand(config, configDir, options = {}) {
-  const startTime = Date.now();
-  const results = [];
-  const storage = new StorageManager({
-    projectRoot: configDir,
-    viewport: config.screenshots?.viewport
-  });
-  await storage.initialize();
-  const threshold = options.threshold ?? config.screenshots?.threshold ?? DEFAULTS.diffThreshold;
-  const diffEngine = new DiffEngine(threshold);
-  const segmentFiles = await discoverSegmentFiles(config, configDir);
-  if (segmentFiles.length === 0) {
-    console.log(pc2.yellow("No segment files found."));
-    return {
-      success: true,
-      total: 0,
-      passed: 0,
-      failed: 0,
-      missing: 0,
-      results: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const segments = [];
-  for (const file of segmentFiles) {
-    try {
-      const segment = await loadSegmentFile(file.absolutePath);
-      if (segment) {
-        segments.push({ path: file.relativePath, segment });
-      }
-    } catch {
-    }
-  }
-  const filteredSegments = options.component ? segments.filter((s) => s.segment.meta.name === options.component) : segments;
-  if (options.component && filteredSegments.length === 0) {
-    console.log(pc2.yellow(`Component "${options.component}" not found.`));
-    return {
-      success: false,
-      total: 0,
-      passed: 0,
-      failed: 0,
-      missing: 0,
-      results: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const variantsToDiff = [];
-  for (const { segment } of filteredSegments) {
-    const variants = options.variant ? segment.variants.filter((v) => v.name === options.variant) : segment.variants;
-    for (const variant of variants) {
-      variantsToDiff.push({
-        component: segment.meta.name,
-        variant: variant.name
-      });
-    }
-  }
-  if (variantsToDiff.length === 0) {
-    console.log(pc2.yellow("No variants to compare."));
-    return {
-      success: true,
-      total: 0,
-      passed: 0,
-      failed: 0,
-      missing: 0,
-      results: [],
-      totalTimeMs: Date.now() - startTime
-    };
-  }
-  const theme = options.theme ?? DEFAULTS.theme;
-  const viewport = config.screenshots?.viewport ?? DEFAULTS.viewport;
-  console.log(pc2.cyan(`
-${BRAND.name} Diff
-`));
-  console.log(pc2.dim(`Comparing against baselines (theme: ${theme}, threshold: ${threshold}%):
-`));
-  const pool = new BrowserPool({
-    viewport
-  });
-  const viewerPort = DEFAULTS.port;
-  const baseUrl = `http://localhost:${viewerPort}`;
-  const captureEngine = new CaptureEngine(pool, baseUrl);
-  let passed = 0;
-  let failed = 0;
-  let missing = 0;
-  const captureOptions = {
-    theme,
-    viewport,
-    delay: config.screenshots?.delay ?? DEFAULTS.captureDelayMs
-  };
-  try {
-    await pool.warmup();
-    for (const { component, variant } of variantsToDiff) {
-      const baseline = await storage.loadBaseline(component, variant, theme);
-      if (!baseline) {
-        console.log(
-          `  ${pc2.yellow("?")} ${component}/${variant} ${pc2.dim("(no baseline)")}`
-        );
-        missing++;
-        continue;
-      }
-      try {
-        const current = await captureEngine.captureVariant(
-          component,
-          variant,
-          captureOptions
-        );
-        if (diffEngine.areIdentical(current, baseline)) {
-          console.log(`  ${pc2.green("\u2713")} ${component}/${variant} ${pc2.dim("0.0%")}`);
-          results.push({
-            component,
-            variant,
-            theme,
-            result: {
-              matches: true,
-              diffPercentage: 0,
-              diffPixelCount: 0,
-              totalPixels: current.viewport.width * current.viewport.height,
-              changedRegions: [],
-              diffTimeMs: 0
-            }
-          });
-          passed++;
-          continue;
-        }
-        const diffResult = diffEngine.compare(current, baseline, { threshold });
-        if (diffResult.matches) {
-          console.log(
-            `  ${pc2.green("\u2713")} ${component}/${variant} ${pc2.dim(`${diffResult.diffPercentage}%`)}`
-          );
-          passed++;
-        } else {
-          let diffImagePath;
-          if (diffResult.diffImage) {
-            diffImagePath = await storage.saveDiff(
-              component,
-              variant,
-              theme,
-              diffResult.diffImage
-            );
-          }
-          console.log(
-            `  ${pc2.red("\u2717")} ${component}/${variant} ${pc2.yellow(`${diffResult.diffPercentage}%`)}` + (diffImagePath ? pc2.dim(` \u2192 ${diffImagePath}`) : "")
-          );
-          failed++;
-          results.push({
-            component,
-            variant,
-            theme,
-            result: diffResult,
-            diffImagePath
-          });
-          continue;
-        }
-        results.push({
-          component,
-          variant,
-          theme,
-          result: diffResult
-        });
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        console.log(`  ${pc2.red("!")} ${component}/${variant} ${pc2.dim(errorMsg)}`);
-        failed++;
-      }
-    }
-  } finally {
-    await pool.shutdown();
-  }
-  const totalTimeMs = Date.now() - startTime;
-  const total = passed + failed + missing;
-  console.log();
-  if (failed === 0 && missing === 0) {
-    console.log(pc2.green(`\u2713 All ${passed} variant(s) match baselines`));
-  } else if (failed > 0) {
-    console.log(pc2.red(`\u2717 ${failed} variant(s) differ from baselines`));
-  }
-  if (missing > 0) {
-    console.log(pc2.yellow(`  ${missing} variant(s) have no baseline (run \`${BRAND.cliCommand} screenshot\`)`));
-  }
-  console.log(pc2.dim(`  Completed in ${formatMs(totalTimeMs)}
-`));
-  const success = failed === 0;
-  return {
-    success,
-    total,
-    passed,
-    failed,
-    missing,
-    results,
-    totalTimeMs
-  };
-}
-
-// src/analyze.ts
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join2, dirname } from "path";
-import pc3 from "picocolors";
-async function runAnalyzeCommand(config, configDir, options = {}) {
-  const format = options.format ?? "html";
-  const minScore = options.minScore ?? 0;
-  console.log(pc3.cyan(`
-${BRAND.name} Analyzer
-`));
-  const segmentsPath = join2(configDir, config.outFile ?? "segments.json");
-  if (!existsSync2(segmentsPath)) {
-    console.log(pc3.red(`\u2717 No segments.json found. Run \`${BRAND.cliCommand} build\` first.
-`));
-    return {
-      success: false,
-      analytics: createEmptyAnalytics()
-    };
-  }
-  console.log(pc3.dim("Analyzing design system...\n"));
-  const content = await readFile2(segmentsPath, "utf-8");
-  const data = JSON.parse(content);
-  const analytics = analyzeDesignSystem(data);
-  printConsoleSummary(analytics);
-  let outputPath;
-  if (format === "html" || format === "json") {
-    outputPath = options.output ?? getDefaultOutputPath(format, configDir);
-    await mkdir2(dirname(outputPath), { recursive: true });
-    if (format === "html") {
-      const html = generateHtmlReport(analytics);
-      await writeFile2(outputPath, html);
-      console.log(pc3.green(`\u2713 Report generated: ${outputPath}
-`));
-    } else {
-      await writeFile2(outputPath, JSON.stringify(analytics, null, 2));
-      console.log(pc3.green(`\u2713 JSON report generated: ${outputPath}
-`));
-    }
-    if (options.open && format === "html") {
-      await openInBrowser(outputPath);
-    }
-  }
-  const passedCi = analytics.summary.overallScore >= minScore;
-  if (options.ci) {
-    if (passedCi) {
-      console.log(
-        pc3.green(`\u2713 Score ${analytics.summary.overallScore} meets minimum threshold ${minScore}
-`)
-      );
-    } else {
-      console.log(
-        pc3.red(
-          `\u2717 Score ${analytics.summary.overallScore} below minimum threshold ${minScore}
-`
-        )
-      );
-    }
-  }
-  return {
-    success: !options.ci || passedCi,
-    analytics,
-    outputPath
-  };
-}
-function printConsoleSummary(analytics) {
-  const { summary, coverage, recommendations } = analytics;
-  const grade = getGrade(summary.overallScore);
-  console.log(
-    pc3.bold(
-      `Overall Score: ${colorizeScore(summary.overallScore)} (${grade})
-`
-    )
-  );
-  console.log(pc3.dim("Summary"));
-  console.log(`  Components:  ${pc3.white(summary.totalComponents.toString())}`);
-  console.log(`  Variants:    ${pc3.white(summary.totalVariants.toString())}`);
-  console.log(`  Props:       ${pc3.white(summary.totalProps.toString())}`);
-  console.log(`  Categories:  ${pc3.white(summary.categories.join(", "))}`);
-  console.log();
-  console.log(pc3.dim("Coverage"));
-  console.log(`  Description:  ${formatCoverage(coverage.fields.description)}`);
-  console.log(`  Usage when:   ${formatCoverage(coverage.fields.usageWhen)}`);
-  console.log(`  Usage whenNot:${formatCoverage(coverage.fields.usageWhenNot)}`);
-  console.log(`  Guidelines:   ${formatCoverage(coverage.fields.guidelines)}`);
-  console.log(`  Relations:    ${formatCoverage(coverage.fields.relations)}`);
-  console.log();
-  if (recommendations.length > 0) {
-    console.log(pc3.dim("Top Recommendations"));
-    for (const rec of recommendations.slice(0, 3)) {
-      const priority = rec.priority === "high" ? pc3.red(`[${rec.priority}]`) : rec.priority === "medium" ? pc3.yellow(`[${rec.priority}]`) : pc3.dim(`[${rec.priority}]`);
-      console.log(`  ${priority} ${rec.title}`);
-    }
-    console.log();
-  }
-}
-function formatCoverage(field) {
-  const pct = colorizeScore(field.percentage);
-  return `${pct} (${field.covered}/${field.total})`;
-}
-function colorizeScore(score) {
-  if (score >= 80) return pc3.green(`${score}%`);
-  if (score >= 60) return pc3.yellow(`${score}%`);
-  return pc3.red(`${score}%`);
-}
-function getDefaultOutputPath(format, configDir) {
-  const filename = format === "html" ? "segments-report.html" : "segments-report.json";
-  return join2(configDir, filename);
-}
-async function openInBrowser(path) {
-  const { platform } = await import("os");
-  const { exec } = await import("child_process");
-  const os = platform();
-  const cmd = os === "darwin" ? `open "${path}"` : os === "win32" ? `start "" "${path}"` : `xdg-open "${path}"`;
-  exec(cmd);
-}
-function createEmptyAnalytics() {
-  return {
-    analyzedAt: /* @__PURE__ */ new Date(),
-    summary: {
-      totalComponents: 0,
-      totalVariants: 0,
-      totalProps: 0,
-      categories: [],
-      overallScore: 0
-    },
-    inventory: {
-      byCategory: {},
-      byStatus: {},
-      byVariantCount: [],
-      byPropCount: []
-    },
-    coverage: {
-      overall: 0,
-      fields: {
-        description: { covered: 0, total: 0, percentage: 0 },
-        usageWhen: { covered: 0, total: 0, percentage: 0 },
-        usageWhenNot: { covered: 0, total: 0, percentage: 0 },
-        guidelines: { covered: 0, total: 0, percentage: 0 },
-        accessibility: { covered: 0, total: 0, percentage: 0 },
-        relations: { covered: 0, total: 0, percentage: 0 },
-        propDescriptions: { covered: 0, total: 0, percentage: 0 },
-        propConstraints: { covered: 0, total: 0, percentage: 0 }
-      },
-      incomplete: []
-    },
-    quality: {
-      missingWhenNot: [],
-      isolated: [],
-      deprecated: [],
-      fewVariants: [],
-      undocumentedProps: [],
-      unconstrainedProps: []
-    },
-    distribution: {
-      variantsPerComponent: [],
-      propsPerComponent: [],
-      componentsPerCategory: [],
-      statusDistribution: [],
-      tagFrequency: []
-    },
-    recommendations: []
-  };
-}
-
-export {
-  validateSchema,
-  validateCoverage,
-  validateAll,
-  buildSegments,
-  buildFragmentsDir,
-  runScreenshotCommand,
-  runDiffCommand,
-  runAnalyzeCommand
-};
-//# sourceMappingURL=chunk-U4GQ2JTD.js.map