@fragments-sdk/cli 0.6.0 → 0.7.1

package/dist/{chunk-D35RGPAG.js → chunk-U6VTHBNI.js}

@@ -8,57 +8,57 @@ import {
   formatMs,
   generateHtmlReport,
   getGrade
-} from "./chunk-NWQ4CJOQ.js";
+} from "./chunk-GKX2HPZ6.js";
 import {
   discoverBlockFiles,
   discoverComponentFiles,
-  discoverSegmentFiles,
+  discoverFragmentFiles,
   discoverTokenFiles,
   extractComponentName,
   generateContextMd,
   generateRegistry,
-  loadSegmentFile,
-  parseSegmentFile
-} from "./chunk-SSLQXHNX.js";
+  loadFragmentFile,
+  parseFragmentFile
+} from "./chunk-5ITIP3ES.js";
 import {
   compileBlock,
   parseTokenFile
-} from "./chunk-Q7GOHVOK.js";
+} from "./chunk-GCZMFLDI.js";
 import {
   BRAND,
   DEFAULTS,
-  segmentDefinitionSchema
-} from "./chunk-6JBGU74P.js";
+  fragmentDefinitionSchema
+} from "./chunk-GHYYFAQN.js";
 
 // src/validators.ts
 async function validateSchema(config, configDir) {
-  const files = await discoverSegmentFiles(config, configDir);
+  const files = await discoverFragmentFiles(config, configDir);
   const errors = [];
   const warnings = [];
   for (const file of files) {
     try {
-      const segment = await loadSegmentFile(file.absolutePath);
-      if (!segment) {
+      const fragment = await loadFragmentFile(file.absolutePath);
+      if (!fragment) {
         errors.push({
           file: file.relativePath,
           message: "No default export found",
-          details: `Segment files must have a default export from defineSegment()`
+          details: `Fragment files must have a default export from defineFragment()`
         });
         continue;
       }
-      const result = segmentDefinitionSchema.safeParse(segment);
+      const result = fragmentDefinitionSchema.safeParse(fragment);
       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",
+          message: "Invalid fragment schema",
           details
         });
       }
     } catch (error) {
       errors.push({
         file: file.relativePath,
-        message: "Failed to load segment file",
+        message: "Failed to load fragment file",
         details: error instanceof Error ? error.message : String(error)
       });
     }
@@ -70,33 +70,33 @@ async function validateSchema(config, configDir) {
   };
 }
 async function validateCoverage(config, configDir) {
-  const segmentFiles = await discoverSegmentFiles(config, configDir);
+  const fragmentFiles = await discoverFragmentFiles(config, configDir);
   const componentFiles = await discoverComponentFiles(config, configDir);
   const errors = [];
   const warnings = [];
   const documentedComponents = /* @__PURE__ */ new Set();
-  for (const file of segmentFiles) {
+  for (const file of fragmentFiles) {
     try {
-      const segment = await loadSegmentFile(file.absolutePath);
-      if (segment?.meta?.name) {
-        documentedComponents.add(segment.meta.name);
+      const fragment = await loadFragmentFile(file.absolutePath);
+      if (fragment?.meta?.name) {
+        documentedComponents.add(fragment.meta.name);
       }
     } catch {
     }
   }
   for (const file of componentFiles) {
     const componentName = extractComponentName(file.relativePath);
-    const segmentPath = file.relativePath.replace(
+    const fragmentPath = file.relativePath.replace(
       /\.(tsx?|jsx?)$/,
       BRAND.fileExtension
     );
-    const hasSegmentFile = segmentFiles.some(
-      (s) => s.relativePath === segmentPath
+    const hasFragmentFile = fragmentFiles.some(
+      (s) => s.relativePath === fragmentPath
     );
-    if (!hasSegmentFile && !documentedComponents.has(componentName)) {
+    if (!hasFragmentFile && !documentedComponents.has(componentName)) {
       warnings.push({
         file: file.relativePath,
-        message: `Component "${componentName}" has no segment documentation`
+        message: `Component "${componentName}" has no fragment documentation`
       });
     }
   }
@@ -120,8 +120,8 @@ async function validateAll(config, configDir) {
 
 // src/build.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { resolve as resolve2, join as join2 } from "path";
-import { existsSync as existsSync2 } from "fs";
+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";
@@ -162,11 +162,11 @@ function resolveModulePath(basePath) {
   }
   return null;
 }
-function resolveComponentSourcePath(segmentFileAbsolutePath, componentImportPath) {
+function resolveComponentSourcePath(fragmentFileAbsolutePath, componentImportPath) {
   if (!componentImportPath) return null;
   if (!componentImportPath.startsWith(".")) return null;
-  const segmentDir = dirname(segmentFileAbsolutePath);
-  const basePath = resolve(segmentDir, componentImportPath);
+  const fragmentDir = dirname(fragmentFileAbsolutePath);
+  const basePath = resolve(fragmentDir, componentImportPath);
   return resolveModulePath(basePath);
 }
 function collectTopLevelDeclarations(sourceFile) {
@@ -429,7 +429,391 @@ function extractCustomPropsFromComponentFile(componentFilePath, exportName) {
   };
 }
 
+// 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(fragments, blocks, componentDir, options) {
+  const knownComponents = new Set(Object.keys(fragments));
+  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(fragments, knownComponents);
+  allEdges.push(...jsxEdges);
+  const blockEdges = extractBlockEdges(blocks);
+  allEdges.push(...blockEdges);
+  const relationEdges = extractRelationEdges(fragments);
+  allEdges.push(...relationEdges);
+  const requiredChildrenMap = inferRequiredChildren(fragments, autoDetected);
+  for (const [name, children] of requiredChildrenMap) {
+    const existing = autoDetected.get(name) ?? {};
+    autoDetected.set(name, { ...existing, requiredChildren: children });
+  }
+  const patternsMap = generateCommonPatterns(fragments, 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(fragments).map(([name, fragment]) => {
+    const detected = autoDetected.get(name);
+    return {
+      name,
+      category: fragment.meta.category,
+      status: fragment.meta.status ?? "stable",
+      compositionPattern: fragment.ai?.compositionPattern ?? detected?.compositionPattern,
+      subComponents: fragment.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, fragment] of Object.entries(fragments)) {
+    const detected = autoDetected.get(name);
+    if (!detected) continue;
+    if (fragment.ai?.subComponents && detected.subComponents) {
+      const declared = new Set(fragment.ai.subComponents);
+      const found = new Set(detected.subComponents);
+      const missing = detected.subComponents.filter((s) => !declared.has(s));
+      const extra = fragment.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(fragments, knownComponents) {
+  const edges = [];
+  const jsxTagRegex = /<([A-Z][a-zA-Z]*(?:\.[A-Z][a-zA-Z]*)?)/g;
+  for (const [name, fragment] of Object.entries(fragments)) {
+    const usedComponents = /* @__PURE__ */ new Set();
+    for (const variant of fragment.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(fragments) {
+  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, fragment] of Object.entries(fragments)) {
+    if (!fragment.relations) continue;
+    for (const rel of fragment.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(fragments, autoDetected) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, fragment] of Object.entries(fragments)) {
+    const detected = autoDetected.get(name);
+    const subs = detected?.subComponents ?? fragment.ai?.subComponents;
+    if (!subs || subs.length === 0) continue;
+    const variantsWithCode = fragment.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(fragments, autoDetected) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, fragment] of Object.entries(fragments)) {
+    const detected = autoDetected.get(name);
+    const subs = detected?.subComponents ?? fragment.ai?.subComponents;
+    if (!subs || subs.length === 0) continue;
+    const firstVariant = fragment.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]) => [
@@ -464,15 +848,15 @@ function mergeDocumentedAndAutoProps(documentedProps, autoProps) {
     })
   );
 }
-async function buildSegments(config, configDir) {
-  const files = await discoverSegmentFiles(config, configDir);
+async function buildFragments(config, configDir) {
+  const files = await discoverFragmentFiles(config, configDir);
   const errors = [];
   const warnings = [];
-  const segments = {};
+  const fragments = {};
   for (const file of files) {
     try {
       const content = await readFile(file.absolutePath, "utf-8");
-      const parsed = parseSegmentFile(content, file.relativePath);
+      const parsed = parseFragmentFile(content, file.relativePath);
       for (const warning of parsed.warnings) {
         warnings.push({ file: file.relativePath, warning });
       }
@@ -563,7 +947,7 @@ async function buildSegments(config, configDir) {
         // Include AI metadata if present
         ...parsed.ai && { ai: parsed.ai }
       };
-      segments[parsed.meta.name] = compiled;
+      fragments[parsed.meta.name] = compiled;
     } catch (error) {
       errors.push({
         file: file.relativePath,
@@ -576,7 +960,7 @@ async function buildSegments(config, configDir) {
     const blockFiles = await discoverBlockFiles(configDir, config.exclude);
     for (const file of blockFiles) {
       try {
-        let raw = await loadSegmentFile(file.absolutePath);
+        let raw = await loadFragmentFile(file.absolutePath);
         if (raw && "default" in raw && typeof raw.default === "object") {
           raw = raw.default;
         }
@@ -625,35 +1009,67 @@ async function buildSegments(config, configDir) {
   } catch {
   }
   let packageName;
-  const pkgJsonPath = resolve2(configDir, "package.json");
-  if (existsSync2(pkgJsonPath)) {
+  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(fragments, blocks, componentDir);
+    for (const [name, fragment] of Object.entries(fragments)) {
+      const detected = graphResult.autoDetected.get(name);
+      if (!detected) continue;
+      if (!fragment.ai) fragment.ai = {};
+      if (!fragment.ai.subComponents && detected.subComponents) {
+        fragment.ai.subComponents = detected.subComponents;
+      }
+      if (!fragment.ai.compositionPattern && detected.compositionPattern) {
+        fragment.ai.compositionPattern = detected.compositionPattern;
+      }
+      if (!fragment.ai.commonPatterns && detected.commonPatterns) {
+        fragment.ai.commonPatterns = detected.commonPatterns;
+      }
+      if (!fragment.ai.requiredChildren && detected.requiredChildren) {
+        fragment.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,
+    fragments,
     ...Object.keys(blocks).length > 0 && { blocks },
-    ...tokens && { tokens }
+    ...tokens && { tokens },
+    ...graphData && { graph: graphData }
   };
-  const outputPath = resolve2(configDir, config.outFile ?? BRAND.outFile);
+  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,
+    fragmentCount: Object.keys(fragments).length,
     errors,
     warnings
   };
 }
 async function buildFragmentsDir(config, configDir) {
-  const fragmentsDir = join2(configDir, BRAND.dataDir);
-  const componentsDir = join2(fragmentsDir, BRAND.componentsDir);
+  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({
@@ -665,9 +1081,9 @@ async function buildFragmentsDir(config, configDir) {
   });
   const errors = [...registryResult.errors];
   const warnings = [...registryResult.warnings];
-  const indexPath = join2(fragmentsDir, "index.json");
+  const indexPath = join3(fragmentsDir, "index.json");
   await writeFile(indexPath, JSON.stringify(registryResult.index, null, 2));
-  const registryPath = join2(fragmentsDir, BRAND.registryFile);
+  const registryPath = join3(fragmentsDir, BRAND.registryFile);
   await writeFile(registryPath, JSON.stringify(registryResult.registry, null, 2));
   const contextResult = generateContextMd(registryResult.registry, {
     format: "markdown",
@@ -679,7 +1095,7 @@ async function buildFragmentsDir(config, configDir) {
       code: false
     }
   });
-  const contextPath = join2(fragmentsDir, BRAND.contextFile);
+  const contextPath = join3(fragmentsDir, BRAND.contextFile);
   await writeFile(contextPath, contextResult.content);
   return {
     success: errors.length === 0,
@@ -702,9 +1118,9 @@ async function runScreenshotCommand(config, configDir, options = {}) {
     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."));
+  const fragmentFiles = await discoverFragmentFiles(config, configDir);
+  if (fragmentFiles.length === 0) {
+    console.log(pc.yellow("No fragment files found."));
     return {
       success: true,
       captured: 0,
@@ -713,12 +1129,12 @@ async function runScreenshotCommand(config, configDir, options = {}) {
       totalTimeMs: Date.now() - startTime
     };
   }
-  const segments = [];
-  for (const file of segmentFiles) {
+  const fragments = [];
+  for (const file of fragmentFiles) {
     try {
-      const segment = await loadSegmentFile(file.absolutePath);
-      if (segment) {
-        segments.push({ path: file.relativePath, segment });
+      const fragment = await loadFragmentFile(file.absolutePath);
+      if (fragment) {
+        fragments.push({ path: file.relativePath, fragment });
       }
     } catch (error) {
       errors.push({
@@ -728,8 +1144,8 @@ async function runScreenshotCommand(config, configDir, options = {}) {
       });
     }
   }
-  const filteredSegments = options.component ? segments.filter((s) => s.segment.meta.name === options.component) : segments;
-  if (options.component && filteredSegments.length === 0) {
+  const filteredFragments = options.component ? fragments.filter((s) => s.fragment.meta.name === options.component) : fragments;
+  if (options.component && filteredFragments.length === 0) {
     console.log(pc.yellow(`Component "${options.component}" not found.`));
     return {
       success: false,
@@ -740,11 +1156,11 @@ async function runScreenshotCommand(config, configDir, options = {}) {
     };
   }
   const variantsToCapture = [];
-  for (const { segment } of filteredSegments) {
-    const variants = options.variant ? segment.variants.filter((v) => v.name === options.variant) : segment.variants;
+  for (const { fragment } of filteredFragments) {
+    const variants = options.variant ? fragment.variants.filter((v) => v.name === options.variant) : fragment.variants;
     for (const variant of variants) {
       variantsToCapture.push({
-        component: segment.meta.name,
+        component: fragment.meta.name,
         variant: variant.name,
         render: variant.render
       });
@@ -848,9 +1264,9 @@ async function runDiffCommand(config, configDir, options = {}) {
   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."));
+  const fragmentFiles = await discoverFragmentFiles(config, configDir);
+  if (fragmentFiles.length === 0) {
+    console.log(pc2.yellow("No fragment files found."));
     return {
       success: true,
       total: 0,
@@ -861,18 +1277,18 @@ async function runDiffCommand(config, configDir, options = {}) {
       totalTimeMs: Date.now() - startTime
     };
   }
-  const segments = [];
-  for (const file of segmentFiles) {
+  const fragments = [];
+  for (const file of fragmentFiles) {
     try {
-      const segment = await loadSegmentFile(file.absolutePath);
-      if (segment) {
-        segments.push({ path: file.relativePath, segment });
+      const fragment = await loadFragmentFile(file.absolutePath);
+      if (fragment) {
+        fragments.push({ path: file.relativePath, fragment });
       }
     } catch {
     }
   }
-  const filteredSegments = options.component ? segments.filter((s) => s.segment.meta.name === options.component) : segments;
-  if (options.component && filteredSegments.length === 0) {
+  const filteredFragments = options.component ? fragments.filter((s) => s.fragment.meta.name === options.component) : fragments;
+  if (options.component && filteredFragments.length === 0) {
     console.log(pc2.yellow(`Component "${options.component}" not found.`));
     return {
       success: false,
@@ -885,11 +1301,11 @@ async function runDiffCommand(config, configDir, options = {}) {
     };
   }
   const variantsToDiff = [];
-  for (const { segment } of filteredSegments) {
-    const variants = options.variant ? segment.variants.filter((v) => v.name === options.variant) : segment.variants;
+  for (const { fragment } of filteredFragments) {
+    const variants = options.variant ? fragment.variants.filter((v) => v.name === options.variant) : fragment.variants;
     for (const variant of variants) {
       variantsToDiff.push({
-        component: segment.meta.name,
+        component: fragment.meta.name,
         variant: variant.name
       });
     }
@@ -1032,9 +1448,9 @@ ${BRAND.name} Diff
 }
 
 // src/analyze.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join3, dirname as dirname2 } from "path";
+import { join as join4, dirname as dirname2 } from "path";
 import pc3 from "picocolors";
 async function runAnalyzeCommand(config, configDir, options = {}) {
   const format = options.format ?? "html";
@@ -1042,9 +1458,9 @@ async function runAnalyzeCommand(config, configDir, options = {}) {
   console.log(pc3.cyan(`
 ${BRAND.name} Analyzer
 `));
-  const segmentsPath = join3(configDir, config.outFile ?? "segments.json");
-  if (!existsSync3(segmentsPath)) {
-    console.log(pc3.red(`\u2717 No segments.json found. Run \`${BRAND.cliCommand} build\` first.
+  const fragmentsPath = join4(configDir, config.outFile ?? "fragments.json");
+  if (!existsSync4(fragmentsPath)) {
+    console.log(pc3.red(`\u2717 No fragments.json found. Run \`${BRAND.cliCommand} build\` first.
 `));
     return {
       success: false,
@@ -1052,7 +1468,7 @@ ${BRAND.name} Analyzer
     };
   }
   console.log(pc3.dim("Analyzing design system...\n"));
-  const content = await readFile2(segmentsPath, "utf-8");
+  const content = await readFile2(fragmentsPath, "utf-8");
   const data = JSON.parse(content);
   const analytics = analyzeDesignSystem(data);
   printConsoleSummary(analytics);
@@ -1137,8 +1553,8 @@ function colorizeScore(score) {
   return pc3.red(`${score}%`);
 }
 function getDefaultOutputPath(format, configDir) {
-  const filename = format === "html" ? "segments-report.html" : "segments-report.json";
-  return join3(configDir, filename);
+  const filename = format === "html" ? "fragments-report.html" : "fragments-report.json";
+  return join4(configDir, filename);
 }
 async function openInBrowser(path) {
   const { platform } = await import("os");
@@ -1200,10 +1616,10 @@ export {
   validateSchema,
   validateCoverage,
   validateAll,
-  buildSegments,
+  buildFragments,
   buildFragmentsDir,
   runScreenshotCommand,
   runDiffCommand,
   runAnalyzeCommand
 };
-//# sourceMappingURL=chunk-D35RGPAG.js.map
+//# sourceMappingURL=chunk-U6VTHBNI.js.map