@fragments-sdk/cli 0.7.0 → 0.7.2

package/src/commands/link/figma.ts

@@ -1,12 +1,12 @@
 /**
- * fragments link figma - Link Figma components to segments
+ * fragments link figma - Link Figma components to fragments
  */
 
 import { readFile, writeFile } from 'node:fs/promises';
 import { relative } from 'node:path';
 import pc from 'picocolors';
 import { BRAND } from '../../core/index.js';
-import { loadConfig, discoverSegmentFiles } from '../../core/node.js';
+import { loadConfig, discoverFragmentFiles } from '../../core/node.js';
 import { FigmaClient } from '../../service/index.js';
 
 /**
@@ -33,29 +33,29 @@ export interface LinkFigmaResult {
 }
 
 /**
- * Segment variant info
+ * Fragment variant info
  */
-interface SegmentVariantInfo {
+interface FragmentVariantInfo {
   name: string;
   hasFigma: boolean;
 }
 
 /**
- * Segment info
+ * Fragment info
  */
-interface SegmentInfo {
+interface FragmentInfo {
   name: string;
   filePath: string;
   relativePath: string;
   hasFigma: boolean;
-  variants: SegmentVariantInfo[];
+  variants: FragmentVariantInfo[];
 }
 
 /**
  * Match result
  */
 interface Match {
-  segment: SegmentInfo;
+  fragment: FragmentInfo;
   figmaComponent: {
     name: string;
     description: string;
@@ -145,20 +145,20 @@ export async function linkFigma(
     console.log();
   }
 
-  // Discover local segments
-  const segmentFiles = await discoverSegmentFiles(config, configDir);
+  // Discover local fragments
+  const fragmentFiles = await discoverFragmentFiles(config, configDir);
 
-  if (segmentFiles.length === 0) {
-    console.log(pc.yellow('No segment files found in codebase.'));
+  if (fragmentFiles.length === 0) {
+    console.log(pc.yellow('No fragment files found in codebase.'));
     console.log(pc.dim(`Looking for: ${config.include.join(', ')}`));
     process.exit(0);
   }
 
-  console.log(pc.dim(`Found ${segmentFiles.length} segment file(s)\n`));
+  console.log(pc.dim(`Found ${fragmentFiles.length} fragment file(s)\n`));
 
-  // Load segments to get names
-  const segments: SegmentInfo[] = [];
-  for (const file of segmentFiles) {
+  // Load fragments to get names
+  const fragments: FragmentInfo[] = [];
+  for (const file of fragmentFiles) {
     try {
       const content = await readFile(file.absolutePath, 'utf-8');
       // Extract name from meta.name in the file
@@ -167,15 +167,15 @@ export async function linkFigma(
       const hasFigma = /meta:\s*\{[^}]*figma:\s*['"]https?:/.test(content);
 
       // Extract variant names and their figma status
-      const segmentVariants = extractVariants(content, nameMatch?.[1]);
+      const fragmentVariants = extractVariants(content, nameMatch?.[1]);
 
       if (nameMatch) {
-        segments.push({
+        fragments.push({
           name: nameMatch[1],
           filePath: file.absolutePath,
           relativePath: file.relativePath,
           hasFigma,
-          variants: segmentVariants,
+          variants: fragmentVariants,
         });
       }
     } catch {
@@ -185,15 +185,15 @@ export async function linkFigma(
 
   // Find matches
   const matches: Match[] = [];
-  const unmatchedSegments: SegmentInfo[] = [];
+  const unmatchedFragments: FragmentInfo[] = [];
 
-  for (const segment of segments) {
+  for (const fragment of fragments) {
     // Find best matching Figma component
     let bestMatch: typeof allFigmaComponents[0] | null = null;
     let bestScore = 0;
 
     for (const figmaComp of allFigmaComponents) {
-      const score = calculateMatchScore(segment.name, figmaComp.name);
+      const score = calculateMatchScore(fragment.name, figmaComp.name);
 
       if (score > bestScore) {
         bestMatch = figmaComp;
@@ -206,19 +206,19 @@ export async function linkFigma(
 
     // Accept matches with 65%+ score
     if (bestMatch && bestScore >= 65) {
-      const alreadyLinked = segment.hasFigma;
+      const alreadyLinked = fragment.hasFigma;
       if (alreadyLinked && !auto) {
-        console.log(pc.dim(`⏭️  ${segment.name} (already linked)`));
+        console.log(pc.dim(`⏭️  ${fragment.name} (already linked)`));
       }
-      matches.push({ segment, figmaComponent: bestMatch, score: bestScore, alreadyLinked });
+      matches.push({ fragment, figmaComponent: bestMatch, score: bestScore, alreadyLinked });
     } else {
-      unmatchedSegments.push(segment);
+      unmatchedFragments.push(fragment);
     }
   }
 
-  if (unmatchedSegments.length > 0) {
-    console.log(pc.dim('Unmatched segments:'));
-    for (const seg of unmatchedSegments) {
+  if (unmatchedFragments.length > 0) {
+    console.log(pc.dim('Unmatched fragments:'));
+    for (const seg of unmatchedFragments) {
       console.log(`  ${pc.dim('•')} ${seg.name}`);
     }
     console.log();
@@ -230,7 +230,7 @@ export async function linkFigma(
 
   if (matches.length === 0) {
     console.log(pc.yellow('\nNo automatic matches found.'));
-    console.log(pc.dim('You can manually add figma URLs to your segment definitions.'));
+    console.log(pc.dim('You can manually add figma URLs to your fragment definitions.'));
     process.exit(0);
   }
 
@@ -241,7 +241,7 @@ export async function linkFigma(
       for (const match of newMatches) {
         const scoreColor = match.score === 100 ? pc.green : pc.yellow;
         console.log(
-          `  ${pc.green('✓')} ${pc.bold(match.segment.name)} → ${match.figmaComponent.name} ${scoreColor(`(${Math.round(match.score)}%)`)}`
+          `  ${pc.green('✓')} ${pc.bold(match.fragment.name)} → ${match.figmaComponent.name} ${scoreColor(`(${Math.round(match.score)}%)`)}`
         );
       }
     }
@@ -259,7 +259,7 @@ export async function linkFigma(
       for (const match of newMatches) {
         const scoreColor = match.score === 100 ? pc.green : pc.yellow;
         console.log(
-          `  ${pc.green('✓')} ${pc.bold(match.segment.name)} → ${match.figmaComponent.name} ${scoreColor(`(${Math.round(match.score)}%)`)}`
+          `  ${pc.green('✓')} ${pc.bold(match.fragment.name)} → ${match.figmaComponent.name} ${scoreColor(`(${Math.round(match.score)}%)`)}`
         );
       }
     } else {
@@ -272,7 +272,7 @@ export async function linkFigma(
       const choices = newMatches.map((match) => {
         const scoreColor = match.score === 100 ? pc.green : pc.yellow;
         return {
-          name: `${pc.bold(match.segment.name)} → ${match.figmaComponent.name} ${scoreColor(`(${Math.round(match.score)}%)`)}`,
+          name: `${pc.bold(match.fragment.name)} → ${match.figmaComponent.name} ${scoreColor(`(${Math.round(match.score)}%)`)}`,
           value: match,
           checked: true,
         };
@@ -295,13 +295,13 @@ export async function linkFigma(
   // Include already-linked matches for variant linking
   const allSelectedMatches = [...selectedMatches, ...alreadyLinkedMatches];
 
-  // Update segment files (only for new matches, not already-linked)
+  // Update fragment files (only for new matches, not already-linked)
   let updated = 0;
   for (const match of selectedMatches) {
     if (match.alreadyLinked) continue;
 
     try {
-      let content = await readFile(match.segment.filePath, 'utf-8');
+      let content = await readFile(match.fragment.filePath, 'utf-8');
       const figmaUrlToInsert = figmaClient.buildNodeUrl(
         match.figmaComponent.file_key,
         match.figmaComponent.node_id,
@@ -323,16 +323,16 @@ export async function linkFigma(
         );
       }
 
-      await writeFile(match.segment.filePath, content);
+      await writeFile(match.fragment.filePath, content);
       updated++;
-      console.log(`  ${pc.green('✓')} Updated ${match.segment.relativePath}`);
+      console.log(`  ${pc.green('✓')} Updated ${match.fragment.relativePath}`);
     } catch (error) {
-      console.log(`  ${pc.red('✗')} Failed to update ${match.segment.relativePath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      console.log(`  ${pc.red('✗')} Failed to update ${match.fragment.relativePath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
   }
 
   if (updated > 0) {
-    console.log(pc.green(`\n✓ Updated ${updated} segment file(s)\n`));
+    console.log(pc.green(`\n✓ Updated ${updated} fragment file(s)\n`));
   }
 
   // Variant linking
@@ -357,10 +357,10 @@ export async function linkFigma(
 }
 
 /**
- * Extract variants from segment file content
+ * Extract variants from fragment file content
  */
-function extractVariants(content: string, componentName?: string): SegmentVariantInfo[] {
-  const variants: SegmentVariantInfo[] = [];
+function extractVariants(content: string, componentName?: string): FragmentVariantInfo[] {
+  const variants: FragmentVariantInfo[] = [];
 
   // Find variants: [ ... ] section
   const variantsArrayMatch = content.match(/variants:\s*\[/);
@@ -411,27 +411,27 @@ function extractVariants(content: string, componentName?: string): SegmentVarian
 /**
  * Calculate match score between two names
  */
-function calculateMatchScore(segmentName: string, figmaName: string): number {
+function calculateMatchScore(fragmentName: string, figmaName: string): number {
   const normalizeForMatch = (s: string) =>
     s.toLowerCase().replace(/[^a-z0-9]/g, '');
 
-  const normalizedSegment = normalizeForMatch(segmentName);
+  const normalizedFragment = normalizeForMatch(fragmentName);
   const normalizedFigma = normalizeForMatch(figmaName);
 
   // Exact match after normalization
-  if (normalizedSegment === normalizedFigma) {
+  if (normalizedFragment === normalizedFigma) {
     return 100;
   }
 
-  // Check if segment name appears at the START of figma name
-  if (normalizedFigma.startsWith(normalizedSegment)) {
-    const coverage = normalizedSegment.length / normalizedFigma.length;
+  // Check if fragment name appears at the START of figma name
+  if (normalizedFigma.startsWith(normalizedFragment)) {
+    const coverage = normalizedFragment.length / normalizedFigma.length;
     return Math.max(85, coverage * 100);
   }
 
-  // Check if figma name appears at the START of segment name
-  if (normalizedSegment.startsWith(normalizedFigma)) {
-    const coverage = normalizedFigma.length / normalizedSegment.length;
+  // Check if figma name appears at the START of fragment name
+  if (normalizedFragment.startsWith(normalizedFigma)) {
+    const coverage = normalizedFigma.length / normalizedFragment.length;
     return Math.max(80, coverage * 100);
   }
 
@@ -445,24 +445,24 @@ function calculateMatchScore(segmentName: string, figmaName: string): number {
       .filter((w) => w.length > 0);
   };
 
-  const segmentWords = getWords(segmentName);
+  const fragmentWords = getWords(fragmentName);
   const figmaWords = getWords(figmaName);
 
-  // Check if all segment words appear in figma words
-  const allSegmentWordsInFigma = segmentWords.every((sw) =>
+  // Check if all fragment words appear in figma words
+  const allFragmentWordsInFigma = fragmentWords.every((sw) =>
     figmaWords.some((fw) => fw === sw || fw.startsWith(sw) || sw.startsWith(fw))
   );
 
-  if (allSegmentWordsInFigma && segmentWords.length > 0) {
-    const wordOverlap = segmentWords.length / Math.max(segmentWords.length, figmaWords.length);
+  if (allFragmentWordsInFigma && fragmentWords.length > 0) {
+    const wordOverlap = fragmentWords.length / Math.max(fragmentWords.length, figmaWords.length);
     return Math.max(75, wordOverlap * 95);
   }
 
   // Partial containment
-  if (normalizedFigma.includes(normalizedSegment)) {
+  if (normalizedFigma.includes(normalizedFragment)) {
     return 70;
   }
-  if (normalizedSegment.includes(normalizedFigma)) {
+  if (normalizedFragment.includes(normalizedFigma)) {
     return 65;
   }
 
@@ -510,16 +510,16 @@ async function linkVariants(
       continue;
     }
 
-    // Match segment variants to Figma variants
-    const segmentVariants = match.segment.variants.filter((v) => !v.hasFigma);
-    if (segmentVariants.length === 0) {
-      console.log(pc.dim(`  ⏭️  ${match.segment.name}: all variants already linked`));
+    // Match fragment variants to Figma variants
+    const fragmentVariants = match.fragment.variants.filter((v) => !v.hasFigma);
+    if (fragmentVariants.length === 0) {
+      console.log(pc.dim(`  ⏭️  ${match.fragment.name}: all variants already linked`));
       continue;
     }
 
-    console.log(pc.dim(`  ${match.segment.name}: ${csWithVariants.variants.length} Figma variants`));
+    console.log(pc.dim(`  ${match.fragment.name}: ${csWithVariants.variants.length} Figma variants`));
 
-    for (const segmentVariant of segmentVariants) {
+    for (const fragmentVariant of fragmentVariants) {
       // Find matching Figma variants by score
       const variantMatches: Array<{
         figmaVariant: typeof csWithVariants.variants[0];
@@ -527,18 +527,18 @@ async function linkVariants(
       }> = [];
 
       for (const fv of csWithVariants.variants) {
-        // Check if any property value matches the segment variant name
-        const normalizedSegment = normalizeForMatch(segmentVariant.name);
+        // Check if any property value matches the fragment variant name
+        const normalizedFragment = normalizeForMatch(fragmentVariant.name);
 
         for (const value of fv.values) {
           const normalizedValue = normalizeForMatch(value);
 
-          if (normalizedSegment === normalizedValue) {
+          if (normalizedFragment === normalizedValue) {
             variantMatches.push({ figmaVariant: fv, score: 100 });
             break;
-          } else if (normalizedValue.includes(normalizedSegment)) {
+          } else if (normalizedValue.includes(normalizedFragment)) {
             variantMatches.push({ figmaVariant: fv, score: 85 });
-          } else if (normalizedSegment.includes(normalizedValue)) {
+          } else if (normalizedFragment.includes(normalizedValue)) {
             variantMatches.push({ figmaVariant: fv, score: 75 });
           }
         }
@@ -557,11 +557,11 @@ async function linkVariants(
         );
 
         try {
-          let content = await readFile(match.segment.filePath, 'utf-8');
+          let content = await readFile(match.fragment.filePath, 'utf-8');
 
           // Add figma URL after the variant's name field
           const namePattern = new RegExp(
-            `(name:\\s*['"]${escapeRegExp(segmentVariant.name)}['"],?)`,
+            `(name:\\s*['"]${escapeRegExp(fragmentVariant.name)}['"],?)`,
             'g'
           );
 
@@ -572,14 +572,14 @@ async function linkVariants(
             return `${matchedStr}\n      figma: '${variantUrl}',`;
           });
 
-          await writeFile(match.segment.filePath, content);
+          await writeFile(match.fragment.filePath, content);
           variantUpdates++;
           console.log(
-            `    ${pc.green('✓')} ${segmentVariant.name} → ${bestMatch.figmaVariant.name}`
+            `    ${pc.green('✓')} ${fragmentVariant.name} → ${bestMatch.figmaVariant.name}`
           );
         } catch (error) {
           console.log(
-            `    ${pc.red('✗')} ${segmentVariant.name}: ${error instanceof Error ? error.message : 'Unknown error'}`
+            `    ${pc.red('✗')} ${fragmentVariant.name}: ${error instanceof Error ? error.message : 'Unknown error'}`
           );
         }
       } else if (variantMatches.length > 0) {
@@ -594,7 +594,7 @@ async function linkVariants(
 
         try {
           const selectedVariant = await select({
-            message: `  Match for "${segmentVariant.name}":`,
+            message: `  Match for "${fragmentVariant.name}":`,
             choices,
           });
 
@@ -605,9 +605,9 @@ async function linkVariants(
               figmaData.fileName
             );
 
-            let content = await readFile(match.segment.filePath, 'utf-8');
+            let content = await readFile(match.fragment.filePath, 'utf-8');
             const namePattern = new RegExp(
-              `(name:\\s*['"]${escapeRegExp(segmentVariant.name)}['"],?)`,
+              `(name:\\s*['"]${escapeRegExp(fragmentVariant.name)}['"],?)`,
               'g'
             );
 
@@ -618,19 +618,19 @@ async function linkVariants(
               return `${matchedStr}\n      figma: '${variantUrl}',`;
             });
 
-            await writeFile(match.segment.filePath, content);
+            await writeFile(match.fragment.filePath, content);
             variantUpdates++;
             console.log(
-              `    ${pc.green('✓')} ${segmentVariant.name} → ${selectedVariant.name}`
+              `    ${pc.green('✓')} ${fragmentVariant.name} → ${selectedVariant.name}`
             );
           } else {
-            console.log(`    ${pc.dim('⏭️')} ${segmentVariant.name} (skipped)`);
+            console.log(`    ${pc.dim('⏭️')} ${fragmentVariant.name} (skipped)`);
           }
         } catch {
-          console.log(`    ${pc.dim('⏭️')} ${segmentVariant.name} (cancelled)`);
+          console.log(`    ${pc.dim('⏭️')} ${fragmentVariant.name} (cancelled)`);
         }
       } else {
-        console.log(`    ${pc.yellow('?')} ${segmentVariant.name}: no matching Figma variant`);
+        console.log(`    ${pc.yellow('?')} ${fragmentVariant.name}: no matching Figma variant`);
       }
     }
   }

package/src/commands/link/index.ts

@@ -1,9 +1,9 @@
 /**
- * fragments link - Link external resources to segments
+ * fragments link - Link external resources to fragments
  *
  * This module provides subcommands for:
- * - figma: Link Figma components to segments
- * - storybook: Bootstrap segments from Storybook stories
+ * - figma: Link Figma components to fragments
+ * - storybook: Bootstrap fragments from Storybook stories
  */
 
 export { linkFigma, type LinkFigmaOptions, type LinkFigmaResult } from './figma.js';

package/src/commands/link/storybook.ts

@@ -1,5 +1,5 @@
 /**
- * fragments link storybook - Bootstrap segments from Storybook stories
+ * fragments link storybook - Bootstrap fragments from Storybook stories
  */
 
 import { writeFile, mkdir } from 'node:fs/promises';
@@ -10,7 +10,7 @@ import {
   detectStorybookConfig,
   discoverStoryFiles as discoverStorybookFiles,
   parseStoryFile,
-  convertToSegment,
+  convertToFragment,
 } from '../../migrate/index.js';
 
 /**
@@ -19,7 +19,7 @@ import {
 export interface LinkStorybookOptions {
   /** Path to .storybook/main.* config */
   config?: string;
-  /** Output directory for segment files */
+  /** Output directory for fragment files */
   out?: string;
   /** Skip confirmation prompts */
   yes?: boolean;
@@ -114,7 +114,7 @@ export async function linkStorybook(
 
     try {
       const parsed = await parseStoryFile(storyFile);
-      const result = convertToSegment(parsed);
+      const result = convertToFragment(parsed);
 
       // Determine output path
       const outputFile = out
@@ -177,7 +177,7 @@ export async function linkStorybook(
 
   // Dry run stops here
   if (dryRun) {
-    console.log(pc.dim(`\n${previews.length} segment file(s) would be created`));
+    console.log(pc.dim(`\n${previews.length} fragment file(s) would be created`));
     console.log(pc.yellow('\n[Dry run - no files were written]'));
     return { success: true, generated: 0 };
   }
@@ -186,7 +186,7 @@ export async function linkStorybook(
   let selectedPreviews = previews;
 
   if (yes) {
-    console.log(pc.dim(`\n${previews.length} segment file(s) will be created`));
+    console.log(pc.dim(`\n${previews.length} fragment file(s) will be created`));
   } else {
     const { checkbox } = await import('@inquirer/prompts');
 
@@ -222,7 +222,7 @@ export async function linkStorybook(
 
   // Generate files
   const genTotal = selectedPreviews.length;
-  console.log(pc.dim(`\nGenerating ${genTotal} segment file(s)...\n`));
+  console.log(pc.dim(`\nGenerating ${genTotal} fragment file(s)...\n`));
 
   let generated = 0;
   let genErrors = 0;
@@ -231,7 +231,7 @@ export async function linkStorybook(
     const storyFile = join(projectRoot, preview.sourceFile);
     try {
       const parsed = await parseStoryFile(storyFile);
-      const result = convertToSegment(parsed);
+      const result = convertToFragment(parsed);
 
       // Determine output path
       const outputFile = out
@@ -252,7 +252,7 @@ export async function linkStorybook(
     }
   }
 
-  console.log(pc.green(`\n✓ Generated ${generated} segment file(s)\n`));
+  console.log(pc.green(`\n✓ Generated ${generated} fragment file(s)\n`));
 
   // Next steps
   console.log(pc.dim('───────────────────────────────────────'));

package/src/commands/list.ts

@@ -4,7 +4,7 @@
 
 import pc from 'picocolors';
 import { BRAND } from '../core/index.js';
-import { loadConfig, discoverSegmentFiles } from '../core/node.js';
+import { loadConfig, discoverFragmentFiles } from '../core/node.js';
 
 /**
  * Options for list command
@@ -30,7 +30,7 @@ export interface ListResult {
  */
 export async function list(options: ListOptions = {}): Promise<ListResult> {
   const { config, configDir } = await loadConfig(options.config);
-  const files = await discoverSegmentFiles(config, configDir);
+  const files = await discoverFragmentFiles(config, configDir);
 
   console.log(pc.cyan(`\n${BRAND.name} - Discovered Fragments\n`));
 

package/src/commands/reset.ts

@@ -42,7 +42,7 @@ export async function reset(options: ResetOptions = {}): Promise<ResetResult> {
   const filesToDelete: string[] = [];
   const dirsToDelete: string[] = [];
 
-  // Check data directory (.segments/)
+  // Check data directory (.fragments/)
   const dataDir = join(projectRoot, BRAND.dataDir);
   try {
     const dataDirStat = await stat(dataDir);
@@ -53,8 +53,8 @@ export async function reset(options: ResetOptions = {}): Promise<ResetResult> {
     // Directory doesn't exist
   }
 
-  // Check for segments.json (default output file)
-  const defaultOutFile = join(projectRoot, 'segments.json');
+  // Check for fragments.json (default output file)
+  const defaultOutFile = join(projectRoot, 'fragments.json');
   try {
     const fileStat = await stat(defaultOutFile);
     if (fileStat.isFile()) {
@@ -65,10 +65,10 @@ export async function reset(options: ResetOptions = {}): Promise<ResetResult> {
   }
 
   // Try to load config for custom outFile and include patterns
-  let segmentPatterns = [`**/*${BRAND.fileExtension}`];
+  let fragmentPatterns = [`**/*${BRAND.fileExtension}`];
   try {
     const { config } = await loadConfig();
-    if (config.outFile && config.outFile !== 'segments.json') {
+    if (config.outFile && config.outFile !== 'fragments.json') {
       const customOutFile = join(projectRoot, config.outFile);
       try {
         const fileStat = await stat(customOutFile);
@@ -81,15 +81,15 @@ export async function reset(options: ResetOptions = {}): Promise<ResetResult> {
     }
     // Use config include patterns if available
     if (config.include && config.include.length > 0) {
-      segmentPatterns = config.include;
+      fragmentPatterns = config.include;
     }
   } catch {
     // No config file, use defaults
   }
 
-  // Find all segment files (*.segment.tsx)
+  // Find all fragment files (*.fragment.tsx)
   console.log(pc.dim('Scanning for generated files...\n'));
-  for (const pattern of segmentPatterns) {
+  for (const pattern of fragmentPatterns) {
     const matches = await fg(pattern, {
       cwd: projectRoot,
       ignore: ['**/node_modules/**'],
@@ -130,23 +130,23 @@ export async function reset(options: ResetOptions = {}): Promise<ResetResult> {
   }
 
   // Group files by type for cleaner output
-  const segmentFiles = filesToDelete.filter((f) => f.endsWith(BRAND.fileExtension));
+  const fragmentFiles = filesToDelete.filter((f) => f.endsWith(BRAND.fileExtension));
   const mdxFilesFound = filesToDelete.filter((f) => f.endsWith('.mdx'));
   const otherFiles = filesToDelete.filter(
     (f) => !f.endsWith(BRAND.fileExtension) && !f.endsWith('.mdx')
   );
 
-  if (segmentFiles.length > 0) {
-    console.log(`  📄 ${segmentFiles.length} segment file(s) (*${BRAND.fileExtension})`);
-    if (segmentFiles.length <= 5) {
-      for (const f of segmentFiles) {
+  if (fragmentFiles.length > 0) {
+    console.log(`  📄 ${fragmentFiles.length} fragment file(s) (*${BRAND.fileExtension})`);
+    if (fragmentFiles.length <= 5) {
+      for (const f of fragmentFiles) {
         console.log(pc.dim(`     ${relative(projectRoot, f)}`));
       }
     } else {
-      for (const f of segmentFiles.slice(0, 3)) {
+      for (const f of fragmentFiles.slice(0, 3)) {
         console.log(pc.dim(`     ${relative(projectRoot, f)}`));
       }
-      console.log(pc.dim(`     ... and ${segmentFiles.length - 3} more`));
+      console.log(pc.dim(`     ... and ${fragmentFiles.length - 3} more`));
     }
   }