@fragments-sdk/cli 0.2.2

package/dist/chunk-4FDQSGKX.js

@@ -0,0 +1,786 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  BrowserPool,
+  CaptureEngine,
+  DiffEngine,
+  StorageManager,
+  analyzeDesignSystem,
+  formatMs,
+  generateHtmlReport,
+  getGrade
+} from "./chunk-MUZ6CM66.js";
+import {
+  discoverComponentFiles,
+  discoverRecipeFiles,
+  discoverSegmentFiles,
+  extractComponentName,
+  generateContextMd,
+  generateRegistry,
+  loadSegmentFile,
+  parseSegmentFile
+} from "./chunk-OAENNG3G.js";
+import {
+  compileRecipe
+} from "./chunk-LY2CFFPY.js";
+import {
+  BRAND,
+  DEFAULTS,
+  segmentDefinitionSchema
+} from "./chunk-XHNKNI6J.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";
+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 }
+        }))
+      };
+      segments[parsed.meta.name] = compiled;
+    } catch (error) {
+      errors.push({
+        file: file.relativePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const recipes = {};
+  try {
+    const recipeFiles = await discoverRecipeFiles(configDir, config.exclude);
+    for (const file of recipeFiles) {
+      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 = compileRecipe(def, file.relativePath);
+          recipes[compiled.name] = compiled;
+        }
+      } catch (error) {
+        warnings.push({
+          file: file.relativePath,
+          warning: `Failed to load recipe: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+    }
+  } catch {
+  }
+  const output = {
+    version: "1.0.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    segments,
+    ...Object.keys(recipes).length > 0 && { recipes }
+  };
+  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 } 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 (!existsSync(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-4FDQSGKX.js.map