@fragments-sdk/cli 0.15.10 → 0.16.0

package/dist/{chunk-HQ6A6DTV.js → chunk-XRADMHMV.js}

@@ -2,7 +2,7 @@ import { createRequire as __banner_createRequire } from 'module'; const require
 import {
   BRAND,
   fragmentsConfigSchema
-} from "./chunk-32LIWN2P.js";
+} from "./chunk-SJFSG7QF.js";
 
 // src/core/config.ts
 import { existsSync } from "fs";
@@ -132,7 +132,6 @@ async function discoverBlockFiles(configDir, exclude) {
     absolutePath: resolve2(configDir, relativePath)
   }));
 }
-var discoverRecipeFiles = discoverBlockFiles;
 async function discoverFragmentFiles(config, configDir) {
   const defaultExcludes = [
     "**/*.test.stories.*",
@@ -323,55 +322,6 @@ async function discoverComponentsFromBarrel(barrelPath, configDir) {
   }
   return components;
 }
-var DEFAULT_TOKEN_PATTERNS = [
-  "src/**/tokens/**/_variables.scss",
-  "src/**/tokens/**/variables.scss",
-  "src/**/styles/**/variables.scss",
-  "src/**/styles/**/tokens.scss",
-  "src/**/styles/**/variables.css",
-  "src/**/theme/**/_variables.scss",
-  "src/**/theme/**/tokens.css",
-  // DTCG token files
-  "**/*.tokens.json",
-  "**/*.tokens"
-];
-async function discoverTokenFiles(configDir, patterns, exclude) {
-  const searchPatterns = patterns && patterns.length > 0 ? patterns : DEFAULT_TOKEN_PATTERNS;
-  const files = await fg(searchPatterns, {
-    cwd: configDir,
-    ignore: exclude ?? ["**/node_modules/**", "**/dist/**"],
-    absolute: false
-  });
-  return files.map((relativePath) => ({
-    relativePath,
-    absolutePath: resolve2(configDir, relativePath)
-  }));
-}
-async function discoverInstalledFragments(projectRoot) {
-  const pkgJsonPath = resolve2(projectRoot, "package.json");
-  if (!existsSync2(pkgJsonPath)) return [];
-  const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
-  const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
-  const results = [];
-  for (const depName of Object.keys(allDeps)) {
-    const depDir = resolve2(projectRoot, "node_modules", depName);
-    const depPkgPath = resolve2(depDir, "package.json");
-    if (!existsSync2(depPkgPath)) continue;
-    const depPkg = JSON.parse(await readFile(depPkgPath, "utf-8"));
-    if (!depPkg.fragments) continue;
-    const files = await fg(
-      [`src/**/*${BRAND.fileExtension}`, "src/**/*.stories.tsx"],
-      { cwd: depDir, ignore: ["**/node_modules/**"], absolute: false }
-    );
-    for (const rel of files) {
-      results.push({
-        relativePath: `${depName}/${rel}`,
-        absolutePath: resolve2(depDir, rel)
-      });
-    }
-  }
-  return results;
-}
 async function discoverAllComponents(configDir, options = {}) {
   const componentsMap = /* @__PURE__ */ new Map();
   const sourceComponents = await discoverComponentsFromSource(
@@ -395,9 +345,270 @@ async function discoverAllComponents(configDir, options = {}) {
   return Array.from(componentsMap.values()).sort((a, b) => a.name.localeCompare(b.name));
 }
 
+// src/core/generators/typescript-extractor.ts
+import ts from "typescript";
+import { readFileSync } from "fs";
+function extractPropsFromFile(filePath) {
+  const sourceText = readFileSync(filePath, "utf-8");
+  return extractPropsFromSource(sourceText, filePath);
+}
+function extractPropsFromSource(sourceText, fileName = "component.tsx") {
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    sourceText,
+    ts.ScriptTarget.Latest,
+    true,
+    fileName.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const result = {
+    componentName: "",
+    props: {},
+    exports: [],
+    imports: []
+  };
+  const propsInterfaces = /* @__PURE__ */ new Map();
+  const componentExports = [];
+  const defaultExports = /* @__PURE__ */ new Set();
+  const importedModules = [];
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isImportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier;
+      if (ts.isStringLiteral(moduleSpecifier)) {
+        importedModules.push(moduleSpecifier.text);
+      }
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+      const name = node.name.text;
+      if (name.endsWith("Props")) {
+        propsInterfaces.set(name, node);
+      }
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      const name = node.name.text;
+      if (name.endsWith("Props")) {
+        propsInterfaces.set(name, node);
+      }
+    }
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      const hasExport = node.modifiers?.some(
+        (m) => m.kind === ts.SyntaxKind.ExportKeyword
+      );
+      const hasDefault = node.modifiers?.some(
+        (m) => m.kind === ts.SyntaxKind.DefaultKeyword
+      );
+      if (hasExport) {
+        componentExports.push(node.name.text);
+        if (hasDefault) {
+          defaultExports.add(node.name.text);
+        }
+      }
+    }
+    if (ts.isVariableStatement(node)) {
+      const hasExport = node.modifiers?.some(
+        (m) => m.kind === ts.SyntaxKind.ExportKeyword
+      );
+      if (hasExport) {
+        for (const decl of node.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name)) {
+            componentExports.push(decl.name.text);
+          }
+        }
+      }
+    }
+    if (ts.isExportDeclaration(node) && node.exportClause) {
+      if (ts.isNamedExports(node.exportClause)) {
+        for (const element of node.exportClause.elements) {
+          componentExports.push(element.name.text);
+        }
+      }
+    }
+  });
+  result.exports = componentExports;
+  result.imports = importedModules;
+  const mainComponent = componentExports.find(
+    (name) => /^[A-Z]/.test(name) && !name.endsWith("Props")
+  );
+  if (!mainComponent) {
+    return null;
+  }
+  result.componentName = mainComponent;
+  result.isDefaultExport = defaultExports.has(mainComponent);
+  const propsInterfaceName = `${mainComponent}Props`;
+  const propsInterface = propsInterfaces.get(propsInterfaceName);
+  if (propsInterface) {
+    result.propsInterfaceName = propsInterfaceName;
+    result.props = extractPropsFromInterface(propsInterface, sourceFile);
+  }
+  return result;
+}
+function extractPropsFromInterface(node, sourceFile) {
+  const props = {};
+  if (ts.isInterfaceDeclaration(node)) {
+    for (const member of node.members) {
+      if (ts.isPropertySignature(member) && member.name) {
+        const propName = member.name.getText(sourceFile);
+        const prop = extractPropFromMember(member, sourceFile);
+        if (prop) {
+          props[propName] = prop;
+        }
+      }
+    }
+  }
+  if (ts.isTypeAliasDeclaration(node)) {
+    const typeNode = node.type;
+    if (ts.isTypeLiteralNode(typeNode)) {
+      for (const member of typeNode.members) {
+        if (ts.isPropertySignature(member) && member.name) {
+          const propName = member.name.getText(sourceFile);
+          const prop = extractPropFromMember(member, sourceFile);
+          if (prop) {
+            props[propName] = prop;
+          }
+        }
+      }
+    }
+  }
+  return props;
+}
+function extractPropFromMember(member, sourceFile) {
+  const entry = {};
+  entry.required = !member.questionToken;
+  if (member.type) {
+    const typeInfo = parseTypeNode(member.type, sourceFile);
+    entry.type = typeInfo.type;
+    entry.typeKind = typeInfo.typeKind;
+    if (typeInfo.options) {
+      entry.options = typeInfo.options;
+    }
+  }
+  const jsDocComment = getJSDocComment(member);
+  if (jsDocComment) {
+    entry.description = jsDocComment;
+  }
+  const defaultValue = getJSDocDefault(member);
+  if (defaultValue !== void 0) {
+    entry.default = defaultValue;
+  }
+  return entry;
+}
+function parseTypeNode(typeNode, sourceFile) {
+  if (typeNode.kind === ts.SyntaxKind.StringKeyword) {
+    return { type: "string", typeKind: "string" };
+  }
+  if (typeNode.kind === ts.SyntaxKind.NumberKeyword) {
+    return { type: "number", typeKind: "number" };
+  }
+  if (typeNode.kind === ts.SyntaxKind.BooleanKeyword) {
+    return { type: "boolean", typeKind: "boolean" };
+  }
+  if (ts.isUnionTypeNode(typeNode)) {
+    const options = [];
+    let allLiterals = true;
+    for (const subType of typeNode.types) {
+      if (ts.isLiteralTypeNode(subType)) {
+        if (ts.isStringLiteral(subType.literal)) {
+          options.push(subType.literal.text);
+        } else if (subType.literal.kind === ts.SyntaxKind.TrueKeyword) {
+          options.push("true");
+        } else if (subType.literal.kind === ts.SyntaxKind.FalseKeyword) {
+          options.push("false");
+        } else {
+          allLiterals = false;
+        }
+      } else {
+        allLiterals = false;
+      }
+    }
+    if (allLiterals && options.length > 0) {
+      return {
+        type: options.map((o) => `"${o}"`).join(" | "),
+        typeKind: "enum",
+        options
+      };
+    }
+    return {
+      type: typeNode.getText(sourceFile),
+      typeKind: "union"
+    };
+  }
+  if (ts.isFunctionTypeNode(typeNode)) {
+    return {
+      type: typeNode.getText(sourceFile),
+      typeKind: "function"
+    };
+  }
+  if (ts.isArrayTypeNode(typeNode)) {
+    return {
+      type: typeNode.getText(sourceFile),
+      typeKind: "array"
+    };
+  }
+  if (ts.isTypeReferenceNode(typeNode)) {
+    const typeName = typeNode.typeName.getText(sourceFile);
+    if (typeName === "ReactNode" || typeName === "React.ReactNode") {
+      return { type: "ReactNode", typeKind: "node" };
+    }
+    if (typeName === "ReactElement" || typeName === "React.ReactElement") {
+      return { type: "ReactElement", typeKind: "element" };
+    }
+    if (typeName === "JSX.Element") {
+      return { type: "JSX.Element", typeKind: "element" };
+    }
+    return {
+      type: typeNode.getText(sourceFile),
+      typeKind: "object"
+    };
+  }
+  if (ts.isTypeLiteralNode(typeNode)) {
+    return {
+      type: typeNode.getText(sourceFile),
+      typeKind: "object"
+    };
+  }
+  return {
+    type: typeNode.getText(sourceFile),
+    typeKind: "unknown"
+  };
+}
+function getJSDocComment(node) {
+  const jsDocTags = ts.getJSDocTags(node);
+  const jsDoc = node.jsDoc;
+  if (jsDoc && jsDoc.length > 0) {
+    const comment = jsDoc[0].comment;
+    if (typeof comment === "string") {
+      return comment;
+    }
+    if (Array.isArray(comment)) {
+      return comment.map((c) => typeof c === "string" ? c : c.text).join("");
+    }
+  }
+  return void 0;
+}
+function getJSDocDefault(node) {
+  const jsDocTags = ts.getJSDocTags(node);
+  for (const tag of jsDocTags) {
+    if (tag.tagName.text === "default") {
+      const comment = tag.comment;
+      if (typeof comment === "string") {
+        try {
+          return JSON.parse(comment);
+        } catch {
+          return comment;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/core/generators/registry.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { relative, dirname as dirname3, basename as basename2, join } from "path";
+import fg2 from "fast-glob";
+
 // src/core/loader.ts
 import { unlink } from "fs/promises";
-import { dirname as dirname3, basename as basename2, join } from "path";
+import { dirname as dirname4, basename as basename3, join as join2 } from "path";
 import { pathToFileURL } from "url";
 import { build } from "esbuild";
 var DEFINE_FRAGMENT_SHIM = `
@@ -458,9 +669,9 @@ async function loadFragmentFile(absolutePath) {
     const module = await import(fileUrl);
     return unwrapFragmentExport(module.default ?? null);
   }
-  const sourceDir = dirname3(absolutePath);
-  const baseName = basename2(absolutePath, `.${ext}`);
-  const tempFile = join(sourceDir, `.${baseName}.fragments-temp-${Date.now()}.mjs`);
+  const sourceDir = dirname4(absolutePath);
+  const baseName = basename3(absolutePath, `.${ext}`);
+  const tempFile = join2(sourceDir, `.${baseName}.fragments-temp-${Date.now()}.mjs`);
   try {
     await build({
       entryPoints: [absolutePath],
@@ -510,38 +721,17 @@ async function loadFragmentFile(absolutePath) {
     }
   }
 }
-async function loadFragmentFiles(absolutePaths) {
-  const results = /* @__PURE__ */ new Map();
-  await Promise.all(
-    absolutePaths.map(async (path) => {
-      try {
-        const fragment = await loadFragmentFile(path);
-        if (fragment) {
-          results.set(path, fragment);
-        } else {
-          results.set(path, new Error("No default export found"));
-        }
-      } catch (error) {
-        results.set(
-          path,
-          error instanceof Error ? error : new Error(String(error))
-        );
-      }
-    })
-  );
-  return results;
-}
 
 // src/core/parser.ts
-import ts from "typescript";
+import ts2 from "typescript";
 function parseFragmentFile(fileContent, filePath) {
   const warnings = [];
-  const sourceFile = ts.createSourceFile(
+  const sourceFile = ts2.createSourceFile(
     filePath ?? "fragment.tsx",
     fileContent,
-    ts.ScriptTarget.Latest,
+    ts2.ScriptTarget.Latest,
     true,
-    ts.ScriptKind.TSX
+    ts2.ScriptKind.TSX
   );
   const imports = extractImports(sourceFile);
   const defineFragmentCall = findDefineFragmentCall(sourceFile);
@@ -559,7 +749,7 @@ function parseFragmentFile(fileContent, filePath) {
     };
   }
   const arg = defineFragmentCall.arguments[0];
-  if (!arg || !ts.isObjectLiteralExpression(arg)) {
+  if (!arg || !ts2.isObjectLiteralExpression(arg)) {
     warnings.push("defineFragment() argument is not an object literal");
     return {
       componentImport: null,
@@ -575,7 +765,7 @@ function parseFragmentFile(fileContent, filePath) {
   const componentProp = findProperty(arg, "component");
   let componentName = null;
   let componentImport = null;
-  if (componentProp && ts.isIdentifier(componentProp)) {
+  if (componentProp && ts2.isIdentifier(componentProp)) {
     componentName = componentProp.text;
     componentImport = imports.get(componentName) ?? null;
   }
@@ -601,10 +791,10 @@ function parseFragmentFile(fileContent, filePath) {
 }
 function extractImports(sourceFile) {
   const imports = /* @__PURE__ */ new Map();
-  ts.forEachChild(sourceFile, (node) => {
-    if (ts.isImportDeclaration(node)) {
+  ts2.forEachChild(sourceFile, (node) => {
+    if (ts2.isImportDeclaration(node)) {
       const moduleSpecifier = node.moduleSpecifier;
-      if (ts.isStringLiteral(moduleSpecifier)) {
+      if (ts2.isStringLiteral(moduleSpecifier)) {
         const modulePath = moduleSpecifier.text;
         const importClause = node.importClause;
         if (importClause) {
@@ -612,7 +802,7 @@ function extractImports(sourceFile) {
             imports.set(importClause.name.text, modulePath);
           }
           const namedBindings = importClause.namedBindings;
-          if (namedBindings && ts.isNamedImports(namedBindings)) {
+          if (namedBindings && ts2.isNamedImports(namedBindings)) {
             for (const element of namedBindings.elements) {
               imports.set(element.name.text, modulePath);
             }
@@ -626,23 +816,23 @@ function extractImports(sourceFile) {
 function findDefineFragmentCall(sourceFile) {
   let result = null;
   function visit(node) {
-    if (ts.isCallExpression(node)) {
+    if (ts2.isCallExpression(node)) {
       const expression = node.expression;
-      if (ts.isIdentifier(expression) && expression.text === "defineFragment") {
+      if (ts2.isIdentifier(expression) && expression.text === "defineFragment") {
         result = node;
         return;
       }
     }
-    ts.forEachChild(node, visit);
+    ts2.forEachChild(node, visit);
   }
   visit(sourceFile);
   return result;
 }
 function findProperty(obj, name) {
   for (const prop of obj.properties) {
-    if (ts.isPropertyAssignment(prop)) {
+    if (ts2.isPropertyAssignment(prop)) {
       const propName = prop.name;
-      if (ts.isIdentifier(propName) && propName.text === name) {
+      if (ts2.isIdentifier(propName) && propName.text === name) {
         return prop.initializer;
       }
     }
@@ -651,7 +841,7 @@ function findProperty(obj, name) {
 }
 function extractMeta(arg, warnings) {
   const metaProp = findProperty(arg, "meta");
-  if (!metaProp || !ts.isObjectLiteralExpression(metaProp)) {
+  if (!metaProp || !ts2.isObjectLiteralExpression(metaProp)) {
     warnings.push("No meta object found");
     return {};
   }
@@ -671,7 +861,7 @@ function extractMeta(arg, warnings) {
   const tags = extractStringArray(metaProp, "tags");
   if (tags.length > 0) meta.tags = tags;
   const depsProp = findProperty(metaProp, "dependencies");
-  if (depsProp && ts.isArrayLiteralExpression(depsProp)) {
+  if (depsProp && ts2.isArrayLiteralExpression(depsProp)) {
     const deps = extractLiteralValue(depsProp);
     if (Array.isArray(deps) && deps.length > 0) {
       meta.dependencies = deps;
@@ -681,7 +871,7 @@ function extractMeta(arg, warnings) {
 }
 function extractUsage(arg, warnings) {
   const usageProp = findProperty(arg, "usage");
-  if (!usageProp || !ts.isObjectLiteralExpression(usageProp)) {
+  if (!usageProp || !ts2.isObjectLiteralExpression(usageProp)) {
     return { when: [], whenNot: [] };
   }
   return {
@@ -693,15 +883,15 @@ function extractUsage(arg, warnings) {
 }
 function extractProps(arg, warnings) {
   const propsProp = findProperty(arg, "props");
-  if (!propsProp || !ts.isObjectLiteralExpression(propsProp)) {
+  if (!propsProp || !ts2.isObjectLiteralExpression(propsProp)) {
     return {};
   }
   const props = {};
   for (const prop of propsProp.properties) {
-    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+    if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name)) {
       const propName = prop.name.text;
       const propValue = prop.initializer;
-      if (ts.isObjectLiteralExpression(propValue)) {
+      if (ts2.isObjectLiteralExpression(propValue)) {
         props[propName] = extractPropDefinition(propValue);
       }
     }
@@ -728,12 +918,12 @@ function extractPropDefinition(obj) {
 }
 function extractVariants(arg, sourceFile, warnings) {
   const variantsProp = findProperty(arg, "variants");
-  if (!variantsProp || !ts.isArrayLiteralExpression(variantsProp)) {
+  if (!variantsProp || !ts2.isArrayLiteralExpression(variantsProp)) {
     return [];
   }
   const variants = [];
   for (const element of variantsProp.elements) {
-    if (ts.isObjectLiteralExpression(element)) {
+    if (ts2.isObjectLiteralExpression(element)) {
       const name = extractStringProperty(element, "name");
       const description = extractStringProperty(element, "description");
       if (name) {
@@ -742,7 +932,7 @@ function extractVariants(arg, sourceFile, warnings) {
           description: description ?? ""
         };
         const codeProp = findProperty(element, "code");
-        if (codeProp && (ts.isStringLiteral(codeProp) || ts.isNoSubstitutionTemplateLiteral(codeProp))) {
+        if (codeProp && (ts2.isStringLiteral(codeProp) || ts2.isNoSubstitutionTemplateLiteral(codeProp))) {
           variant.code = codeProp.text;
         }
         const renderProp = findProperty(element, "render");
@@ -754,7 +944,7 @@ function extractVariants(arg, sourceFile, warnings) {
           variant.figma = figma;
         }
         const argsProp = findProperty(element, "args");
-        if (argsProp && ts.isObjectLiteralExpression(argsProp)) {
+        if (argsProp && ts2.isObjectLiteralExpression(argsProp)) {
           const argsValue = extractLiteralValue(argsProp);
           if (argsValue && typeof argsValue === "object" && !Array.isArray(argsValue)) {
             variant.args = argsValue;
@@ -793,7 +983,7 @@ function dedent(str) {
   }).join("\n");
 }
 function extractRenderCode(renderProp, sourceFile) {
-  if (ts.isArrowFunction(renderProp)) {
+  if (ts2.isArrowFunction(renderProp)) {
     const body = renderProp.body;
     const start = body.getStart(sourceFile);
     const end = body.getEnd();
@@ -808,12 +998,12 @@ function extractRenderCode(renderProp, sourceFile) {
 }
 function extractRelations(arg, warnings) {
   const relationsProp = findProperty(arg, "relations");
-  if (!relationsProp || !ts.isArrayLiteralExpression(relationsProp)) {
+  if (!relationsProp || !ts2.isArrayLiteralExpression(relationsProp)) {
     return [];
   }
   const relations = [];
   for (const element of relationsProp.elements) {
-    if (ts.isObjectLiteralExpression(element)) {
+    if (ts2.isObjectLiteralExpression(element)) {
       const component = extractStringProperty(element, "component");
       const relationship = extractStringProperty(element, "relationship");
       const note = extractStringProperty(element, "note");
@@ -830,7 +1020,7 @@ function extractRelations(arg, warnings) {
 }
 function extractAIMetadata(arg, warnings) {
   const aiProp = findProperty(arg, "ai");
-  if (!aiProp || !ts.isObjectLiteralExpression(aiProp)) {
+  if (!aiProp || !ts2.isObjectLiteralExpression(aiProp)) {
     return void 0;
   }
   const ai = {};
@@ -857,7 +1047,7 @@ function extractAIMetadata(arg, warnings) {
 }
 function extractContractMetadata(arg) {
   const contractProp = findProperty(arg, "contract");
-  if (!contractProp || !ts.isObjectLiteralExpression(contractProp)) {
+  if (!contractProp || !ts2.isObjectLiteralExpression(contractProp)) {
     return void 0;
   }
   const contract = {};
@@ -876,10 +1066,10 @@ function extractContractMetadata(arg) {
 }
 function extractStringProperty(obj, name) {
   const prop = findProperty(obj, name);
-  if (prop && ts.isStringLiteral(prop)) {
+  if (prop && ts2.isStringLiteral(prop)) {
     return prop.text;
   }
-  if (prop && ts.isNoSubstitutionTemplateLiteral(prop)) {
+  if (prop && ts2.isNoSubstitutionTemplateLiteral(prop)) {
     return prop.text;
   }
   return null;
@@ -887,49 +1077,49 @@ function extractStringProperty(obj, name) {
 function extractBooleanProperty(obj, name) {
   const prop = findProperty(obj, name);
   if (prop) {
-    if (prop.kind === ts.SyntaxKind.TrueKeyword) return true;
-    if (prop.kind === ts.SyntaxKind.FalseKeyword) return false;
+    if (prop.kind === ts2.SyntaxKind.TrueKeyword) return true;
+    if (prop.kind === ts2.SyntaxKind.FalseKeyword) return false;
   }
   return null;
 }
 function extractStringArray(obj, name) {
   const prop = findProperty(obj, name);
-  if (!prop || !ts.isArrayLiteralExpression(prop)) {
+  if (!prop || !ts2.isArrayLiteralExpression(prop)) {
     return [];
   }
   const result = [];
   for (const element of prop.elements) {
-    if (ts.isStringLiteral(element)) {
+    if (ts2.isStringLiteral(element)) {
       result.push(element.text);
-    } else if (ts.isNoSubstitutionTemplateLiteral(element)) {
+    } else if (ts2.isNoSubstitutionTemplateLiteral(element)) {
       result.push(element.text);
     }
   }
   return result;
 }
 function extractLiteralValue(expr) {
-  if (ts.isStringLiteral(expr)) {
+  if (ts2.isStringLiteral(expr)) {
     return expr.text;
   }
-  if (ts.isNumericLiteral(expr)) {
+  if (ts2.isNumericLiteral(expr)) {
     return Number(expr.text);
   }
-  if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+  if (expr.kind === ts2.SyntaxKind.TrueKeyword) {
     return true;
   }
-  if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+  if (expr.kind === ts2.SyntaxKind.FalseKeyword) {
     return false;
   }
-  if (expr.kind === ts.SyntaxKind.NullKeyword) {
+  if (expr.kind === ts2.SyntaxKind.NullKeyword) {
     return null;
   }
-  if (ts.isArrayLiteralExpression(expr)) {
+  if (ts2.isArrayLiteralExpression(expr)) {
     return expr.elements.map(extractLiteralValue);
   }
-  if (ts.isObjectLiteralExpression(expr)) {
+  if (ts2.isObjectLiteralExpression(expr)) {
     const obj = {};
     for (const prop of expr.properties) {
-      if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+      if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name)) {
         obj[prop.name.text] = extractLiteralValue(prop.initializer);
       }
     }
@@ -939,988 +1129,24 @@ function extractLiteralValue(expr) {
 }
 
 // src/core/previewLoader.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join2, resolve as resolve3 } from "path";
-var PREVIEW_FILES = [
-  "preview.tsx",
-  "preview.ts",
-  "preview.jsx",
-  "preview.js"
-];
-function findPreviewConfigPath(storybookDir) {
-  for (const fileName of PREVIEW_FILES) {
-    const filePath = join2(storybookDir, fileName);
-    if (existsSync3(filePath)) {
-      return filePath;
-    }
-  }
-  return null;
-}
-function findStorybookDir(projectRoot) {
-  const possiblePaths = [
-    join2(projectRoot, ".storybook"),
-    join2(projectRoot, "storybook")
-  ];
-  for (const dir of possiblePaths) {
-    if (existsSync3(dir)) {
-      return dir;
-    }
-  }
-  return null;
-}
-async function loadPreviewConfig(previewPath) {
-  try {
-    const fileUrl = new URL(`file://${resolve3(previewPath)}`);
-    const module = await import(fileUrl.href);
-    const config = {
-      decorators: module.decorators ?? module.default?.decorators ?? [],
-      parameters: module.parameters ?? module.default?.parameters ?? {},
-      globalTypes: module.globalTypes ?? module.default?.globalTypes ?? {},
-      args: module.args ?? module.default?.args ?? {},
-      argTypes: module.argTypes ?? module.default?.argTypes ?? {},
-      loaders: module.loaders ?? module.default?.loaders ?? []
-    };
-    return config;
-  } catch (error) {
-    console.warn(
-      `[Fragments] Failed to load preview config from ${previewPath}:`,
-      error instanceof Error ? error.message : error
-    );
-    return {};
-  }
-}
-async function autoLoadPreviewConfig(projectRoot) {
-  const storybookDir = findStorybookDir(projectRoot);
-  if (!storybookDir) {
-    return {};
-  }
-  const previewPath = findPreviewConfigPath(storybookDir);
-  if (!previewPath) {
-    return {};
-  }
-  return loadPreviewConfig(previewPath);
-}
-function generatePreviewModule(previewPath) {
-  if (!previewPath) {
-    return `
-export const decorators = [];
-export const parameters = {};
-export const globalTypes = {};
-export const args = {};
-export const argTypes = {};
-export const loaders = [];
-
-export default {
-  decorators,
-  parameters,
-  globalTypes,
-  args,
-  argTypes,
-  loaders,
-};
-`;
-  }
-  return `
-import * as preview from "${previewPath}";
-
-export const decorators = preview.decorators ?? preview.default?.decorators ?? [];
-export const parameters = preview.parameters ?? preview.default?.parameters ?? {};
-export const globalTypes = preview.globalTypes ?? preview.default?.globalTypes ?? {};
-export const args = preview.args ?? preview.default?.args ?? {};
-export const argTypes = preview.argTypes ?? preview.default?.argTypes ?? {};
-export const loaders = preview.loaders ?? preview.default?.loaders ?? [];
-
-export default {
-  decorators,
-  parameters,
-  globalTypes,
-  args,
-  argTypes,
-  loaders,
-};
-`;
-}
-
-// src/core/generators/typescript-extractor.ts
-import ts2 from "typescript";
-import { readFileSync } from "fs";
-function extractPropsFromFile(filePath) {
-  const sourceText = readFileSync(filePath, "utf-8");
-  return extractPropsFromSource(sourceText, filePath);
-}
-function extractPropsFromSource(sourceText, fileName = "component.tsx") {
-  const sourceFile = ts2.createSourceFile(
-    fileName,
-    sourceText,
-    ts2.ScriptTarget.Latest,
-    true,
-    fileName.endsWith(".tsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS
-  );
-  const result = {
-    componentName: "",
-    props: {},
-    exports: [],
-    imports: []
-  };
-  const propsInterfaces = /* @__PURE__ */ new Map();
-  const componentExports = [];
-  const defaultExports = /* @__PURE__ */ new Set();
-  const importedModules = [];
-  ts2.forEachChild(sourceFile, (node) => {
-    if (ts2.isImportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier;
-      if (ts2.isStringLiteral(moduleSpecifier)) {
-        importedModules.push(moduleSpecifier.text);
-      }
-    }
-    if (ts2.isInterfaceDeclaration(node)) {
-      const name = node.name.text;
-      if (name.endsWith("Props")) {
-        propsInterfaces.set(name, node);
-      }
-    }
-    if (ts2.isTypeAliasDeclaration(node)) {
-      const name = node.name.text;
-      if (name.endsWith("Props")) {
-        propsInterfaces.set(name, node);
-      }
-    }
-    if (ts2.isFunctionDeclaration(node) && node.name) {
-      const hasExport = node.modifiers?.some(
-        (m) => m.kind === ts2.SyntaxKind.ExportKeyword
-      );
-      const hasDefault = node.modifiers?.some(
-        (m) => m.kind === ts2.SyntaxKind.DefaultKeyword
-      );
-      if (hasExport) {
-        componentExports.push(node.name.text);
-        if (hasDefault) {
-          defaultExports.add(node.name.text);
-        }
-      }
-    }
-    if (ts2.isVariableStatement(node)) {
-      const hasExport = node.modifiers?.some(
-        (m) => m.kind === ts2.SyntaxKind.ExportKeyword
-      );
-      if (hasExport) {
-        for (const decl of node.declarationList.declarations) {
-          if (ts2.isIdentifier(decl.name)) {
-            componentExports.push(decl.name.text);
-          }
-        }
-      }
-    }
-    if (ts2.isExportDeclaration(node) && node.exportClause) {
-      if (ts2.isNamedExports(node.exportClause)) {
-        for (const element of node.exportClause.elements) {
-          componentExports.push(element.name.text);
-        }
-      }
-    }
-  });
-  result.exports = componentExports;
-  result.imports = importedModules;
-  const mainComponent = componentExports.find(
-    (name) => /^[A-Z]/.test(name) && !name.endsWith("Props")
-  );
-  if (!mainComponent) {
-    return null;
-  }
-  result.componentName = mainComponent;
-  result.isDefaultExport = defaultExports.has(mainComponent);
-  const propsInterfaceName = `${mainComponent}Props`;
-  const propsInterface = propsInterfaces.get(propsInterfaceName);
-  if (propsInterface) {
-    result.propsInterfaceName = propsInterfaceName;
-    result.props = extractPropsFromInterface(propsInterface, sourceFile);
-  }
-  return result;
-}
-function extractPropsFromInterface(node, sourceFile) {
-  const props = {};
-  if (ts2.isInterfaceDeclaration(node)) {
-    for (const member of node.members) {
-      if (ts2.isPropertySignature(member) && member.name) {
-        const propName = member.name.getText(sourceFile);
-        const prop = extractPropFromMember(member, sourceFile);
-        if (prop) {
-          props[propName] = prop;
-        }
-      }
-    }
-  }
-  if (ts2.isTypeAliasDeclaration(node)) {
-    const typeNode = node.type;
-    if (ts2.isTypeLiteralNode(typeNode)) {
-      for (const member of typeNode.members) {
-        if (ts2.isPropertySignature(member) && member.name) {
-          const propName = member.name.getText(sourceFile);
-          const prop = extractPropFromMember(member, sourceFile);
-          if (prop) {
-            props[propName] = prop;
-          }
-        }
-      }
-    }
-  }
-  return props;
-}
-function extractPropFromMember(member, sourceFile) {
-  const entry = {};
-  entry.required = !member.questionToken;
-  if (member.type) {
-    const typeInfo = parseTypeNode(member.type, sourceFile);
-    entry.type = typeInfo.type;
-    entry.typeKind = typeInfo.typeKind;
-    if (typeInfo.options) {
-      entry.options = typeInfo.options;
-    }
-  }
-  const jsDocComment = getJSDocComment(member);
-  if (jsDocComment) {
-    entry.description = jsDocComment;
-  }
-  const defaultValue = getJSDocDefault(member);
-  if (defaultValue !== void 0) {
-    entry.default = defaultValue;
-  }
-  return entry;
-}
-function parseTypeNode(typeNode, sourceFile) {
-  if (typeNode.kind === ts2.SyntaxKind.StringKeyword) {
-    return { type: "string", typeKind: "string" };
-  }
-  if (typeNode.kind === ts2.SyntaxKind.NumberKeyword) {
-    return { type: "number", typeKind: "number" };
-  }
-  if (typeNode.kind === ts2.SyntaxKind.BooleanKeyword) {
-    return { type: "boolean", typeKind: "boolean" };
-  }
-  if (ts2.isUnionTypeNode(typeNode)) {
-    const options = [];
-    let allLiterals = true;
-    for (const subType of typeNode.types) {
-      if (ts2.isLiteralTypeNode(subType)) {
-        if (ts2.isStringLiteral(subType.literal)) {
-          options.push(subType.literal.text);
-        } else if (subType.literal.kind === ts2.SyntaxKind.TrueKeyword) {
-          options.push("true");
-        } else if (subType.literal.kind === ts2.SyntaxKind.FalseKeyword) {
-          options.push("false");
-        } else {
-          allLiterals = false;
-        }
-      } else {
-        allLiterals = false;
-      }
-    }
-    if (allLiterals && options.length > 0) {
-      return {
-        type: options.map((o) => `"${o}"`).join(" | "),
-        typeKind: "enum",
-        options
-      };
-    }
-    return {
-      type: typeNode.getText(sourceFile),
-      typeKind: "union"
-    };
-  }
-  if (ts2.isFunctionTypeNode(typeNode)) {
-    return {
-      type: typeNode.getText(sourceFile),
-      typeKind: "function"
-    };
-  }
-  if (ts2.isArrayTypeNode(typeNode)) {
-    return {
-      type: typeNode.getText(sourceFile),
-      typeKind: "array"
-    };
-  }
-  if (ts2.isTypeReferenceNode(typeNode)) {
-    const typeName = typeNode.typeName.getText(sourceFile);
-    if (typeName === "ReactNode" || typeName === "React.ReactNode") {
-      return { type: "ReactNode", typeKind: "node" };
-    }
-    if (typeName === "ReactElement" || typeName === "React.ReactElement") {
-      return { type: "ReactElement", typeKind: "element" };
-    }
-    if (typeName === "JSX.Element") {
-      return { type: "JSX.Element", typeKind: "element" };
-    }
-    return {
-      type: typeNode.getText(sourceFile),
-      typeKind: "object"
-    };
-  }
-  if (ts2.isTypeLiteralNode(typeNode)) {
-    return {
-      type: typeNode.getText(sourceFile),
-      typeKind: "object"
-    };
-  }
-  return {
-    type: typeNode.getText(sourceFile),
-    typeKind: "unknown"
-  };
-}
-function getJSDocComment(node) {
-  const jsDocTags = ts2.getJSDocTags(node);
-  const jsDoc = node.jsDoc;
-  if (jsDoc && jsDoc.length > 0) {
-    const comment = jsDoc[0].comment;
-    if (typeof comment === "string") {
-      return comment;
-    }
-    if (Array.isArray(comment)) {
-      return comment.map((c) => typeof c === "string" ? c : c.text).join("");
-    }
-  }
-  return void 0;
-}
-function getJSDocDefault(node) {
-  const jsDocTags = ts2.getJSDocTags(node);
-  for (const tag of jsDocTags) {
-    if (tag.tagName.text === "default") {
-      const comment = tag.comment;
-      if (typeof comment === "string") {
-        try {
-          return JSON.parse(comment);
-        } catch {
-          return comment;
-        }
-      }
-    }
-  }
-  return void 0;
-}
-
-// src/core/generators/registry.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { relative, dirname as dirname4, basename as basename3, join as join3 } from "path";
-import fg2 from "fast-glob";
-async function generateRegistry(options) {
-  const {
-    projectRoot,
-    componentPatterns = ["src/**/*.tsx", "src/**/*.ts"],
-    storyPatterns = ["src/**/*.stories.tsx", "src/**/*.stories.ts"],
-    fragmentsDir = join3(projectRoot, BRAND.dataDir),
-    registryOptions = {}
-  } = options;
-  const {
-    requireStory = false,
-    publicOnly = false,
-    categoryDepth = 1,
-    includeProps = false,
-    embedFragments = false
-  } = registryOptions;
-  const errors = [];
-  const warnings = [];
-  const storyFiles = await fg2(storyPatterns, {
-    cwd: projectRoot,
-    ignore: ["**/node_modules/**"],
-    absolute: true
-  });
-  const storyMap = /* @__PURE__ */ new Map();
-  for (const storyPath of storyFiles) {
-    const storyDir = dirname4(storyPath);
-    const storyBase = basename3(storyPath).replace(/\.stories\.(tsx?|jsx?)$/, "");
-    storyMap.set(`${storyDir}/${storyBase}`, storyPath);
-  }
-  const componentFiles = await fg2(componentPatterns, {
-    cwd: projectRoot,
-    ignore: [
-      "**/node_modules/**",
-      "**/*.stories.*",
-      "**/*.test.*",
-      "**/*.spec.*",
-      "**/*.d.ts"
-    ],
-    absolute: true
-  });
-  const fragmentPattern = join3(
-    BRAND.dataDir,
-    BRAND.componentsDir,
-    `*${BRAND.fileExtension}`
-  );
-  const fragmentFiles = await fg2(fragmentPattern, {
-    cwd: projectRoot,
-    absolute: true
-  });
-  const fragmentMap = /* @__PURE__ */ new Map();
-  for (const fragmentPath of fragmentFiles) {
-    const fragmentName = basename3(fragmentPath).replace(BRAND.fileExtension, "");
-    try {
-      const content = readFileSync2(fragmentPath, "utf-8");
-      const fragment = JSON.parse(content);
-      fragmentMap.set(fragmentName, {
-        path: relative(projectRoot, fragmentPath),
-        fragment
-      });
-    } catch (e) {
-      errors.push({
-        file: fragmentPath,
-        error: `Failed to parse fragment: ${e instanceof Error ? e.message : String(e)}`
-      });
-    }
-  }
-  const components = {};
-  const indexComponents = {};
-  const categories = {};
-  for (const filePath of componentFiles) {
-    try {
-      const extracted = extractPropsFromFile(filePath);
-      if (!extracted || !extracted.componentName) {
-        continue;
-      }
-      const componentName = extracted.componentName;
-      const relativePath = relative(projectRoot, filePath);
-      if (publicOnly && !extracted.exports.includes(componentName)) {
-        continue;
-      }
-      const componentDir = dirname4(filePath);
-      const baseNameWithoutExt = basename3(filePath).replace(/\.(tsx?|jsx?)$/, "");
-      const storyPath = storyMap.get(`${componentDir}/${baseNameWithoutExt}`);
-      if (requireStory && !storyPath) {
-        continue;
-      }
-      const fragmentData = fragmentMap.get(componentName);
-      const category = fragmentData?.fragment?.meta?.status ? void 0 : getCategoryFromPath(relativePath, categoryDepth);
-      const hasEnrichment = fragmentData ? hasRealEnrichment(fragmentData.fragment) : false;
-      const entry = {
-        path: relativePath
-      };
-      if (storyPath) {
-        entry.storyPath = relative(projectRoot, storyPath);
-      }
-      if (fragmentData) {
-        entry.fragmentPath = fragmentData.path;
-        if (hasEnrichment) {
-          entry.hasEnrichment = true;
-        }
-        if (fragmentData.fragment.description) {
-          entry.description = fragmentData.fragment.description;
-        }
-        if (fragmentData.fragment.meta?.status) {
-          entry.status = fragmentData.fragment.meta.status;
-        }
-        if (embedFragments) {
-          entry.fragment = fragmentData.fragment;
-        }
-      }
-      if (category) {
-        entry.category = category;
-        if (!categories[category]) {
-          categories[category] = [];
-        }
-        categories[category].push(componentName);
-      }
-      if (includeProps && extracted.props) {
-        entry.props = extracted.props;
-      }
-      if (extracted.exports.length > 1) {
-        entry.exports = extracted.exports;
-      }
-      components[componentName] = entry;
-      indexComponents[componentName] = relativePath;
-    } catch (e) {
-      errors.push({
-        file: filePath,
-        error: `Failed to extract component: ${e instanceof Error ? e.message : String(e)}`
-      });
-    }
-  }
-  const componentCount = Object.keys(components).length;
-  const registry = {
-    $schema: "https://fragments.dev/schema/registry-v1.json",
-    version: "1.0",
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    componentCount,
-    components,
-    categories
-  };
-  const index = {
-    version: "1.0",
-    generatedAt: registry.generatedAt,
-    components: indexComponents,
-    categories
-  };
-  return { registry, index, errors, warnings };
-}
-function getCategoryFromPath(relativePath, depth = 1) {
-  const parts = relativePath.split("/");
-  const componentsIndex = parts.findIndex((p) => p === "components");
-  if (componentsIndex === -1) {
-    return void 0;
-  }
-  const afterComponents = parts.slice(componentsIndex + 1);
-  if (afterComponents.length <= 1) {
-    return void 0;
-  }
-  const folderName = afterComponents[0];
-  const fileName = afterComponents[afterComponents.length - 1].replace(/\.(tsx?|jsx?)$/, "");
-  if (afterComponents.length === 2 && folderName === fileName) {
-    return void 0;
-  }
-  const categoryParts = afterComponents.slice(0, Math.min(depth, afterComponents.length - 1));
-  const lastCategoryPart = categoryParts[categoryParts.length - 1];
-  if (lastCategoryPart === fileName) {
-    categoryParts.pop();
-  }
-  if (categoryParts.length === 0) {
-    return void 0;
-  }
-  return categoryParts.join("/");
-}
-function hasRealEnrichment(fragment) {
-  if (fragment.description && fragment.description.length > 20) {
-    return true;
-  }
-  if (fragment.usage?.when && fragment.usage.when.length > 0) {
-    return true;
-  }
-  if (fragment.usage?.doNot && fragment.usage.doNot.length > 0) {
-    return true;
-  }
-  if (fragment.usage?.patterns && fragment.usage.patterns.length > 0) {
-    return true;
-  }
-  if (fragment.accessibility?.requirements && fragment.accessibility.requirements.length > 0) {
-    return true;
-  }
-  if (fragment.figma?.nodeId || fragment.figma?.variants) {
-    return true;
-  }
-  if (fragment.related?.similar && fragment.related.similar.length > 0) {
-    return true;
-  }
-  return false;
-}
-function resolveComponentPath(componentName, registry) {
-  const entry = registry.components[componentName];
-  return entry?.path;
-}
-function getComponentsByCategory(category, registry) {
-  return registry.categories?.[category] || [];
-}
-
-// src/core/generators/context.ts
-function generateContextMd(registry, options = {}) {
-  const {
-    format = "markdown",
-    compact = false,
-    include = { props: true, relations: true, code: false }
-  } = options;
-  if (format === "json") {
-    return generateJsonContext(registry, include, compact);
-  }
-  return generateMarkdownContext(registry, include, compact);
-}
-function generateMarkdownContext(registry, include, compact) {
-  const lines = [];
-  const componentNames = Object.keys(registry.components).sort();
-  const componentCount = componentNames.length;
-  lines.push("# Component Library Context");
-  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]} | Components: ${componentCount}`);
-  lines.push("");
-  lines.push("## Quick Reference");
-  lines.push("");
-  lines.push("| Component | Path | Category | Status |");
-  lines.push("|-----------|------|----------|--------|");
-  for (const name of componentNames) {
-    const entry = registry.components[name];
-    const status = entry.status || "stable";
-    const category = entry.category || "-";
-    lines.push(`| ${name} | ${entry.path} | ${category} | ${status} |`);
-  }
-  lines.push("");
-  if (compact) {
-    const content2 = lines.join("\n");
-    return {
-      content: content2,
-      tokenEstimate: estimateTokens(content2),
-      componentCount
-    };
-  }
-  lines.push("---");
-  lines.push("");
-  for (const name of componentNames) {
-    const entry = registry.components[name];
-    const fragment = entry.fragment;
-    lines.push(`## ${name}`);
-    lines.push(`**Path:** \`${entry.path}\``);
-    if (entry.category) {
-      lines.push(`**Category:** ${entry.category} | **Status:** ${entry.status || "stable"}`);
-    }
-    lines.push("");
-    if (entry.description || fragment?.description) {
-      lines.push("### Description");
-      lines.push(entry.description || fragment?.description || "");
-      lines.push("");
-    }
-    if (fragment?.usage) {
-      if (fragment.usage.when && fragment.usage.when.length > 0) {
-        lines.push("### When to Use");
-        for (const when of fragment.usage.when) {
-          lines.push(`- ${when}`);
-        }
-        lines.push("");
-      }
-      if (fragment.usage.doNot && fragment.usage.doNot.length > 0) {
-        lines.push("### Do Not");
-        for (const doNotItem of fragment.usage.doNot) {
-          if (typeof doNotItem === "string") {
-            lines.push(`- ${doNotItem}`);
-          } else {
-            const item = doNotItem;
-            if (item.instead) {
-              const alternativePath = resolveComponentPath2(item.instead, registry);
-              if (alternativePath) {
-                lines.push(`- ${item.text} \u2192 use **${item.instead}** (\`${alternativePath}\`)`);
-              } else {
-                lines.push(`- ${item.text} \u2192 use **${item.instead}**`);
-              }
-            } else {
-              lines.push(`- ${item.text}`);
-            }
-          }
-        }
-        lines.push("");
-      }
-      if (include.code && fragment.usage.patterns && fragment.usage.patterns.length > 0) {
-        lines.push("### Patterns");
-        for (const pattern of fragment.usage.patterns) {
-          lines.push(`**${pattern.name}**`);
-          if (pattern.description) {
-            lines.push(pattern.description);
-          }
-          lines.push("```tsx");
-          lines.push(pattern.code);
-          lines.push("```");
-          lines.push("");
-        }
-      }
-    }
-    if (include.props && entry.props && Object.keys(entry.props).length > 0) {
-      lines.push("### Props");
-      lines.push("| Prop | Type | Default | Description |");
-      lines.push("|------|------|---------|-------------|");
-      for (const [propName, prop] of Object.entries(entry.props)) {
-        const type = formatPropType(prop);
-        const defaultVal = prop.default !== void 0 ? `\`${JSON.stringify(prop.default)}\`` : "-";
-        const desc = prop.description || "-";
-        const required = prop.required ? " (required)" : "";
-        lines.push(`| ${propName}${required} | ${type} | ${defaultVal} | ${desc} |`);
-      }
-      lines.push("");
-    }
-    if (fragment?.accessibility) {
-      lines.push("### Accessibility");
-      if (fragment.accessibility.role) {
-        lines.push(`**Role:** ${fragment.accessibility.role}`);
-      }
-      if (fragment.accessibility.requirements && fragment.accessibility.requirements.length > 0) {
-        for (const req of fragment.accessibility.requirements) {
-          lines.push(`- ${req}`);
-        }
-      }
-      if (fragment.accessibility.keyboard) {
-        lines.push("");
-        lines.push("**Keyboard:**");
-        for (const [key, action] of Object.entries(fragment.accessibility.keyboard)) {
-          lines.push(`- \`${key}\`: ${action}`);
-        }
-      }
-      lines.push("");
-    }
-    if (include.relations && fragment?.related) {
-      lines.push("### Related");
-      if (fragment.related.similar && fragment.related.similar.length > 0) {
-        const resolved = fragment.related.similar.map((comp) => {
-          const path = resolveComponentPath2(comp, registry);
-          return path ? `${comp} (\`${path}\`)` : comp;
-        });
-        lines.push(`- **Similar:** ${resolved.join(", ")}`);
-      }
-      if (fragment.related.composedWith && fragment.related.composedWith.length > 0) {
-        const resolved = fragment.related.composedWith.map((comp) => {
-          const path = resolveComponentPath2(comp, registry);
-          return path ? `${comp} (\`${path}\`)` : comp;
-        });
-        lines.push(`- **Composed with:** ${resolved.join(", ")}`);
-      }
-      if (fragment.related.usedIn && fragment.related.usedIn.length > 0) {
-        const resolved = fragment.related.usedIn.map((comp) => {
-          const path = resolveComponentPath2(comp, registry);
-          return path ? `${comp} (\`${path}\`)` : comp;
-        });
-        lines.push(`- **Used in:** ${resolved.join(", ")}`);
-      }
-      lines.push("");
-    }
-    lines.push("---");
-    lines.push("");
-  }
-  const content = lines.join("\n");
-  return {
-    content,
-    tokenEstimate: estimateTokens(content),
-    componentCount
-  };
-}
-function generateJsonContext(registry, include, compact) {
-  const componentNames = Object.keys(registry.components).sort();
-  const componentCount = componentNames.length;
-  const components = {};
-  for (const name of componentNames) {
-    const entry = registry.components[name];
-    const fragment = entry.fragment;
-    const component = {
-      path: entry.path
-    };
-    if (entry.category) component.category = entry.category;
-    if (entry.status) component.status = entry.status;
-    if (entry.description || fragment?.description) {
-      component.description = entry.description || fragment?.description;
-    }
-    if (!compact && fragment?.usage) {
-      if (fragment.usage.when && fragment.usage.when.length > 0) {
-        component.whenToUse = fragment.usage.when;
-      }
-      if (fragment.usage.doNot && fragment.usage.doNot.length > 0) {
-        component.doNot = fragment.usage.doNot.map((item) => {
-          if (typeof item === "string") {
-            return { text: item };
-          }
-          const doNotItem = item;
-          const result = {
-            text: doNotItem.text
-          };
-          if (doNotItem.instead) {
-            result.instead = doNotItem.instead;
-            result.insteadPath = resolveComponentPath2(doNotItem.instead, registry);
-          }
-          return result;
-        });
-      }
-    }
-    if (!compact && include.props && entry.props) {
-      component.props = {};
-      for (const [propName, prop] of Object.entries(entry.props)) {
-        component.props[propName] = {
-          type: formatPropType(prop)
-        };
-        if (prop.required) component.props[propName].required = true;
-        if (prop.default !== void 0) component.props[propName].default = prop.default;
-        if (prop.description) component.props[propName].description = prop.description;
-      }
-    }
-    if (!compact && include.relations && fragment?.related) {
-      component.related = {};
-      if (fragment.related.similar) {
-        component.related.similar = fragment.related.similar.map((name2) => ({
-          name: name2,
-          path: resolveComponentPath2(name2, registry)
-        }));
-      }
-      if (fragment.related.composedWith) {
-        component.related.composedWith = fragment.related.composedWith.map((name2) => ({
-          name: name2,
-          path: resolveComponentPath2(name2, registry)
-        }));
-      }
-      if (fragment.related.usedIn) {
-        component.related.usedIn = fragment.related.usedIn.map((name2) => ({
-          name: name2,
-          path: resolveComponentPath2(name2, registry)
-        }));
-      }
-    }
-    components[name] = component;
-  }
-  const output = {
-    version: "1.0",
-    generatedAt: registry.generatedAt,
-    componentCount,
-    categories: registry.categories,
-    components
-  };
-  const content = JSON.stringify(output, null, 2);
-  return {
-    content,
-    tokenEstimate: estimateTokens(content),
-    componentCount
-  };
-}
-function resolveComponentPath2(componentName, registry) {
-  return registry.components[componentName]?.path;
-}
-function formatPropType(prop) {
-  if (prop.options && prop.options.length > 0) {
-    return prop.options.map((o) => `"${o}"`).join(" \\| ");
-  }
-  return prop.type || "unknown";
-}
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
+import { existsSync as existsSync4 } from "fs";
+import { join as join3, resolve as resolve3 } from "path";
 
 // src/core/importAnalyzer.ts
 import ts3 from "typescript";
 import { readFileSync as readFileSync3 } from "fs";
 import { dirname as dirname5, basename as basename4 } from "path";
-function extractComponentNameFromPath(filePath) {
-  const fileName = basename4(filePath);
-  if (fileName === "index.tsx" || fileName === "index.ts" || fileName === "index.jsx" || fileName === "index.js") {
-    const parentDir = basename4(dirname5(filePath));
-    return parentDir;
-  }
-  return fileName.replace(/\.(tsx?|jsx?)$/, "").replace(/\.stories$/, "").replace(/\.fragment$/, "").replace(/\.fragment$/, "");
-}
-function isComponentImportPath(importPath) {
-  if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
-    return false;
-  }
-  const skipPatterns = [
-    /\/hooks\//,
-    /\/utils\//,
-    /\/helpers\//,
-    /\/lib\//,
-    /\/types\//,
-    /\/constants\//,
-    /\/styles\//,
-    /\/context\//,
-    /\.css$/,
-    /\.scss$/,
-    /\.less$/,
-    /\.json$/
-  ];
-  for (const pattern of skipPatterns) {
-    if (pattern.test(importPath)) {
-      return false;
-    }
-  }
-  return true;
-}
-function isPascalCase(name) {
-  return /^[A-Z][a-zA-Z0-9]*$/.test(name);
-}
-function analyzeFileImports(filePath) {
-  const componentName = extractComponentNameFromPath(filePath);
-  const imports = [];
-  let sourceText;
-  try {
-    sourceText = readFileSync3(filePath, "utf-8");
-  } catch {
-    return { filePath, componentName, imports };
-  }
-  const sourceFile = ts3.createSourceFile(
-    filePath,
-    sourceText,
-    ts3.ScriptTarget.Latest,
-    true,
-    filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS
-  );
-  ts3.forEachChild(sourceFile, (node) => {
-    if (ts3.isImportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier;
-      if (!ts3.isStringLiteral(moduleSpecifier)) return;
-      const importPath = moduleSpecifier.text;
-      if (!isComponentImportPath(importPath)) return;
-      const importClause = node.importClause;
-      if (!importClause) return;
-      if (importClause.name) {
-        const name = importClause.name.text;
-        if (isPascalCase(name)) {
-          imports.push({
-            name,
-            path: importPath,
-            isDefault: true,
-            isNamespace: false
-          });
-        }
-      }
-      const namedBindings = importClause.namedBindings;
-      if (namedBindings) {
-        if (ts3.isNamedImports(namedBindings)) {
-          for (const element of namedBindings.elements) {
-            const name = element.name.text;
-            if (isPascalCase(name)) {
-              imports.push({
-                name,
-                path: importPath,
-                isDefault: false,
-                isNamespace: false
-              });
-            }
-          }
-        } else if (ts3.isNamespaceImport(namedBindings)) {
-          const name = namedBindings.name.text;
-          imports.push({
-            name,
-            path: importPath,
-            isDefault: false,
-            isNamespace: true
-          });
-        }
-      }
-    }
-  });
-  return { filePath, componentName, imports };
-}
-function buildImportGraph(filePaths) {
-  const importedBy = /* @__PURE__ */ new Map();
-  for (const filePath of filePaths) {
-    const result = analyzeFileImports(filePath);
-    for (const imp of result.imports) {
-      if (imp.isNamespace) continue;
-      const importedComponent = imp.name;
-      const importingComponent = result.componentName;
-      if (importedComponent === importingComponent) continue;
-      const existing = importedBy.get(importedComponent) || [];
-      if (!existing.includes(importingComponent)) {
-        existing.push(importingComponent);
-        importedBy.set(importedComponent, existing);
-      }
-    }
-  }
-  return importedBy;
-}
-function getImportedBy(componentName, importGraph) {
-  return importGraph.get(componentName) || [];
-}
 
 export {
   findConfigFile,
   loadConfig,
   discoverBlockFiles,
-  discoverRecipeFiles,
   discoverFragmentFiles,
   discoverComponentFiles,
   extractComponentName,
-  discoverComponentsFromSource,
-  discoverComponentsFromBarrel,
-  discoverTokenFiles,
-  discoverInstalledFragments,
   discoverAllComponents,
   loadFragmentFile,
-  loadFragmentFiles,
   parseFragmentFile,
-  findPreviewConfigPath,
-  findStorybookDir,
-  loadPreviewConfig,
-  autoLoadPreviewConfig,
-  generatePreviewModule,
-  extractPropsFromFile,
-  extractPropsFromSource,
-  generateRegistry,
-  resolveComponentPath,
-  getComponentsByCategory,
-  generateContextMd,
-  analyzeFileImports,
-  buildImportGraph,
-  getImportedBy
+  extractPropsFromFile
 };
-//# sourceMappingURL=chunk-HQ6A6DTV.js.map
+//# sourceMappingURL=chunk-XRADMHMV.js.map