@fragments-sdk/cli 0.9.1 → 0.10.1

package/dist/{chunk-GF6OVPIN.js → chunk-OQO55NKV.js}

@@ -1,10 +1,88 @@
 import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
-import {
-  blockDefinitionSchema,
-  fragmentDefinitionSchema
-} from "./chunk-NVSPGSKB.js";
 
-// src/core/performance-presets.ts
+// ../core/dist/index.js
+import { z } from "zod";
+import { createElement } from "react";
+import {
+  toId as storybookToId,
+  storyNameFromExport as storybookStoryNameFromExport,
+  isExportStory as storybookIsExportStory
+} from "@storybook/csf";
+import { generateContext, filterPlaceholders, PLACEHOLDER_PATTERNS } from "@fragments-sdk/context/generate";
+import { ComponentGraphEngine } from "@fragments-sdk/context/graph";
+import { useEffect, useState } from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+var BRAND = {
+  /** Display name (e.g., "Fragments") */
+  name: "Fragments",
+  /** Lowercase name for file paths and CLI (e.g., "fragments") */
+  nameLower: "fragments",
+  /** File extension for fragment definition files (e.g., ".fragment.tsx") */
+  fileExtension: ".fragment.tsx",
+  /** Legacy file extension for segments (still supported for migration) */
+  legacyFileExtension: ".segment.tsx",
+  /** JSON file extension for compiled output */
+  jsonExtension: ".fragment.json",
+  /** Default output file name (e.g., "fragments.json") */
+  outFile: "fragments.json",
+  /** Config file name (e.g., "fragments.config.ts") */
+  configFile: "fragments.config.ts",
+  /** Legacy config file name (still supported for migration) */
+  legacyConfigFile: "segments.config.ts",
+  /** CLI command name (e.g., "fragments") */
+  cliCommand: "fragments",
+  /** Package scope (e.g., "@fragments") */
+  packageScope: "@fragments",
+  /** Directory for storing fragments, registry, and cache */
+  dataDir: ".fragments",
+  /** Components subdirectory within .fragments/ */
+  componentsDir: "components",
+  /** Registry file name */
+  registryFile: "registry.json",
+  /** Context file name (AI-ready markdown) */
+  contextFile: "context.md",
+  /** Screenshots subdirectory */
+  screenshotsDir: "screenshots",
+  /** Cache subdirectory (gitignored) */
+  cacheDir: "cache",
+  /** Diff output subdirectory (gitignored) */
+  diffDir: "diff",
+  /** Manifest filename */
+  manifestFile: "manifest.json",
+  /** Prefix for localStorage keys (e.g., "fragments-") */
+  storagePrefix: "fragments-",
+  /** Static viewer HTML file name */
+  viewerHtmlFile: "fragments-viewer.html",
+  /** MCP tool name prefix (e.g., "fragments_") */
+  mcpToolPrefix: "fragments_",
+  /** File extension for block definition files */
+  blockFileExtension: ".block.ts",
+  /** @deprecated Use blockFileExtension instead */
+  recipeFileExtension: ".recipe.ts",
+  /** Vite plugin namespace */
+  vitePluginNamespace: "fragments-core-shim"
+};
+var DEFAULTS = {
+  /** Default viewport dimensions */
+  viewport: {
+    width: 1280,
+    height: 800
+  },
+  /** Default diff threshold (percentage) */
+  diffThreshold: 5,
+  /** Browser pool size */
+  poolSize: 3,
+  /** Idle timeout before browser shutdown (ms) - 5 minutes */
+  idleTimeoutMs: 5 * 60 * 1e3,
+  /** Delay after render before capture (ms) */
+  captureDelayMs: 100,
+  /** Font loading timeout (ms) */
+  fontTimeoutMs: 3e3,
+  /** Default theme */
+  theme: "light",
+  /** Dev server port */
+  port: 6006
+};
 var PRESETS = {
   strict: { bundleSize: 8 * 1024 },
   // 8KB gzipped
@@ -56,8 +134,187 @@ function budgetBar(percent, width = 20) {
   const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
   return percent > 100 ? `\x1B[31m${bar}\x1B[0m` : `\x1B[32m${bar}\x1B[0m`;
 }
-
-// src/core/defineFragment.ts
+var figmaStringMappingSchema = z.object({
+  __type: z.literal("figma-string"),
+  figmaProperty: z.string().min(1)
+});
+var figmaBooleanMappingSchema = z.object({
+  __type: z.literal("figma-boolean"),
+  figmaProperty: z.string().min(1),
+  valueMapping: z.object({ true: z.unknown(), false: z.unknown() }).optional()
+});
+var figmaEnumMappingSchema = z.object({
+  __type: z.literal("figma-enum"),
+  figmaProperty: z.string().min(1),
+  valueMapping: z.record(z.unknown())
+});
+var figmaInstanceMappingSchema = z.object({
+  __type: z.literal("figma-instance"),
+  figmaProperty: z.string().min(1)
+});
+var figmaChildrenMappingSchema = z.object({
+  __type: z.literal("figma-children"),
+  layers: z.array(z.string().min(1))
+});
+var figmaTextContentMappingSchema = z.object({
+  __type: z.literal("figma-text-content"),
+  layer: z.string().min(1)
+});
+var figmaPropMappingSchema = z.discriminatedUnion("__type", [
+  figmaStringMappingSchema,
+  figmaBooleanMappingSchema,
+  figmaEnumMappingSchema,
+  figmaInstanceMappingSchema,
+  figmaChildrenMappingSchema,
+  figmaTextContentMappingSchema
+]);
+var fragmentMetaSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  category: z.string().min(1),
+  tags: z.array(z.string()).optional(),
+  status: z.enum(["stable", "beta", "deprecated", "experimental"]).optional(),
+  since: z.string().optional(),
+  dependencies: z.array(z.object({
+    name: z.string().min(1),
+    version: z.string().min(1),
+    reason: z.string().optional()
+  })).optional(),
+  figma: z.string().url().optional(),
+  figmaProps: z.record(figmaPropMappingSchema).optional()
+});
+var fragmentUsageSchema = z.object({
+  when: z.array(z.string()),
+  whenNot: z.array(z.string()),
+  guidelines: z.array(z.string()).optional(),
+  accessibility: z.array(z.string()).optional()
+});
+var propTypeSchema = z.enum([
+  "string",
+  "number",
+  "boolean",
+  "enum",
+  "function",
+  "node",
+  "element",
+  "object",
+  "array",
+  "union",
+  "custom"
+]);
+var propDefinitionSchema = z.object({
+  type: propTypeSchema,
+  values: z.array(z.string()).readonly().optional(),
+  default: z.unknown().optional(),
+  description: z.string().optional(),
+  required: z.boolean().optional(),
+  constraints: z.array(z.string()).optional(),
+  typeDetails: z.record(z.unknown()).optional()
+});
+var relationshipTypeSchema = z.enum([
+  "alternative",
+  "sibling",
+  "parent",
+  "child",
+  "composition",
+  "complementary",
+  "used-by"
+]);
+var componentRelationSchema = z.object({
+  component: z.string().min(1),
+  relationship: relationshipTypeSchema,
+  note: z.string().min(1)
+});
+var fragmentVariantSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  render: z.function().returns(z.unknown()),
+  code: z.string().optional(),
+  figma: z.string().url().optional()
+});
+var fragmentBanSchema = z.object({
+  pattern: z.string().min(1),
+  message: z.string().min(1)
+});
+var fragmentContractSchema = z.object({
+  propsSummary: z.array(z.string()).optional(),
+  a11yRules: z.array(z.string()).optional(),
+  bans: z.array(fragmentBanSchema).optional(),
+  scenarioTags: z.array(z.string()).optional(),
+  performanceBudget: z.number().positive().optional()
+});
+var fragmentGeneratedSchema = z.object({
+  source: z.enum(["storybook", "manual", "ai"]),
+  sourceFile: z.string().optional(),
+  confidence: z.number().min(0).max(1).optional(),
+  timestamp: z.string().datetime().optional()
+});
+var aiMetadataSchema = z.object({
+  compositionPattern: z.enum(["compound", "simple", "controlled", "wrapper"]).optional(),
+  subComponents: z.array(z.string()).optional(),
+  requiredChildren: z.array(z.string()).optional(),
+  commonPatterns: z.array(z.string()).optional()
+});
+var blockDefinitionSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  category: z.string().min(1),
+  components: z.array(z.string().min(1)).min(1),
+  code: z.string().min(1),
+  tags: z.array(z.string()).optional()
+});
+var fragmentDefinitionSchema = z.object({
+  component: z.any(),
+  // Allow any component type (function, class, forwardRef, etc.)
+  meta: fragmentMetaSchema,
+  usage: fragmentUsageSchema,
+  props: z.record(propDefinitionSchema),
+  relations: z.array(componentRelationSchema).optional(),
+  variants: z.array(fragmentVariantSchema),
+  // Allow empty variants array
+  contract: fragmentContractSchema.optional(),
+  ai: aiMetadataSchema.optional(),
+  _generated: fragmentGeneratedSchema.optional()
+});
+var fragmentsConfigSchema = z.object({
+  include: z.array(z.string()).min(1),
+  exclude: z.array(z.string()).optional(),
+  components: z.array(z.string()).optional(),
+  outFile: z.string().optional(),
+  framework: z.enum(["react", "vue", "svelte"]).optional(),
+  figmaFile: z.string().url().optional(),
+  figmaToken: z.string().optional(),
+  screenshots: z.object({}).passthrough().optional(),
+  service: z.object({}).passthrough().optional(),
+  registry: z.object({}).passthrough().optional(),
+  tokens: z.object({
+    include: z.array(z.string()).min(1)
+  }).passthrough().optional(),
+  snippets: z.object({
+    mode: z.enum(["warn", "error"]).optional(),
+    scope: z.enum(["snippet", "snippet+render"]).optional(),
+    requireFullSnippet: z.boolean().optional(),
+    allowedExternalModules: z.array(z.string().min(1)).optional()
+  }).optional(),
+  performance: z.union([
+    z.enum(["strict", "standard", "relaxed"]),
+    z.object({
+      preset: z.enum(["strict", "standard", "relaxed"]).optional(),
+      budgets: z.object({
+        bundleSize: z.number().positive().optional()
+      }).optional()
+    })
+  ]).optional(),
+  storybook: z.object({
+    exclude: z.array(z.string()).optional(),
+    include: z.array(z.string()).optional(),
+    excludeDeprecated: z.boolean().optional(),
+    excludeTests: z.boolean().optional(),
+    excludeSvgIcons: z.boolean().optional(),
+    excludeSubComponents: z.boolean().optional()
+  }).optional()
+});
+var recipeDefinitionSchema = blockDefinitionSchema;
 function defineFragment(definition) {
   if (process.env.NODE_ENV !== "production") {
     const result = fragmentDefinitionSchema.safeParse(definition);
@@ -114,21 +371,9 @@ function compileBlock(definition, filePath) {
   };
 }
 var compileRecipe = compileBlock;
-
-// src/core/storyAdapter.ts
-import { createElement } from "react";
-
-// src/core/storybook-csf.ts
-import {
-  toId as storybookToId,
-  storyNameFromExport as storybookStoryNameFromExport,
-  isExportStory as storybookIsExportStory
-} from "@storybook/csf";
 var toId = (...args) => storybookToId(...args);
 var storyNameFromExport = (...args) => storybookStoryNameFromExport(...args);
 var isExportStory = (...args) => storybookIsExportStory(...args);
-
-// src/core/storyAdapter.ts
 var globalPreviewConfig = {};
 function setPreviewConfig(config) {
   globalPreviewConfig = config;
@@ -467,11 +712,126 @@ function applyDecorators(renderFn, decorators, context) {
   }
   return storyFn();
 }
-
-// src/core/context.ts
-import { generateContext, filterPlaceholders, PLACEHOLDER_PATTERNS } from "@fragments-sdk/context/generate";
-
-// src/core/figma.ts
+var EXCLUDED_TAGS = /* @__PURE__ */ new Set(["hidden", "internal", "no-fragment"]);
+var SVG_ICON_RE = /^Svg[A-Z]/;
+var TEST_TITLE_RE = /\/tests?$/i;
+var TEST_FILE_RE = /\.test\.stories\./;
+var DEPRECATED_TITLE_RE = /\bDeprecated\b/i;
+function checkStoryExclusion(opts) {
+  const { config } = opts;
+  if (isForceIncluded(opts.componentName, config)) {
+    return { excluded: false };
+  }
+  if (isConfigExcluded(opts.componentName, config)) {
+    return {
+      excluded: true,
+      reason: "config-excluded",
+      detail: `'${opts.componentName}' matches storybook.exclude pattern`
+    };
+  }
+  if (config.excludeDeprecated !== false && opts.storybookTitle && DEPRECATED_TITLE_RE.test(opts.storybookTitle)) {
+    return {
+      excluded: true,
+      reason: "deprecated",
+      detail: `Title "${opts.storybookTitle}" contains "Deprecated"`
+    };
+  }
+  if (config.excludeTests !== false) {
+    if (opts.storybookTitle && TEST_TITLE_RE.test(opts.storybookTitle)) {
+      return {
+        excluded: true,
+        reason: "test-story",
+        detail: `Title "${opts.storybookTitle}" ends with /test(s)`
+      };
+    }
+    if (TEST_FILE_RE.test(opts.filePath)) {
+      return {
+        excluded: true,
+        reason: "test-story",
+        detail: `File path matches *.test.stories.*`
+      };
+    }
+  }
+  if (config.excludeSvgIcons !== false) {
+    const names = [opts.componentName, opts.componentDisplayName, opts.componentFunctionName].filter(Boolean);
+    for (const name of names) {
+      if (SVG_ICON_RE.test(name)) {
+        return {
+          excluded: true,
+          reason: "svg-icon",
+          detail: `Component name "${name}" matches Svg[A-Z] pattern`
+        };
+      }
+    }
+  }
+  if (opts.tags?.length) {
+    const hit = opts.tags.find((t) => EXCLUDED_TAGS.has(t));
+    if (hit) {
+      return {
+        excluded: true,
+        reason: "tag-excluded",
+        detail: `Tag "${hit}" is in the exclusion set`
+      };
+    }
+  }
+  if (opts.variantCount === 0) {
+    return {
+      excluded: true,
+      reason: "empty-variants",
+      detail: "Zero renderable story exports"
+    };
+  }
+  return { excluded: false };
+}
+function detectSubComponentPaths(storyFiles) {
+  const byDir = /* @__PURE__ */ new Map();
+  for (const file of storyFiles) {
+    const parts = file.relativePath.split("/");
+    if (parts.length < 2) continue;
+    const fileName = parts[parts.length - 1];
+    const baseMatch = fileName.match(/^([^.]+)\.stories\./);
+    if (!baseMatch) continue;
+    const dir = parts.slice(0, -1).join("/");
+    const baseName = baseMatch[1];
+    if (!byDir.has(dir)) byDir.set(dir, []);
+    byDir.get(dir).push({ relativePath: file.relativePath, baseName });
+  }
+  const subComponentMap = /* @__PURE__ */ new Map();
+  for (const [dir, files] of byDir) {
+    if (files.length <= 1) continue;
+    const dirName = dir.split("/").pop();
+    const primary = files.find((f) => f.baseName === dirName);
+    if (!primary) continue;
+    for (const file of files) {
+      if (file.relativePath === primary.relativePath) continue;
+      subComponentMap.set(file.relativePath, primary.baseName);
+    }
+  }
+  return subComponentMap;
+}
+function isForceIncluded(name, config) {
+  if (!config.include?.length) return false;
+  return config.include.some((pattern) => matchesPattern(name, pattern));
+}
+function isConfigExcluded(name, config) {
+  if (!config.exclude?.length) return false;
+  return config.exclude.some((pattern) => matchesPattern(name, pattern));
+}
+function matchesPattern(name, pattern) {
+  if (!pattern.includes("*")) {
+    return name === pattern;
+  }
+  const parts = pattern.split("*");
+  if (parts.length === 2) {
+    const [prefix, suffix] = parts;
+    if (prefix && suffix) return name.startsWith(prefix) && name.endsWith(suffix);
+    if (prefix) return name.startsWith(prefix);
+    if (suffix) return name.endsWith(suffix);
+    return true;
+  }
+  const escaped = parts.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${escaped}$`).test(name);
+}
 function string(figmaProperty) {
   return {
     __type: "figma-string",
@@ -550,8 +910,6 @@ function resolveFigmaMapping(mapping, figmaValues) {
       return void 0;
   }
 }
-
-// src/core/token-parser.ts
 var NAMING_RULES = [
   { pattern: /--\w+-font-/, category: "typography" },
   { pattern: /--\w+-line-height-/, category: "typography" },
@@ -729,9 +1087,6 @@ function parseTokenFile(content, filePath) {
     total: tokens.length
   };
 }
-
-// src/core/composition.ts
-import { ComponentGraphEngine } from "@fragments-sdk/context/graph";
 var CATEGORY_AFFINITIES = {
   forms: ["feedback"],
   actions: ["feedback"]
@@ -921,10 +1276,6 @@ function findBestCategoryCandidate(fragments, category, selectedSet, suggestedSe
   }
   return best;
 }
-
-// src/core/preview-runtime.tsx
-import { useEffect, useState } from "react";
-import { Fragment, jsx } from "react/jsx-runtime";
 var EMPTY_STATE = {
   content: null,
   isLoading: false,
@@ -1008,11 +1359,27 @@ function PreviewVariantRuntime({
 }
 
 export {
+  BRAND,
+  DEFAULTS,
   PRESET_NAMES,
   resolvePerformanceConfig,
   classifyComplexity,
   formatBytes,
   budgetBar,
+  figmaPropMappingSchema,
+  fragmentMetaSchema,
+  fragmentUsageSchema,
+  propDefinitionSchema,
+  componentRelationSchema,
+  fragmentVariantSchema,
+  fragmentBanSchema,
+  fragmentContractSchema,
+  fragmentGeneratedSchema,
+  aiMetadataSchema,
+  blockDefinitionSchema,
+  fragmentDefinitionSchema,
+  fragmentsConfigSchema,
+  recipeDefinitionSchema,
   defineFragment,
   compileFragment,
   defineBlock,
@@ -1025,6 +1392,10 @@ export {
   setPreviewConfig,
   getPreviewConfig,
   storyModuleToFragment,
+  checkStoryExclusion,
+  detectSubComponentPaths,
+  isForceIncluded,
+  isConfigExcluded,
   generateContext,
   figma,
   isFigmaPropMapping,
@@ -1036,4 +1407,4 @@ export {
   usePreviewVariantRuntime,
   PreviewVariantRuntime
 };
-//# sourceMappingURL=chunk-GF6OVPIN.js.map
+//# sourceMappingURL=chunk-OQO55NKV.js.map