@fragments-sdk/cli 0.5.2 → 0.7.0

package/dist/chunk-7OPWMLOE.js

@@ -0,0 +1,1625 @@
+import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
+import {
+  BrowserPool,
+  CaptureEngine,
+  DiffEngine,
+  StorageManager,
+  analyzeDesignSystem,
+  formatMs,
+  generateHtmlReport,
+  getGrade
+} from "./chunk-NWQ4CJOQ.js";
+import {
+  discoverBlockFiles,
+  discoverComponentFiles,
+  discoverSegmentFiles,
+  discoverTokenFiles,
+  extractComponentName,
+  generateContextMd,
+  generateRegistry,
+  loadSegmentFile,
+  parseSegmentFile
+} from "./chunk-CVXKXVOY.js";
+import {
+  compileBlock,
+  parseTokenFile
+} from "./chunk-TJ34N7C7.js";
+import {
+  BRAND,
+  DEFAULTS,
+  segmentDefinitionSchema
+} from "./chunk-6JBGU74P.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 as resolve3, join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+
+// src/core/auto-props.ts
+import { existsSync, statSync } from "fs";
+import { dirname, extname, join, resolve } from "path";
+import ts from "typescript";
+function toPosixPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function isFile(filePath) {
+  if (!existsSync(filePath)) return false;
+  try {
+    return statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveModulePath(basePath) {
+  const candidates = [];
+  const extension = extname(basePath);
+  if (extension) {
+    candidates.push(basePath);
+  } else {
+    candidates.push(
+      `${basePath}.tsx`,
+      `${basePath}.ts`,
+      `${basePath}.jsx`,
+      `${basePath}.js`,
+      join(basePath, "index.tsx"),
+      join(basePath, "index.ts"),
+      join(basePath, "index.jsx"),
+      join(basePath, "index.js")
+    );
+  }
+  for (const candidate of candidates) {
+    if (isFile(candidate)) {
+      return resolve(candidate);
+    }
+  }
+  return null;
+}
+function resolveComponentSourcePath(segmentFileAbsolutePath, componentImportPath) {
+  if (!componentImportPath) return null;
+  if (!componentImportPath.startsWith(".")) return null;
+  const segmentDir = dirname(segmentFileAbsolutePath);
+  const basePath = resolve(segmentDir, componentImportPath);
+  return resolveModulePath(basePath);
+}
+function collectTopLevelDeclarations(sourceFile) {
+  const typeDeclarations = /* @__PURE__ */ new Map();
+  const functionDeclarations = /* @__PURE__ */ new Map();
+  const variableDeclarations = /* @__PURE__ */ new Map();
+  for (const node of sourceFile.statements) {
+    if (ts.isInterfaceDeclaration(node)) {
+      typeDeclarations.set(node.name.text, node);
+      continue;
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      typeDeclarations.set(node.name.text, node);
+      continue;
+    }
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      functionDeclarations.set(node.name.text, node);
+      continue;
+    }
+    if (ts.isVariableStatement(node)) {
+      for (const declaration of node.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name)) {
+          variableDeclarations.set(declaration.name.text, declaration);
+        }
+      }
+    }
+  }
+  return { typeDeclarations, functionDeclarations, variableDeclarations };
+}
+function readDefaultValue(expression) {
+  if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts.isNumericLiteral(expression)) {
+    return Number(expression.text);
+  }
+  if (expression.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (expression.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (expression.kind === ts.SyntaxKind.NullKeyword) return null;
+  if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(expression.operand)) {
+    return -Number(expression.operand.text);
+  }
+  return void 0;
+}
+function extractDefaultValues(componentNode) {
+  const defaults = {};
+  if (!componentNode?.parameters?.length) return defaults;
+  const firstParam = componentNode.parameters[0];
+  if (!ts.isObjectBindingPattern(firstParam.name)) return defaults;
+  for (const element of firstParam.name.elements) {
+    let propName = null;
+    if (element.propertyName) {
+      if (ts.isIdentifier(element.propertyName) || ts.isStringLiteral(element.propertyName)) {
+        propName = element.propertyName.text;
+      }
+    } else if (ts.isIdentifier(element.name)) {
+      propName = element.name.text;
+    }
+    if (!propName || !element.initializer) continue;
+    const value = readDefaultValue(element.initializer);
+    if (value !== void 0) {
+      defaults[propName] = value;
+    }
+  }
+  return defaults;
+}
+function isNullishType(type) {
+  return (type.flags & ts.TypeFlags.Null) !== 0 || (type.flags & ts.TypeFlags.Undefined) !== 0 || (type.flags & ts.TypeFlags.Void) !== 0;
+}
+function isBooleanLikeType(type) {
+  return (type.flags & ts.TypeFlags.BooleanLike) !== 0 || type.flags === ts.TypeFlags.BooleanLiteral;
+}
+function inferPropType(type, checker) {
+  const typeText = checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+  if (typeText.includes("ReactNode")) {
+    return { type: "node" };
+  }
+  if (typeText.includes("ReactElement") || typeText.includes("JSX.Element")) {
+    return { type: "element" };
+  }
+  if (type.getCallSignatures().length > 0) {
+    return { type: "function" };
+  }
+  if (checker.isArrayType(type) || checker.isTupleType(type)) {
+    return { type: "array" };
+  }
+  if (type.isUnion()) {
+    const nonNullableTypes = type.types.filter((unionType) => !isNullishType(unionType));
+    if (nonNullableTypes.length === 1) {
+      return inferPropType(nonNullableTypes[0], checker);
+    }
+    const stringLiteralValues = nonNullableTypes.filter((unionType) => (unionType.flags & ts.TypeFlags.StringLiteral) !== 0).map((unionType) => unionType.value);
+    if (stringLiteralValues.length > 0 && stringLiteralValues.length === nonNullableTypes.length) {
+      return { type: "enum", values: stringLiteralValues };
+    }
+    if (nonNullableTypes.every((unionType) => isBooleanLikeType(unionType))) {
+      return { type: "boolean" };
+    }
+    return { type: "union" };
+  }
+  if ((type.flags & ts.TypeFlags.StringLike) !== 0) {
+    return { type: "string" };
+  }
+  if ((type.flags & ts.TypeFlags.NumberLike) !== 0) {
+    return { type: "number" };
+  }
+  if ((type.flags & ts.TypeFlags.BooleanLike) !== 0) {
+    return { type: "boolean" };
+  }
+  if ((type.flags & ts.TypeFlags.Object) !== 0) {
+    return { type: "object" };
+  }
+  return { type: "custom" };
+}
+function resolveComponentSignature(exportName, declarations, sourceFile) {
+  const visitedNames = /* @__PURE__ */ new Set();
+  const typeNodeFromFunction = (node) => ({
+    propsTypeNode: node.parameters[0]?.type ?? null,
+    componentNode: node
+  });
+  const resolveFromExpression = (expression) => {
+    if (ts.isParenthesizedExpression(expression)) {
+      return resolveFromExpression(expression.expression);
+    }
+    if (ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression)) {
+      return resolveFromExpression(expression.expression);
+    }
+    if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+      return typeNodeFromFunction(expression);
+    }
+    if (ts.isIdentifier(expression)) {
+      return resolveFromIdentifier(expression.text);
+    }
+    if (ts.isCallExpression(expression)) {
+      if (ts.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "forwardRef") {
+        const forwardRefPropsType = expression.typeArguments?.[1] ?? null;
+        const innerArg = expression.arguments[0];
+        const inner = innerArg && (ts.isArrowFunction(innerArg) || ts.isFunctionExpression(innerArg)) ? typeNodeFromFunction(innerArg) : innerArg && ts.isIdentifier(innerArg) ? resolveFromIdentifier(innerArg.text) : { propsTypeNode: null, componentNode: null };
+        return {
+          propsTypeNode: forwardRefPropsType ?? inner.propsTypeNode,
+          componentNode: inner.componentNode
+        };
+      }
+      if (ts.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "memo" && expression.arguments[0]) {
+        return resolveFromExpression(expression.arguments[0]);
+      }
+      if (ts.isPropertyAccessExpression(expression.expression) && expression.expression.expression.getText(sourceFile) === "Object" && expression.expression.name.text === "assign" && expression.arguments[0]) {
+        return resolveFromExpression(expression.arguments[0]);
+      }
+    }
+    return { propsTypeNode: null, componentNode: null };
+  };
+  const resolveFromVariable = (declaration) => {
+    if (declaration.type && ts.isTypeReferenceNode(declaration.type) && declaration.type.typeArguments?.length) {
+      const typeName = declaration.type.typeName.getText(sourceFile);
+      if (typeName.includes("FC") || typeName.includes("FunctionComponent")) {
+        const componentNode = declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) ? declaration.initializer : null;
+        return {
+          propsTypeNode: declaration.type.typeArguments[0] ?? null,
+          componentNode
+        };
+      }
+    }
+    if (declaration.initializer) {
+      return resolveFromExpression(declaration.initializer);
+    }
+    return { propsTypeNode: null, componentNode: null };
+  };
+  const resolveFromIdentifier = (name) => {
+    if (!name || visitedNames.has(name)) {
+      return { propsTypeNode: null, componentNode: null };
+    }
+    visitedNames.add(name);
+    const functionDeclaration = declarations.functionDeclarations.get(name);
+    if (functionDeclaration) {
+      return typeNodeFromFunction(functionDeclaration);
+    }
+    const variableDeclaration = declarations.variableDeclarations.get(name);
+    if (variableDeclaration) {
+      return resolveFromVariable(variableDeclaration);
+    }
+    return { propsTypeNode: null, componentNode: null };
+  };
+  return resolveFromIdentifier(exportName);
+}
+function extractCustomPropsFromComponentFile(componentFilePath, exportName) {
+  const warnings = [];
+  const resolvedPath = resolve(componentFilePath);
+  if (!existsSync(resolvedPath)) {
+    return {
+      props: {},
+      warnings: [`Component file not found: ${resolvedPath}`],
+      resolved: false
+    };
+  }
+  const compilerOptions = {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    jsx: ts.JsxEmit.ReactJSX,
+    allowSyntheticDefaultImports: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    strict: false,
+    noEmit: true
+  };
+  const program = ts.createProgram([resolvedPath], compilerOptions);
+  const sourceFile = program.getSourceFile(resolvedPath);
+  if (!sourceFile) {
+    return {
+      props: {},
+      warnings: [`Unable to parse component source: ${resolvedPath}`],
+      resolved: false
+    };
+  }
+  const checker = program.getTypeChecker();
+  const declarations = collectTopLevelDeclarations(sourceFile);
+  const signature = resolveComponentSignature(exportName, declarations, sourceFile);
+  if (!signature.propsTypeNode) {
+    return {
+      props: {},
+      warnings: [`Unable to resolve props type for export: ${exportName}`],
+      resolved: false
+    };
+  }
+  const propsType = checker.getTypeFromTypeNode(signature.propsTypeNode);
+  const defaultValues = extractDefaultValues(signature.componentNode);
+  const sourceFilePath = toPosixPath(sourceFile.fileName);
+  const extractedProps = {};
+  for (const symbol of checker.getPropertiesOfType(propsType)) {
+    const propName = symbol.getName();
+    if (propName.startsWith("_") || propName.startsWith("$")) {
+      continue;
+    }
+    const declarationsForSymbol = symbol.getDeclarations() ?? [];
+    const localDeclarations = declarationsForSymbol.filter(
+      (declaration) => toPosixPath(declaration.getSourceFile().fileName) === sourceFilePath
+    );
+    if (localDeclarations.length === 0) {
+      continue;
+    }
+    const referenceNode = localDeclarations[0];
+    const inferredType = inferPropType(checker.getTypeOfSymbolAtLocation(symbol, referenceNode), checker);
+    const description = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+    extractedProps[propName] = {
+      type: inferredType.type,
+      description,
+      required: (symbol.getFlags() & ts.SymbolFlags.Optional) === 0,
+      ...inferredType.values && { values: inferredType.values },
+      ...defaultValues[propName] !== void 0 && { default: defaultValues[propName] }
+    };
+  }
+  if (Object.keys(extractedProps).length === 0) {
+    warnings.push(`Resolved props type for ${exportName}, but no local custom props were found`);
+  }
+  return {
+    props: extractedProps,
+    warnings,
+    resolved: true
+  };
+}
+
+// src/core/graph-extractor.ts
+import ts2 from "typescript";
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { readdirSync } from "fs";
+import { EDGE_TYPE_WEIGHTS, computeHealthFromData } from "@fragments-sdk/context/graph";
+async function buildComponentGraph(segments, blocks, componentDir, options) {
+  const knownComponents = new Set(Object.keys(segments));
+  const allEdges = [];
+  const autoDetected = /* @__PURE__ */ new Map();
+  const warnings = [];
+  if (!options?.skipSourceAnalysis) {
+    const sourceEdges = extractImportAndHookEdges(componentDir, knownComponents);
+    allEdges.push(...sourceEdges);
+    const subComponentResults = extractSubComponents(componentDir, knownComponents);
+    for (const [name, subs] of subComponentResults) {
+      autoDetected.set(name, {
+        ...autoDetected.get(name),
+        subComponents: subs,
+        compositionPattern: subs.length > 0 ? "compound" : "simple"
+      });
+    }
+  }
+  const jsxEdges = extractJsxUsageEdges(segments, knownComponents);
+  allEdges.push(...jsxEdges);
+  const blockEdges = extractBlockEdges(blocks);
+  allEdges.push(...blockEdges);
+  const relationEdges = extractRelationEdges(segments);
+  allEdges.push(...relationEdges);
+  const requiredChildrenMap = inferRequiredChildren(segments, autoDetected);
+  for (const [name, children] of requiredChildrenMap) {
+    const existing = autoDetected.get(name) ?? {};
+    autoDetected.set(name, { ...existing, requiredChildren: children });
+  }
+  const patternsMap = generateCommonPatterns(segments, autoDetected);
+  for (const [name, patterns] of patternsMap) {
+    const existing = autoDetected.get(name) ?? {};
+    autoDetected.set(name, { ...existing, commonPatterns: patterns });
+  }
+  const mergedEdges = mergeAndDeduplicate(allEdges);
+  const nodes = Object.entries(segments).map(([name, segment]) => {
+    const detected = autoDetected.get(name);
+    return {
+      name,
+      category: segment.meta.category,
+      status: segment.meta.status ?? "stable",
+      compositionPattern: segment.ai?.compositionPattern ?? detected?.compositionPattern,
+      subComponents: segment.ai?.subComponents ?? detected?.subComponents
+    };
+  });
+  const blockIndex = /* @__PURE__ */ new Map();
+  for (const [blockName, block] of Object.entries(blocks)) {
+    for (const comp of block.components) {
+      const existing = blockIndex.get(comp);
+      if (existing) existing.push(blockName);
+      else blockIndex.set(comp, [blockName]);
+    }
+  }
+  const health = computeHealthFromData(nodes, mergedEdges, blockIndex);
+  for (const [name, segment] of Object.entries(segments)) {
+    const detected = autoDetected.get(name);
+    if (!detected) continue;
+    if (segment.ai?.subComponents && detected.subComponents) {
+      const declared = new Set(segment.ai.subComponents);
+      const found = new Set(detected.subComponents);
+      const missing = detected.subComponents.filter((s) => !declared.has(s));
+      const extra = segment.ai.subComponents.filter((s) => !found.has(s));
+      if (missing.length > 0) {
+        warnings.push(
+          `${name}: declares ${declared.size} subComponents but code has ${found.size}. Missing from declaration: ${missing.join(", ")}`
+        );
+      }
+      if (extra.length > 0) {
+        warnings.push(
+          `${name}: declares subComponents [${extra.join(", ")}] not found in Object.assign`
+        );
+      }
+    }
+  }
+  return {
+    graph: { nodes, edges: mergedEdges, health },
+    autoDetected,
+    warnings
+  };
+}
+function extractImportAndHookEdges(componentDir, knownComponents) {
+  const edges = [];
+  for (const componentName of knownComponents) {
+    const indexPath = findComponentIndex(componentDir, componentName);
+    if (!indexPath) continue;
+    let sourceText;
+    try {
+      sourceText = readFileSync(indexPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const sourceFile = ts2.createSourceFile(
+      indexPath,
+      sourceText,
+      ts2.ScriptTarget.Latest,
+      true,
+      indexPath.endsWith(".tsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS
+    );
+    const visitNode = (node) => {
+      if (ts2.isImportDeclaration(node)) {
+        const moduleSpecifier = node.moduleSpecifier;
+        if (ts2.isStringLiteral(moduleSpecifier)) {
+          const importPath = moduleSpecifier.text;
+          if (importPath.startsWith(".") || importPath.startsWith("/")) {
+            const clause = node.importClause;
+            if (clause) {
+              if (clause.name && isPascalCase(clause.name.text) && knownComponents.has(clause.name.text)) {
+                edges.push({
+                  source: componentName,
+                  target: clause.name.text,
+                  type: "imports",
+                  weight: EDGE_TYPE_WEIGHTS["imports"],
+                  provenance: `source:${componentName}/index.tsx`
+                });
+              }
+              if (clause.namedBindings && ts2.isNamedImports(clause.namedBindings)) {
+                for (const element of clause.namedBindings.elements) {
+                  const name = element.name.text;
+                  if (isPascalCase(name) && knownComponents.has(name) && name !== componentName) {
+                    edges.push({
+                      source: componentName,
+                      target: name,
+                      type: "imports",
+                      weight: EDGE_TYPE_WEIGHTS["imports"],
+                      provenance: `source:${componentName}/index.tsx`
+                    });
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      if (ts2.isCallExpression(node) && ts2.isIdentifier(node.expression)) {
+        const callName = node.expression.text;
+        const hookMatch = callName.match(/^use([A-Z][a-zA-Z]*)$/);
+        if (hookMatch) {
+          const hookTarget = hookMatch[1];
+          if (knownComponents.has(hookTarget) && hookTarget !== componentName) {
+            edges.push({
+              source: componentName,
+              target: hookTarget,
+              type: "hook-depends",
+              weight: EDGE_TYPE_WEIGHTS["hook-depends"],
+              provenance: `source:${componentName}/index.tsx`
+            });
+          }
+        }
+      }
+      ts2.forEachChild(node, visitNode);
+    };
+    ts2.forEachChild(sourceFile, visitNode);
+  }
+  return edges;
+}
+function extractSubComponents(componentDir, knownComponents) {
+  const result = /* @__PURE__ */ new Map();
+  for (const componentName of knownComponents) {
+    const indexPath = findComponentIndex(componentDir, componentName);
+    if (!indexPath) continue;
+    let sourceText;
+    try {
+      sourceText = readFileSync(indexPath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (!sourceText.includes("Object.assign")) continue;
+    const sourceFile = ts2.createSourceFile(
+      indexPath,
+      sourceText,
+      ts2.ScriptTarget.Latest,
+      true,
+      indexPath.endsWith(".tsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS
+    );
+    const subComponents = [];
+    const visitNode = (node) => {
+      if (ts2.isCallExpression(node) && ts2.isPropertyAccessExpression(node.expression) && ts2.isIdentifier(node.expression.expression) && node.expression.expression.text === "Object" && node.expression.name.text === "assign" && node.arguments.length >= 2) {
+        const propsArg = node.arguments[1];
+        if (ts2.isObjectLiteralExpression(propsArg)) {
+          for (const prop of propsArg.properties) {
+            if (ts2.isShorthandPropertyAssignment(prop)) {
+              subComponents.push(prop.name.text);
+            } else if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name)) {
+              subComponents.push(prop.name.text);
+            }
+          }
+        }
+      }
+      ts2.forEachChild(node, visitNode);
+    };
+    ts2.forEachChild(sourceFile, visitNode);
+    if (subComponents.length > 0) {
+      result.set(componentName, subComponents);
+    }
+  }
+  return result;
+}
+function extractJsxUsageEdges(segments, knownComponents) {
+  const edges = [];
+  const jsxTagRegex = /<([A-Z][a-zA-Z]*(?:\.[A-Z][a-zA-Z]*)?)/g;
+  for (const [name, segment] of Object.entries(segments)) {
+    const usedComponents = /* @__PURE__ */ new Set();
+    for (const variant of segment.variants) {
+      if (!variant.code) continue;
+      let match;
+      jsxTagRegex.lastIndex = 0;
+      while ((match = jsxTagRegex.exec(variant.code)) !== null) {
+        let tagName = match[1];
+        if (tagName.includes(".")) {
+          tagName = tagName.split(".")[0];
+        }
+        if (knownComponents.has(tagName) && tagName !== name) {
+          usedComponents.add(tagName);
+        }
+      }
+    }
+    for (const target of usedComponents) {
+      edges.push({
+        source: name,
+        target,
+        type: "renders",
+        weight: EDGE_TYPE_WEIGHTS["renders"],
+        provenance: `variant:${name}`
+      });
+    }
+  }
+  return edges;
+}
+function extractBlockEdges(blocks) {
+  const edges = [];
+  for (const [blockName, block] of Object.entries(blocks)) {
+    const components = block.components;
+    for (let i = 0; i < components.length; i++) {
+      for (let j = i + 1; j < components.length; j++) {
+        edges.push({
+          source: components[i],
+          target: components[j],
+          type: "composes",
+          weight: EDGE_TYPE_WEIGHTS["composes"],
+          provenance: `block:${blockName}`
+        });
+      }
+    }
+  }
+  return edges;
+}
+function extractRelationEdges(segments) {
+  const edges = [];
+  const relationToEdgeType = {
+    parent: "parent-of",
+    child: "parent-of",
+    // reversed: if A declares child B, edge is A parent-of B
+    composition: "composes",
+    alternative: "alternative-to",
+    sibling: "sibling-of"
+  };
+  for (const [name, segment] of Object.entries(segments)) {
+    if (!segment.relations) continue;
+    for (const rel of segment.relations) {
+      const edgeType = relationToEdgeType[rel.relationship];
+      if (!edgeType) continue;
+      let source;
+      let target;
+      if (rel.relationship === "parent") {
+        source = rel.component;
+        target = name;
+      } else {
+        source = name;
+        target = rel.component;
+      }
+      edges.push({
+        source,
+        target,
+        type: edgeType,
+        weight: EDGE_TYPE_WEIGHTS[edgeType],
+        note: rel.note,
+        provenance: "relation"
+      });
+    }
+  }
+  return edges;
+}
+function inferRequiredChildren(segments, autoDetected) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, segment] of Object.entries(segments)) {
+    const detected = autoDetected.get(name);
+    const subs = detected?.subComponents ?? segment.ai?.subComponents;
+    if (!subs || subs.length === 0) continue;
+    const variantsWithCode = segment.variants.filter((v) => v.code);
+    if (variantsWithCode.length === 0) continue;
+    const required = [];
+    for (const sub of subs) {
+      const inAll = variantsWithCode.every((v) => {
+        const patterns = [
+          new RegExp(`<${name}\\.${sub}[\\s/>]`),
+          new RegExp(`<${sub}[\\s/>]`)
+        ];
+        return patterns.some((p) => p.test(v.code));
+      });
+      if (inAll) required.push(sub);
+    }
+    if (required.length > 0) {
+      result.set(name, required);
+    }
+  }
+  return result;
+}
+function generateCommonPatterns(segments, autoDetected) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, segment] of Object.entries(segments)) {
+    const detected = autoDetected.get(name);
+    const subs = detected?.subComponents ?? segment.ai?.subComponents;
+    if (!subs || subs.length === 0) continue;
+    const firstVariant = segment.variants.find((v) => v.code);
+    if (!firstVariant?.code) continue;
+    const usedSubs = [];
+    for (const sub of subs) {
+      const patterns = [
+        new RegExp(`<${name}\\.${sub}`),
+        new RegExp(`<${sub}[\\s/>]`)
+      ];
+      if (patterns.some((p) => p.test(firstVariant.code))) {
+        usedSubs.push(sub);
+      }
+    }
+    if (usedSubs.length > 0) {
+      const pattern = `<${name}>
+${usedSubs.map((s) => `  <${name}.${s}>...</${name}.${s}>`).join("\n")}
+</${name}>`;
+      result.set(name, [pattern]);
+    }
+  }
+  return result;
+}
+function mergeAndDeduplicate(edges) {
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const key = `${edge.source}\u2192${edge.target}:${edge.type}`;
+    const existing = edgeMap.get(key);
+    if (!existing || edge.weight > existing.weight) {
+      edgeMap.set(key, edge);
+    }
+  }
+  return [...edgeMap.values()];
+}
+function isPascalCase(name) {
+  return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+}
+function findComponentIndex(componentDir, componentName) {
+  const candidates = [
+    join2(componentDir, componentName, "index.tsx"),
+    join2(componentDir, componentName, "index.ts"),
+    join2(componentDir, componentName, `${componentName}.tsx`),
+    join2(componentDir, componentName, `${componentName}.ts`)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  try {
+    const entries = readdirSync(componentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name === componentName) {
+        const subCandidates = [
+          join2(componentDir, entry.name, "index.tsx"),
+          join2(componentDir, entry.name, "index.ts")
+        ];
+        for (const sc of subCandidates) {
+          if (existsSync2(sc)) return sc;
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/build.ts
+import { serializeGraph } from "@fragments-sdk/context/graph";
+function normalizeParsedProps(parsedProps) {
+  return Object.fromEntries(
+    Object.entries(parsedProps).map(([name, prop]) => [
+      name,
+      {
+        type: prop.type ?? "custom",
+        description: prop.description ?? "",
+        default: prop.default,
+        required: prop.required,
+        values: prop.values,
+        constraints: prop.constraints
+      }
+    ])
+  );
+}
+function mergeDocumentedAndAutoProps(documentedProps, autoProps) {
+  return Object.fromEntries(
+    Object.keys(autoProps).map((name) => {
+      const documented = documentedProps[name];
+      const auto = autoProps[name];
+      return [
+        name,
+        {
+          type: auto.type,
+          description: documented?.description ?? auto.description ?? "",
+          default: auto.default !== void 0 ? auto.default : documented?.default,
+          required: auto.required,
+          values: auto.values ?? documented?.values,
+          constraints: documented?.constraints
+        }
+      ];
+    })
+  );
+}
+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 documentedProps = normalizeParsedProps(parsed.props);
+      let mergedProps = documentedProps;
+      const componentExportName = parsed.componentName ?? parsed.meta.name;
+      const componentSourcePath = resolveComponentSourcePath(
+        file.absolutePath,
+        parsed.componentImport
+      );
+      if (componentExportName && componentSourcePath) {
+        const autoPropsResult = extractCustomPropsFromComponentFile(
+          componentSourcePath,
+          componentExportName
+        );
+        for (const warning of autoPropsResult.warnings) {
+          warnings.push({ file: file.relativePath, warning });
+        }
+        const hasAutoProps = Object.keys(autoPropsResult.props).length > 0;
+        if (autoPropsResult.resolved && hasAutoProps) {
+          const removedDocumentedProps = Object.keys(documentedProps).filter(
+            (propName) => !(propName in autoPropsResult.props)
+          );
+          if (removedDocumentedProps.length > 0) {
+            warnings.push({
+              file: file.relativePath,
+              warning: `Removed ${removedDocumentedProps.length} documented props not present in source API: ${removedDocumentedProps.join(", ")}`
+            });
+          }
+          mergedProps = mergeDocumentedAndAutoProps(
+            documentedProps,
+            autoPropsResult.props
+          );
+        } else if (autoPropsResult.resolved && !hasAutoProps && Object.keys(documentedProps).length > 0) {
+          warnings.push({
+            file: file.relativePath,
+            warning: "Auto-props extraction returned no custom props; falling back to documented props"
+          });
+        }
+      } else if (!componentExportName) {
+        warnings.push({
+          file: file.relativePath,
+          warning: "Unable to resolve component export name for auto-props extraction"
+        });
+      } else if (!componentSourcePath) {
+        warnings.push({
+          file: file.relativePath,
+          warning: `Unable to resolve component source path from import: ${parsed.componentImport ?? "unknown"}`
+        });
+      }
+      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: mergedProps,
+        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 = resolve3(configDir, "package.json");
+  if (existsSync3(pkgJsonPath)) {
+    try {
+      const pkg = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
+      if (pkg.name) packageName = pkg.name;
+    } catch {
+    }
+  }
+  const componentDir = resolve3(configDir, "src", "components");
+  let graphData;
+  try {
+    const graphResult = await buildComponentGraph(segments, blocks, componentDir);
+    for (const [name, segment] of Object.entries(segments)) {
+      const detected = graphResult.autoDetected.get(name);
+      if (!detected) continue;
+      if (!segment.ai) segment.ai = {};
+      if (!segment.ai.subComponents && detected.subComponents) {
+        segment.ai.subComponents = detected.subComponents;
+      }
+      if (!segment.ai.compositionPattern && detected.compositionPattern) {
+        segment.ai.compositionPattern = detected.compositionPattern;
+      }
+      if (!segment.ai.commonPatterns && detected.commonPatterns) {
+        segment.ai.commonPatterns = detected.commonPatterns;
+      }
+      if (!segment.ai.requiredChildren && detected.requiredChildren) {
+        segment.ai.requiredChildren = detected.requiredChildren;
+      }
+    }
+    for (const w of graphResult.warnings) {
+      warnings.push({ file: "graph", warning: w });
+    }
+    graphData = serializeGraph(graphResult.graph);
+  } catch (error) {
+    warnings.push({
+      file: "graph",
+      warning: `Graph extraction failed: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  const output = {
+    version: "1.0.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...packageName && { packageName },
+    segments,
+    ...Object.keys(blocks).length > 0 && { blocks },
+    ...tokens && { tokens },
+    ...graphData && { graph: graphData }
+  };
+  const outputPath = resolve3(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 = join3(configDir, BRAND.dataDir);
+  const componentsDir = join3(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 = join3(fragmentsDir, "index.json");
+  await writeFile(indexPath, JSON.stringify(registryResult.index, null, 2));
+  const registryPath = join3(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 = join3(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 existsSync4 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join4, dirname as dirname2 } 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 = join4(configDir, config.outFile ?? "segments.json");
+  if (!existsSync4(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(dirname2(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 join4(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-7OPWMLOE.js.map