@fragments-sdk/cli 0.11.1 → 0.12.1

package/dist/{chunk-5G3VZH43.js → chunk-GVDSFQ4E.js}

@@ -1,17 +1,20 @@
 import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
+import {
+  createComponentExtractor
+} from "./chunk-JJ2VRTBU.js";
 import {
   generateContextMd,
   generateRegistry,
   loadFragmentFile,
   parseFragmentFile
-} from "./chunk-HRFUSSZI.js";
+} from "./chunk-AM4MRTMN.js";
 import {
   discoverBlockFiles,
   discoverComponentFiles,
   discoverFragmentFiles,
   discoverTokenFiles,
   extractComponentName
-} from "./chunk-WXSR2II7.js";
+} from "./chunk-OQKMEFOS.js";
 import {
   BrowserPool,
   CaptureEngine,
@@ -21,7 +24,7 @@ import {
   formatMs,
   generateHtmlReport,
   getGrade
-} from "./chunk-D5PYOXEI.js";
+} from "./chunk-LVWFOLUZ.js";
 import {
   BRAND,
   DEFAULTS,
@@ -30,7 +33,7 @@ import {
   fragmentDefinitionSchema,
   parseTokenFile,
   resolvePerformanceConfig
-} from "./chunk-OQO55NKV.js";
+} from "./chunk-WFS63PCW.js";
 
 // src/service/snippet-validation.ts
 import ts from "typescript";
@@ -481,7 +484,52 @@ async function validateSnippetPolicy(config, configDir, options = {}) {
   return toValidationResult(policy, issues);
 }
 
+// src/core/auto-props.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import { dirname, extname, join as join2, resolve } from "path";
+import ts2 from "typescript";
+function isFile(filePath) {
+  if (!existsSync2(filePath)) return false;
+  try {
+    return statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveModulePath(basePath) {
+  const candidates = [];
+  const extension = extname(basePath);
+  if (extension) {
+    candidates.push(basePath);
+  } else {
+    candidates.push(
+      `${basePath}.tsx`,
+      `${basePath}.ts`,
+      `${basePath}.jsx`,
+      `${basePath}.js`,
+      join2(basePath, "index.tsx"),
+      join2(basePath, "index.ts"),
+      join2(basePath, "index.jsx"),
+      join2(basePath, "index.js")
+    );
+  }
+  for (const candidate of candidates) {
+    if (isFile(candidate)) {
+      return resolve(candidate);
+    }
+  }
+  return null;
+}
+function resolveComponentSourcePath(fragmentFileAbsolutePath, componentImportPath) {
+  if (!componentImportPath) return null;
+  if (!componentImportPath.startsWith(".")) return null;
+  const fragmentDir = dirname(fragmentFileAbsolutePath);
+  const basePath = resolve(fragmentDir, componentImportPath);
+  return resolveModulePath(basePath);
+}
+
 // src/validators.ts
+import { readFile as readFile2 } from "fs/promises";
 async function validateSchema(config, configDir) {
   const files = await discoverFragmentFiles(config, configDir);
   const errors = [];
@@ -593,15 +641,162 @@ async function validateSnippets(config, configDir, options = {}) {
     warnings: snippetResult.warnings
   };
 }
+async function validateDrift(config, configDir, options = {}) {
+  const fragmentFiles = await discoverFragmentFiles(config, configDir);
+  const errors = [];
+  const warnings = [];
+  const reports = [];
+  if (fragmentFiles.length === 0) {
+    return { valid: true, errors, warnings, reports };
+  }
+  const extractor = createComponentExtractor(options.tsconfig);
+  try {
+    for (const file of fragmentFiles) {
+      try {
+        const fragment = await loadFragmentFile(file.absolutePath);
+        if (!fragment?.meta?.name) continue;
+        const fileContent = await readFile2(file.absolutePath, "utf-8");
+        const parsed = parseFragmentFile(fileContent, file.absolutePath);
+        if (!parsed.componentImport) continue;
+        const sourcePath = resolveComponentSourcePath(file.absolutePath, parsed.componentImport);
+        if (!sourcePath) continue;
+        const meta = extractor.extract(sourcePath, fragment.meta.name);
+        if (!meta) continue;
+        const drifts = diffProps(fragment.props, meta.props);
+        let compositionDrift = null;
+        const fragmentAi = fragment.ai;
+        if (meta.composition && !fragmentAi?.compositionPattern) {
+          compositionDrift = `Source has "${meta.composition.pattern}" composition but fragment has no ai.compositionPattern`;
+        } else if (!meta.composition && fragmentAi?.compositionPattern) {
+          compositionDrift = `Fragment declares "${fragmentAi.compositionPattern}" but source has no compound pattern`;
+        } else if (meta.composition && fragmentAi?.compositionPattern && meta.composition.pattern !== fragmentAi.compositionPattern) {
+          compositionDrift = `Composition pattern changed: fragment="${fragmentAi.compositionPattern}" source="${meta.composition.pattern}"`;
+        }
+        if (drifts.length > 0 || compositionDrift) {
+          const report2 = {
+            component: fragment.meta.name,
+            file: file.relativePath,
+            drifts,
+            compositionDrift
+          };
+          reports.push(report2);
+          for (const drift of drifts) {
+            if (drift.kind === "removed") {
+              errors.push({
+                file: file.relativePath,
+                message: `Prop "${drift.prop}" documented in fragment but removed from source`,
+                details: `Fragment: ${drift.fragment} | Source: (not found)`
+              });
+            } else if (drift.kind === "added") {
+              warnings.push({
+                file: file.relativePath,
+                message: `Prop "${drift.prop}" exists in source but not documented in fragment`
+              });
+            } else {
+              warnings.push({
+                file: file.relativePath,
+                message: `Prop "${drift.prop}" ${drift.kind.replace("_", " ")}: fragment=${drift.fragment} source=${drift.source}`
+              });
+            }
+          }
+          if (compositionDrift) {
+            warnings.push({
+              file: file.relativePath,
+              message: compositionDrift
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  } finally {
+    extractor.dispose();
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    reports
+  };
+}
+function diffProps(fragmentProps, sourceProps) {
+  const drifts = [];
+  const localSourceProps = Object.fromEntries(
+    Object.entries(sourceProps).filter(([_, p]) => p.source === "local")
+  );
+  for (const [name, sourceProp] of Object.entries(localSourceProps)) {
+    if (!(name in fragmentProps)) {
+      drifts.push({
+        prop: name,
+        kind: "added",
+        source: sourceProp.type,
+        fragment: "(not documented)"
+      });
+    }
+  }
+  for (const [name, fragProp] of Object.entries(fragmentProps)) {
+    if (!(name in localSourceProps)) {
+      drifts.push({
+        prop: name,
+        kind: "removed",
+        source: "(not found)",
+        fragment: String(fragProp.type ?? "unknown")
+      });
+      continue;
+    }
+    const sourceProp = localSourceProps[name];
+    if (fragProp.type && fragProp.type !== sourceProp.typeKind) {
+      drifts.push({
+        prop: name,
+        kind: "type_changed",
+        source: sourceProp.typeKind,
+        fragment: String(fragProp.type)
+      });
+    }
+    if (fragProp.required !== void 0 && fragProp.required !== sourceProp.required) {
+      drifts.push({
+        prop: name,
+        kind: "required_changed",
+        source: String(sourceProp.required),
+        fragment: String(fragProp.required)
+      });
+    }
+    if (fragProp.values && sourceProp.values) {
+      const fragSet = new Set(fragProp.values);
+      const srcSet = new Set(sourceProp.values);
+      const added = sourceProp.values.filter((v) => !fragSet.has(v));
+      const removed = Array.from(fragProp.values).filter((v) => !srcSet.has(v));
+      if (added.length > 0 || removed.length > 0) {
+        drifts.push({
+          prop: name,
+          kind: "values_changed",
+          source: sourceProp.values.join(", "),
+          fragment: Array.from(fragProp.values).join(", ")
+        });
+      }
+    }
+    if (fragProp.default !== void 0 && sourceProp.default !== void 0) {
+      if (String(fragProp.default) !== sourceProp.default) {
+        drifts.push({
+          prop: name,
+          kind: "default_changed",
+          source: sourceProp.default,
+          fragment: String(fragProp.default)
+        });
+      }
+    }
+  }
+  return drifts;
+}
 
 // src/build.ts
-import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { readFile as readFile3, writeFile, mkdir } from "fs/promises";
 import { resolve as resolve5, join as join5 } from "path";
 import { existsSync as existsSync6 } from "fs";
 
 // src/core/token-resolver.ts
-import { resolve, dirname, basename } from "path";
-import { existsSync as existsSync2, readdirSync } from "fs";
+import { resolve as resolve2, dirname as dirname2, basename } from "path";
+import { existsSync as existsSync3, readdirSync } from "fs";
 function roundRgbValues(value) {
   return value.replace(
     /rgb\(([^)]+)\)/g,
@@ -647,7 +842,7 @@ async function resolveTokensWithSass(unresolvedTokens, tokensDir) {
 :root { @include vars.fui-css-variables; }
 `;
     const compiled = sass.compileString(scssSource, {
-      loadPaths: [tokensDir, dirname(tokensDir)],
+      loadPaths: [tokensDir, dirname2(tokensDir)],
       style: "expanded",
       // Suppress sass deprecation warnings during build
       logger: { warn() {
@@ -673,15 +868,15 @@ async function resolveTokensWithSass(unresolvedTokens, tokensDir) {
 function findVariablesFile(tokensDir) {
   const candidates = ["_variables.scss", "variables.scss"];
   for (const name of candidates) {
-    const path = resolve(tokensDir, name);
-    if (existsSync2(path)) {
+    const path = resolve2(tokensDir, name);
+    if (existsSync3(path)) {
       return path;
     }
   }
   try {
     const files = readdirSync(tokensDir).filter((f) => f.endsWith(".scss"));
     for (const file of files) {
-      const path = resolve(tokensDir, file);
+      const path = resolve2(tokensDir, file);
       if (file.includes("variables") || file.includes("tokens")) {
         return path;
       }
@@ -691,312 +886,6 @@ function findVariablesFile(tokensDir) {
   return null;
 }
 
-// src/core/auto-props.ts
-import { existsSync as existsSync3, statSync } from "fs";
-import { dirname as dirname2, extname, join as join2, resolve as resolve2 } from "path";
-import ts2 from "typescript";
-function toPosixPath(filePath) {
-  return filePath.replace(/\\/g, "/");
-}
-function isFile(filePath) {
-  if (!existsSync3(filePath)) return false;
-  try {
-    return statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function resolveModulePath(basePath) {
-  const candidates = [];
-  const extension = extname(basePath);
-  if (extension) {
-    candidates.push(basePath);
-  } else {
-    candidates.push(
-      `${basePath}.tsx`,
-      `${basePath}.ts`,
-      `${basePath}.jsx`,
-      `${basePath}.js`,
-      join2(basePath, "index.tsx"),
-      join2(basePath, "index.ts"),
-      join2(basePath, "index.jsx"),
-      join2(basePath, "index.js")
-    );
-  }
-  for (const candidate of candidates) {
-    if (isFile(candidate)) {
-      return resolve2(candidate);
-    }
-  }
-  return null;
-}
-function resolveComponentSourcePath(fragmentFileAbsolutePath, componentImportPath) {
-  if (!componentImportPath) return null;
-  if (!componentImportPath.startsWith(".")) return null;
-  const fragmentDir = dirname2(fragmentFileAbsolutePath);
-  const basePath = resolve2(fragmentDir, componentImportPath);
-  return resolveModulePath(basePath);
-}
-function collectTopLevelDeclarations(sourceFile) {
-  const typeDeclarations = /* @__PURE__ */ new Map();
-  const functionDeclarations = /* @__PURE__ */ new Map();
-  const variableDeclarations = /* @__PURE__ */ new Map();
-  for (const node of sourceFile.statements) {
-    if (ts2.isInterfaceDeclaration(node)) {
-      typeDeclarations.set(node.name.text, node);
-      continue;
-    }
-    if (ts2.isTypeAliasDeclaration(node)) {
-      typeDeclarations.set(node.name.text, node);
-      continue;
-    }
-    if (ts2.isFunctionDeclaration(node) && node.name) {
-      functionDeclarations.set(node.name.text, node);
-      continue;
-    }
-    if (ts2.isVariableStatement(node)) {
-      for (const declaration of node.declarationList.declarations) {
-        if (ts2.isIdentifier(declaration.name)) {
-          variableDeclarations.set(declaration.name.text, declaration);
-        }
-      }
-    }
-  }
-  return { typeDeclarations, functionDeclarations, variableDeclarations };
-}
-function readDefaultValue(expression) {
-  if (ts2.isStringLiteral(expression) || ts2.isNoSubstitutionTemplateLiteral(expression)) {
-    return expression.text;
-  }
-  if (ts2.isNumericLiteral(expression)) {
-    return Number(expression.text);
-  }
-  if (expression.kind === ts2.SyntaxKind.TrueKeyword) return true;
-  if (expression.kind === ts2.SyntaxKind.FalseKeyword) return false;
-  if (expression.kind === ts2.SyntaxKind.NullKeyword) return null;
-  if (ts2.isPrefixUnaryExpression(expression) && expression.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(expression.operand)) {
-    return -Number(expression.operand.text);
-  }
-  return void 0;
-}
-function extractDefaultValues(componentNode) {
-  const defaults = {};
-  if (!componentNode?.parameters?.length) return defaults;
-  const firstParam = componentNode.parameters[0];
-  if (!ts2.isObjectBindingPattern(firstParam.name)) return defaults;
-  for (const element of firstParam.name.elements) {
-    let propName = null;
-    if (element.propertyName) {
-      if (ts2.isIdentifier(element.propertyName) || ts2.isStringLiteral(element.propertyName)) {
-        propName = element.propertyName.text;
-      }
-    } else if (ts2.isIdentifier(element.name)) {
-      propName = element.name.text;
-    }
-    if (!propName || !element.initializer) continue;
-    const value = readDefaultValue(element.initializer);
-    if (value !== void 0) {
-      defaults[propName] = value;
-    }
-  }
-  return defaults;
-}
-function isNullishType(type) {
-  return (type.flags & ts2.TypeFlags.Null) !== 0 || (type.flags & ts2.TypeFlags.Undefined) !== 0 || (type.flags & ts2.TypeFlags.Void) !== 0;
-}
-function isBooleanLikeType(type) {
-  return (type.flags & ts2.TypeFlags.BooleanLike) !== 0 || type.flags === ts2.TypeFlags.BooleanLiteral;
-}
-function inferPropType(type, checker) {
-  const typeText = checker.typeToString(type, void 0, ts2.TypeFormatFlags.NoTruncation);
-  if (typeText.includes("ReactNode")) {
-    return { type: "node" };
-  }
-  if (typeText.includes("ReactElement") || typeText.includes("JSX.Element")) {
-    return { type: "element" };
-  }
-  if (type.getCallSignatures().length > 0) {
-    return { type: "function" };
-  }
-  if (checker.isArrayType(type) || checker.isTupleType(type)) {
-    return { type: "array" };
-  }
-  if (type.isUnion()) {
-    const nonNullableTypes = type.types.filter((unionType) => !isNullishType(unionType));
-    if (nonNullableTypes.length === 1) {
-      return inferPropType(nonNullableTypes[0], checker);
-    }
-    const stringLiteralValues = nonNullableTypes.filter((unionType) => (unionType.flags & ts2.TypeFlags.StringLiteral) !== 0).map((unionType) => unionType.value);
-    if (stringLiteralValues.length > 0 && stringLiteralValues.length === nonNullableTypes.length) {
-      return { type: "enum", values: stringLiteralValues };
-    }
-    if (nonNullableTypes.every((unionType) => isBooleanLikeType(unionType))) {
-      return { type: "boolean" };
-    }
-    return { type: "union" };
-  }
-  if ((type.flags & ts2.TypeFlags.StringLike) !== 0) {
-    return { type: "string" };
-  }
-  if ((type.flags & ts2.TypeFlags.NumberLike) !== 0) {
-    return { type: "number" };
-  }
-  if ((type.flags & ts2.TypeFlags.BooleanLike) !== 0) {
-    return { type: "boolean" };
-  }
-  if ((type.flags & ts2.TypeFlags.Object) !== 0) {
-    return { type: "object" };
-  }
-  return { type: "custom" };
-}
-function resolveComponentSignature(exportName, declarations, sourceFile) {
-  const visitedNames = /* @__PURE__ */ new Set();
-  const typeNodeFromFunction = (node) => ({
-    propsTypeNode: node.parameters[0]?.type ?? null,
-    componentNode: node
-  });
-  const resolveFromExpression = (expression) => {
-    if (ts2.isParenthesizedExpression(expression)) {
-      return resolveFromExpression(expression.expression);
-    }
-    if (ts2.isAsExpression(expression) || ts2.isTypeAssertionExpression(expression)) {
-      return resolveFromExpression(expression.expression);
-    }
-    if (ts2.isArrowFunction(expression) || ts2.isFunctionExpression(expression)) {
-      return typeNodeFromFunction(expression);
-    }
-    if (ts2.isIdentifier(expression)) {
-      return resolveFromIdentifier(expression.text);
-    }
-    if (ts2.isCallExpression(expression)) {
-      if (ts2.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "forwardRef") {
-        const forwardRefPropsType = expression.typeArguments?.[1] ?? null;
-        const innerArg = expression.arguments[0];
-        const inner = innerArg && (ts2.isArrowFunction(innerArg) || ts2.isFunctionExpression(innerArg)) ? typeNodeFromFunction(innerArg) : innerArg && ts2.isIdentifier(innerArg) ? resolveFromIdentifier(innerArg.text) : { propsTypeNode: null, componentNode: null };
-        return {
-          propsTypeNode: forwardRefPropsType ?? inner.propsTypeNode,
-          componentNode: inner.componentNode
-        };
-      }
-      if (ts2.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "memo" && expression.arguments[0]) {
-        return resolveFromExpression(expression.arguments[0]);
-      }
-      if (ts2.isPropertyAccessExpression(expression.expression) && expression.expression.expression.getText(sourceFile) === "Object" && expression.expression.name.text === "assign" && expression.arguments[0]) {
-        return resolveFromExpression(expression.arguments[0]);
-      }
-    }
-    return { propsTypeNode: null, componentNode: null };
-  };
-  const resolveFromVariable = (declaration) => {
-    if (declaration.type && ts2.isTypeReferenceNode(declaration.type) && declaration.type.typeArguments?.length) {
-      const typeName = declaration.type.typeName.getText(sourceFile);
-      if (typeName.includes("FC") || typeName.includes("FunctionComponent")) {
-        const componentNode = declaration.initializer && (ts2.isArrowFunction(declaration.initializer) || ts2.isFunctionExpression(declaration.initializer)) ? declaration.initializer : null;
-        return {
-          propsTypeNode: declaration.type.typeArguments[0] ?? null,
-          componentNode
-        };
-      }
-    }
-    if (declaration.initializer) {
-      return resolveFromExpression(declaration.initializer);
-    }
-    return { propsTypeNode: null, componentNode: null };
-  };
-  const resolveFromIdentifier = (name) => {
-    if (!name || visitedNames.has(name)) {
-      return { propsTypeNode: null, componentNode: null };
-    }
-    visitedNames.add(name);
-    const functionDeclaration = declarations.functionDeclarations.get(name);
-    if (functionDeclaration) {
-      return typeNodeFromFunction(functionDeclaration);
-    }
-    const variableDeclaration = declarations.variableDeclarations.get(name);
-    if (variableDeclaration) {
-      return resolveFromVariable(variableDeclaration);
-    }
-    return { propsTypeNode: null, componentNode: null };
-  };
-  return resolveFromIdentifier(exportName);
-}
-function extractCustomPropsFromComponentFile(componentFilePath, exportName) {
-  const warnings = [];
-  const resolvedPath = resolve2(componentFilePath);
-  if (!existsSync3(resolvedPath)) {
-    return {
-      props: {},
-      warnings: [`Component file not found: ${resolvedPath}`],
-      resolved: false
-    };
-  }
-  const compilerOptions = {
-    target: ts2.ScriptTarget.ESNext,
-    module: ts2.ModuleKind.ESNext,
-    moduleResolution: ts2.ModuleResolutionKind.Bundler,
-    jsx: ts2.JsxEmit.ReactJSX,
-    allowSyntheticDefaultImports: true,
-    esModuleInterop: true,
-    skipLibCheck: true,
-    strict: false,
-    noEmit: true
-  };
-  const program = ts2.createProgram([resolvedPath], compilerOptions);
-  const sourceFile = program.getSourceFile(resolvedPath);
-  if (!sourceFile) {
-    return {
-      props: {},
-      warnings: [`Unable to parse component source: ${resolvedPath}`],
-      resolved: false
-    };
-  }
-  const checker = program.getTypeChecker();
-  const declarations = collectTopLevelDeclarations(sourceFile);
-  const signature = resolveComponentSignature(exportName, declarations, sourceFile);
-  if (!signature.propsTypeNode) {
-    return {
-      props: {},
-      warnings: [`Unable to resolve props type for export: ${exportName}`],
-      resolved: false
-    };
-  }
-  const propsType = checker.getTypeFromTypeNode(signature.propsTypeNode);
-  const defaultValues = extractDefaultValues(signature.componentNode);
-  const sourceFilePath = toPosixPath(sourceFile.fileName);
-  const extractedProps = {};
-  for (const symbol of checker.getPropertiesOfType(propsType)) {
-    const propName = symbol.getName();
-    if (propName.startsWith("_") || propName.startsWith("$")) {
-      continue;
-    }
-    const declarationsForSymbol = symbol.getDeclarations() ?? [];
-    const localDeclarations = declarationsForSymbol.filter(
-      (declaration) => toPosixPath(declaration.getSourceFile().fileName) === sourceFilePath
-    );
-    if (localDeclarations.length === 0) {
-      continue;
-    }
-    const referenceNode = localDeclarations[0];
-    const inferredType = inferPropType(checker.getTypeOfSymbolAtLocation(symbol, referenceNode), checker);
-    const description = ts2.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
-    extractedProps[propName] = {
-      type: inferredType.type,
-      description,
-      required: (symbol.getFlags() & ts2.SymbolFlags.Optional) === 0,
-      ...inferredType.values && { values: inferredType.values },
-      ...defaultValues[propName] !== void 0 && { default: defaultValues[propName] }
-    };
-  }
-  if (Object.keys(extractedProps).length === 0) {
-    warnings.push(`Resolved props type for ${exportName}, but no local custom props were found`);
-  }
-  return {
-    props: extractedProps,
-    warnings,
-    resolved: true
-  };
-}
-
 // src/core/graph-extractor.ts
 import ts3 from "typescript";
 import { readFileSync, existsSync as existsSync4 } from "fs";
@@ -1645,13 +1534,13 @@ function normalizeParsedProps(parsedProps) {
 }
 function mergeDocumentedAndAutoProps(documentedProps, autoProps) {
   return Object.fromEntries(
-    Object.keys(autoProps).map((name) => {
+    Object.keys(autoProps).filter((name) => autoProps[name].source === "local" || name in documentedProps).map((name) => {
       const documented = documentedProps[name];
       const auto = autoProps[name];
       return [
         name,
         {
-          type: auto.type,
+          type: auto.typeKind,
           description: documented?.description ?? auto.description ?? "",
           default: auto.default !== void 0 ? auto.default : documented?.default,
           required: auto.required,
@@ -1662,14 +1551,37 @@ function mergeDocumentedAndAutoProps(documentedProps, autoProps) {
     })
   );
 }
+function compilePropsSummary(props) {
+  return Object.entries(props).filter(([_, p]) => p.source === "local").map(([name, prop]) => {
+    let summary = name + ": ";
+    if (prop.values && prop.values.length > 0) {
+      summary += prop.values.join("|");
+    } else {
+      summary += prop.typeKind;
+    }
+    if (prop.default !== void 0) {
+      summary += ` (default: ${prop.default})`;
+    }
+    if (prop.required) {
+      summary += " (required)";
+    }
+    return summary;
+  });
+}
 async function buildFragments(config, configDir) {
   const files = await discoverFragmentFiles(config, configDir);
   const errors = [];
   const warnings = [];
   const fragments = {};
+  const tsconfigCandidates = [
+    resolve5(configDir, "tsconfig.json"),
+    resolve5(configDir, "..", "tsconfig.json")
+  ];
+  const tsconfigPath = tsconfigCandidates.find((p) => existsSync6(p));
+  const extractor = createComponentExtractor(tsconfigPath);
   for (const file of files) {
     try {
-      const content = await readFile2(file.absolutePath, "utf-8");
+      const content = await readFile3(file.absolutePath, "utf-8");
       if (!content.includes("defineFragment")) {
         warnings.push({
           file: file.relativePath,
@@ -1695,34 +1607,32 @@ async function buildFragments(config, configDir) {
         file.absolutePath,
         parsed.componentImport
       );
+      let extractedMeta = null;
       if (componentExportName && componentSourcePath) {
-        const autoPropsResult = extractCustomPropsFromComponentFile(
-          componentSourcePath,
-          componentExportName
-        );
-        for (const warning of autoPropsResult.warnings) {
-          warnings.push({ file: file.relativePath, warning });
+        try {
+          extractedMeta = extractor.extract(componentSourcePath, componentExportName);
+        } catch {
         }
-        const hasAutoProps = Object.keys(autoPropsResult.props).length > 0;
-        if (autoPropsResult.resolved && hasAutoProps) {
-          const removedDocumentedProps = Object.keys(documentedProps).filter(
-            (propName) => !(propName in autoPropsResult.props)
-          );
-          if (removedDocumentedProps.length > 0) {
+        if (extractedMeta) {
+          const autoProps = extractedMeta.props;
+          const hasAutoProps = Object.keys(autoProps).length > 0;
+          if (hasAutoProps) {
+            const removedDocumentedProps = Object.keys(documentedProps).filter(
+              (propName) => !(propName in autoProps)
+            );
+            if (removedDocumentedProps.length > 0) {
+              warnings.push({
+                file: file.relativePath,
+                warning: `Removed ${removedDocumentedProps.length} documented props not present in source API: ${removedDocumentedProps.join(", ")}`
+              });
+            }
+            mergedProps = mergeDocumentedAndAutoProps(documentedProps, autoProps);
+          } else if (Object.keys(documentedProps).length > 0) {
             warnings.push({
               file: file.relativePath,
-              warning: `Removed ${removedDocumentedProps.length} documented props not present in source API: ${removedDocumentedProps.join(", ")}`
+              warning: "Auto-props extraction returned no props; falling back to documented props"
             });
           }
-          mergedProps = mergeDocumentedAndAutoProps(
-            documentedProps,
-            autoPropsResult.props
-          );
-        } else if (autoPropsResult.resolved && !hasAutoProps && Object.keys(documentedProps).length > 0) {
-          warnings.push({
-            file: file.relativePath,
-            warning: "Auto-props extraction returned no custom props; falling back to documented props"
-          });
         }
       } else if (!componentExportName) {
         warnings.push({
@@ -1735,6 +1645,23 @@ async function buildFragments(config, configDir) {
           warning: `Unable to resolve component source path from import: ${parsed.componentImport ?? "unknown"}`
         });
       }
+      let contract = parsed.contract;
+      if (!contract?.propsSummary && extractedMeta) {
+        const summary = compilePropsSummary(extractedMeta.props);
+        if (summary.length > 0) {
+          contract = { ...contract, propsSummary: summary };
+        }
+      }
+      let ai = parsed.ai;
+      if (extractedMeta?.composition) {
+        const comp = extractedMeta.composition;
+        ai = {
+          compositionPattern: comp.pattern,
+          subComponents: comp.parts.map((p) => p.name),
+          ...ai
+          // Manually authored ai fields take precedence
+        };
+      }
       const compiled = {
         filePath: file.relativePath,
         meta: {
@@ -1766,10 +1693,10 @@ async function buildFragments(config, configDir) {
           ...v.figma && { figma: v.figma },
           ...v.args && { args: v.args }
         })),
-        // Include AI metadata if present
-        ...parsed.ai && { ai: parsed.ai },
-        // Include contract metadata if present
-        ...parsed.contract && { contract: parsed.contract }
+        // Include AI metadata (auto-enriched or manual)
+        ...ai && { ai },
+        // Include contract metadata (auto-compiled or manual)
+        ...contract && { contract }
       };
       fragments[parsed.meta.name] = compiled;
     } catch (error) {
@@ -1779,6 +1706,7 @@ async function buildFragments(config, configDir) {
       });
     }
   }
+  extractor.dispose();
   const blocks = {};
   try {
     const blockFiles = await discoverBlockFiles(configDir, config.exclude);
@@ -1812,7 +1740,7 @@ async function buildFragments(config, configDir) {
       let total = 0;
       const fileContents = [];
       for (const file of tokenFiles) {
-        const content = await readFile2(file.absolutePath, "utf-8");
+        const content = await readFile3(file.absolutePath, "utf-8");
         fileContents.push({ content, path: file.relativePath });
       }
       const allContent = fileContents.map((f) => f.content).join("\n");
@@ -1869,7 +1797,7 @@ async function buildFragments(config, configDir) {
   const pkgJsonPath = resolve5(configDir, "package.json");
   if (existsSync6(pkgJsonPath)) {
     try {
-      const pkg = JSON.parse(await readFile2(pkgJsonPath, "utf-8"));
+      const pkg = JSON.parse(await readFile3(pkgJsonPath, "utf-8"));
       if (pkg.name) packageName = pkg.name;
     } catch {
     }
@@ -2344,7 +2272,7 @@ ${BRAND.name} Diff
 
 // src/analyze.ts
 import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join6, dirname as dirname4 } from "path";
 import pc3 from "picocolors";
 async function runAnalyzeCommand(config, configDir, options = {}) {
@@ -2363,7 +2291,7 @@ ${BRAND.name} Analyzer
     };
   }
   console.log(pc3.dim("Analyzing design system...\n"));
-  const content = await readFile3(fragmentsPath, "utf-8");
+  const content = await readFile4(fragmentsPath, "utf-8");
   const data = JSON.parse(content);
   const analytics = analyzeDesignSystem(data);
   printConsoleSummary(analytics);
@@ -2508,10 +2436,12 @@ function createEmptyAnalytics() {
 }
 
 export {
+  resolveComponentSourcePath,
   validateSchema,
   validateCoverage,
   validateAll,
   validateSnippets,
+  validateDrift,
   measureBundleSizes,
   toPerformanceData,
   buildFragments,
@@ -2520,4 +2450,4 @@ export {
   runDiffCommand,
   runAnalyzeCommand
 };
-//# sourceMappingURL=chunk-5G3VZH43.js.map
+//# sourceMappingURL=chunk-GVDSFQ4E.js.map