@fragments-sdk/cli 0.7.0 → 0.7.1

package/dist/{chunk-7OPWMLOE.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-CVXKXVOY.js";
+  loadFragmentFile,
+  parseFragmentFile
+} from "./chunk-5ITIP3ES.js";
 import {
   compileBlock,
   parseTokenFile
-} from "./chunk-TJ34N7C7.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`
       });
     }
   }
@@ -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) {
@@ -435,8 +435,8 @@ 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));
+async function buildComponentGraph(fragments, blocks, componentDir, options) {
+  const knownComponents = new Set(Object.keys(fragments));
   const allEdges = [];
   const autoDetected = /* @__PURE__ */ new Map();
   const warnings = [];
@@ -452,31 +452,31 @@ async function buildComponentGraph(segments, blocks, componentDir, options) {
       });
     }
   }
-  const jsxEdges = extractJsxUsageEdges(segments, knownComponents);
+  const jsxEdges = extractJsxUsageEdges(fragments, knownComponents);
   allEdges.push(...jsxEdges);
   const blockEdges = extractBlockEdges(blocks);
   allEdges.push(...blockEdges);
-  const relationEdges = extractRelationEdges(segments);
+  const relationEdges = extractRelationEdges(fragments);
   allEdges.push(...relationEdges);
-  const requiredChildrenMap = inferRequiredChildren(segments, autoDetected);
+  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(segments, autoDetected);
+  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(segments).map(([name, segment]) => {
+  const nodes = Object.entries(fragments).map(([name, fragment]) => {
     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
+      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();
@@ -488,14 +488,14 @@ async function buildComponentGraph(segments, blocks, componentDir, options) {
     }
   }
   const health = computeHealthFromData(nodes, mergedEdges, blockIndex);
-  for (const [name, segment] of Object.entries(segments)) {
+  for (const [name, fragment] of Object.entries(fragments)) {
     const detected = autoDetected.get(name);
     if (!detected) continue;
-    if (segment.ai?.subComponents && detected.subComponents) {
-      const declared = new Set(segment.ai.subComponents);
+    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 = segment.ai.subComponents.filter((s) => !found.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(", ")}`
@@ -631,12 +631,12 @@ function extractSubComponents(componentDir, knownComponents) {
   }
   return result;
 }
-function extractJsxUsageEdges(segments, knownComponents) {
+function extractJsxUsageEdges(fragments, knownComponents) {
   const edges = [];
   const jsxTagRegex = /<([A-Z][a-zA-Z]*(?:\.[A-Z][a-zA-Z]*)?)/g;
-  for (const [name, segment] of Object.entries(segments)) {
+  for (const [name, fragment] of Object.entries(fragments)) {
     const usedComponents = /* @__PURE__ */ new Set();
-    for (const variant of segment.variants) {
+    for (const variant of fragment.variants) {
       if (!variant.code) continue;
       let match;
       jsxTagRegex.lastIndex = 0;
@@ -680,7 +680,7 @@ function extractBlockEdges(blocks) {
   }
   return edges;
 }
-function extractRelationEdges(segments) {
+function extractRelationEdges(fragments) {
   const edges = [];
   const relationToEdgeType = {
     parent: "parent-of",
@@ -690,9 +690,9 @@ function extractRelationEdges(segments) {
     alternative: "alternative-to",
     sibling: "sibling-of"
   };
-  for (const [name, segment] of Object.entries(segments)) {
-    if (!segment.relations) continue;
-    for (const rel of segment.relations) {
+  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;
@@ -716,13 +716,13 @@ function extractRelationEdges(segments) {
   }
   return edges;
 }
-function inferRequiredChildren(segments, autoDetected) {
+function inferRequiredChildren(fragments, autoDetected) {
   const result = /* @__PURE__ */ new Map();
-  for (const [name, segment] of Object.entries(segments)) {
+  for (const [name, fragment] of Object.entries(fragments)) {
     const detected = autoDetected.get(name);
-    const subs = detected?.subComponents ?? segment.ai?.subComponents;
+    const subs = detected?.subComponents ?? fragment.ai?.subComponents;
     if (!subs || subs.length === 0) continue;
-    const variantsWithCode = segment.variants.filter((v) => v.code);
+    const variantsWithCode = fragment.variants.filter((v) => v.code);
     if (variantsWithCode.length === 0) continue;
     const required = [];
     for (const sub of subs) {
@@ -741,13 +741,13 @@ function inferRequiredChildren(segments, autoDetected) {
   }
   return result;
 }
-function generateCommonPatterns(segments, autoDetected) {
+function generateCommonPatterns(fragments, autoDetected) {
   const result = /* @__PURE__ */ new Map();
-  for (const [name, segment] of Object.entries(segments)) {
+  for (const [name, fragment] of Object.entries(fragments)) {
     const detected = autoDetected.get(name);
-    const subs = detected?.subComponents ?? segment.ai?.subComponents;
+    const subs = detected?.subComponents ?? fragment.ai?.subComponents;
     if (!subs || subs.length === 0) continue;
-    const firstVariant = segment.variants.find((v) => v.code);
+    const firstVariant = fragment.variants.find((v) => v.code);
     if (!firstVariant?.code) continue;
     const usedSubs = [];
     for (const sub of subs) {
@@ -848,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 });
       }
@@ -947,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,
@@ -960,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;
         }
@@ -1020,22 +1020,22 @@ async function buildSegments(config, configDir) {
   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 graphResult = await buildComponentGraph(fragments, blocks, componentDir);
+    for (const [name, fragment] of Object.entries(fragments)) {
       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 (!fragment.ai) fragment.ai = {};
+      if (!fragment.ai.subComponents && detected.subComponents) {
+        fragment.ai.subComponents = detected.subComponents;
       }
-      if (!segment.ai.compositionPattern && detected.compositionPattern) {
-        segment.ai.compositionPattern = detected.compositionPattern;
+      if (!fragment.ai.compositionPattern && detected.compositionPattern) {
+        fragment.ai.compositionPattern = detected.compositionPattern;
       }
-      if (!segment.ai.commonPatterns && detected.commonPatterns) {
-        segment.ai.commonPatterns = detected.commonPatterns;
+      if (!fragment.ai.commonPatterns && detected.commonPatterns) {
+        fragment.ai.commonPatterns = detected.commonPatterns;
       }
-      if (!segment.ai.requiredChildren && detected.requiredChildren) {
-        segment.ai.requiredChildren = detected.requiredChildren;
+      if (!fragment.ai.requiredChildren && detected.requiredChildren) {
+        fragment.ai.requiredChildren = detected.requiredChildren;
       }
     }
     for (const w of graphResult.warnings) {
@@ -1052,7 +1052,7 @@ async function buildSegments(config, configDir) {
     version: "1.0.0",
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...packageName && { packageName },
-    segments,
+    fragments,
     ...Object.keys(blocks).length > 0 && { blocks },
     ...tokens && { tokens },
     ...graphData && { graph: graphData }
@@ -1062,7 +1062,7 @@ async function buildSegments(config, configDir) {
   return {
     success: errors.length === 0,
     outputPath,
-    segmentCount: Object.keys(segments).length,
+    fragmentCount: Object.keys(fragments).length,
     errors,
     warnings
   };
@@ -1118,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,
@@ -1129,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({
@@ -1144,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,
@@ -1156,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
       });
@@ -1264,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,
@@ -1277,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,
@@ -1301,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
       });
     }
@@ -1458,9 +1458,9 @@ async function runAnalyzeCommand(config, configDir, options = {}) {
   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.
+  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,
@@ -1468,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);
@@ -1553,7 +1553,7 @@ function colorizeScore(score) {
   return pc3.red(`${score}%`);
 }
 function getDefaultOutputPath(format, configDir) {
-  const filename = format === "html" ? "segments-report.html" : "segments-report.json";
+  const filename = format === "html" ? "fragments-report.html" : "fragments-report.json";
   return join4(configDir, filename);
 }
 async function openInBrowser(path) {
@@ -1616,10 +1616,10 @@ export {
   validateSchema,
   validateCoverage,
   validateAll,
-  buildSegments,
+  buildFragments,
   buildFragmentsDir,
   runScreenshotCommand,
   runDiffCommand,
   runAnalyzeCommand
 };
-//# sourceMappingURL=chunk-7OPWMLOE.js.map
+//# sourceMappingURL=chunk-U6VTHBNI.js.map