@fragments-sdk/cli 0.5.2 → 0.6.0

package/dist/{chunk-ICAIQ57V.js → chunk-6JBGU74P.js}

@@ -1,4 +1,4 @@
-import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
 
 // src/core/constants.ts
 var BRAND = {
@@ -152,7 +152,9 @@ var relationshipTypeSchema = z.enum([
   "sibling",
   "parent",
   "child",
-  "composition"
+  "composition",
+  "complementary",
+  "used-by"
 ]);
 var componentRelationSchema = z.object({
   component: z.string().min(1),
@@ -244,4 +246,4 @@ export {
   segmentsConfigSchema,
   recipeDefinitionSchema
 };
-//# sourceMappingURL=chunk-ICAIQ57V.js.map
+//# sourceMappingURL=chunk-6JBGU74P.js.map

package/dist/chunk-6JBGU74P.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/constants.ts","../src/core/schema.ts"],"sourcesContent":["/**\n * Brand constants for easy rebranding if domain availability requires it.\n * All naming throughout the codebase should reference these constants.\n */\nexport const BRAND = {\n  /** Display name (e.g., \"Fragments\") */\n  name: \"Fragments\",\n\n  /** Lowercase name for file paths and CLI (e.g., \"fragments\") */\n  nameLower: \"fragments\",\n\n  /** File extension for fragment definition files (e.g., \".fragment.tsx\") */\n  fileExtension: \".fragment.tsx\",\n\n  /** Legacy file extension for segments (still supported for migration) */\n  legacyFileExtension: \".segment.tsx\",\n\n  /** JSON file extension for compiled output */\n  jsonExtension: \".fragment.json\",\n\n  /** Default output file name (e.g., \"fragments.json\") */\n  outFile: \"fragments.json\",\n\n  /** Config file name (e.g., \"fragments.config.ts\") */\n  configFile: \"fragments.config.ts\",\n\n  /** Legacy config file name (still supported for migration) */\n  legacyConfigFile: \"segments.config.ts\",\n\n  /** CLI command name (e.g., \"fragments\") */\n  cliCommand: \"fragments\",\n\n  /** Package scope (e.g., \"@fragments\") */\n  packageScope: \"@fragments\",\n\n  /** Directory for storing fragments, registry, and cache */\n  dataDir: \".fragments\",\n\n  /** Components subdirectory within .fragments/ */\n  componentsDir: \"components\",\n\n  /** Registry file name */\n  registryFile: \"registry.json\",\n\n  /** Context file name (AI-ready markdown) */\n  contextFile: \"context.md\",\n\n  /** Screenshots subdirectory */\n  screenshotsDir: \"screenshots\",\n\n  /** Cache subdirectory (gitignored) */\n  cacheDir: \"cache\",\n\n  /** Diff output subdirectory (gitignored) */\n  diffDir: \"diff\",\n\n  /** Manifest filename */\n  manifestFile: \"manifest.json\",\n\n  /** Prefix for localStorage keys (e.g., \"fragments-\") */\n  storagePrefix: \"fragments-\",\n\n  /** Static viewer HTML file name */\n  viewerHtmlFile: \"fragments-viewer.html\",\n\n  /** MCP tool name prefix (e.g., \"fragments_\") */\n  mcpToolPrefix: \"fragments_\",\n\n  /** File extension for block definition files */\n  blockFileExtension: \".block.ts\",\n\n  /** @deprecated Use blockFileExtension instead */\n  recipeFileExtension: \".recipe.ts\",\n\n  /** Vite plugin namespace */\n  vitePluginNamespace: \"fragments-core-shim\",\n} as const;\n\nexport type Brand = typeof BRAND;\n\n/**\n * Default configuration values for the service.\n * These can be overridden in fragments.config.ts\n */\nexport const DEFAULTS = {\n  /** Default viewport dimensions */\n  viewport: {\n    width: 1280,\n    height: 800,\n  },\n\n  /** Default diff threshold (percentage) */\n  diffThreshold: 5,\n\n  /** Browser pool size */\n  poolSize: 3,\n\n  /** Idle timeout before browser shutdown (ms) - 5 minutes */\n  idleTimeoutMs: 5 * 60 * 1000,\n\n  /** Delay after render before capture (ms) */\n  captureDelayMs: 100,\n\n  /** Font loading timeout (ms) */\n  fontTimeoutMs: 3000,\n\n  /** Default theme */\n  theme: \"light\" as const,\n\n  /** Dev server port */\n  port: 6006,\n} as const;\n\nexport type Defaults = typeof DEFAULTS;\n","import { z } from 'zod';\n\n/**\n * Zod schemas for runtime validation of segment definitions\n */\n\n// Figma property mapping schemas\nconst figmaStringMappingSchema = z.object({\n  __type: z.literal('figma-string'),\n  figmaProperty: z.string().min(1),\n});\n\nconst figmaBooleanMappingSchema = z.object({\n  __type: z.literal('figma-boolean'),\n  figmaProperty: z.string().min(1),\n  valueMapping: z.object({ true: z.unknown(), false: z.unknown() }).optional(),\n});\n\nconst figmaEnumMappingSchema = z.object({\n  __type: z.literal('figma-enum'),\n  figmaProperty: z.string().min(1),\n  valueMapping: z.record(z.unknown()),\n});\n\nconst figmaInstanceMappingSchema = z.object({\n  __type: z.literal('figma-instance'),\n  figmaProperty: z.string().min(1),\n});\n\nconst figmaChildrenMappingSchema = z.object({\n  __type: z.literal('figma-children'),\n  layers: z.array(z.string().min(1)),\n});\n\nconst figmaTextContentMappingSchema = z.object({\n  __type: z.literal('figma-text-content'),\n  layer: z.string().min(1),\n});\n\nexport const figmaPropMappingSchema = z.discriminatedUnion('__type', [\n  figmaStringMappingSchema,\n  figmaBooleanMappingSchema,\n  figmaEnumMappingSchema,\n  figmaInstanceMappingSchema,\n  figmaChildrenMappingSchema,\n  figmaTextContentMappingSchema,\n]);\n\nexport const segmentMetaSchema = z.object({\n  name: z.string().min(1),\n  description: z.string().min(1),\n  category: z.string().min(1),\n  tags: z.array(z.string()).optional(),\n  status: z.enum(['stable', 'beta', 'deprecated', 'experimental']).optional(),\n  since: z.string().optional(),\n  figma: z.string().url().optional(),\n  figmaProps: z.record(figmaPropMappingSchema).optional(),\n});\n\nexport const segmentUsageSchema = z.object({\n  when: z.array(z.string()).min(1),\n  whenNot: z.array(z.string()).min(1),\n  guidelines: z.array(z.string()).optional(),\n  accessibility: z.array(z.string()).optional(),\n});\n\nexport const propTypeSchema: z.ZodType<string> = z.enum([\n  'string',\n  'number',\n  'boolean',\n  'enum',\n  'function',\n  'node',\n  'element',\n  'object',\n  'array',\n  'union',\n  'custom',\n]);\n\nexport const propDefinitionSchema = z.object({\n  type: propTypeSchema,\n  values: z.array(z.string()).readonly().optional(),\n  default: z.unknown().optional(),\n  description: z.string().optional(),\n  required: z.boolean().optional(),\n  constraints: z.array(z.string()).optional(),\n  typeDetails: z.record(z.unknown()).optional(),\n});\n\nexport const relationshipTypeSchema = z.enum([\n  'alternative',\n  'sibling',\n  'parent',\n  'child',\n  'composition',\n  'complementary',\n  'used-by',\n]);\n\nexport const componentRelationSchema = z.object({\n  component: z.string().min(1),\n  relationship: relationshipTypeSchema,\n  note: z.string().min(1),\n});\n\nexport const segmentVariantSchema = z.object({\n  name: z.string().min(1),\n  description: z.string().min(1),\n  render: z.function().returns(z.unknown()),\n  code: z.string().optional(),\n  figma: z.string().url().optional(),\n});\n\n/**\n * Schema for banned patterns in codebase\n */\nexport const segmentBanSchema = z.object({\n  pattern: z.string().min(1),\n  message: z.string().min(1),\n});\n\n/**\n * Schema for agent-optimized contract metadata\n */\nexport const segmentContractSchema = z.object({\n  propsSummary: z.array(z.string()).optional(),\n  a11yRules: z.array(z.string()).optional(),\n  bans: z.array(segmentBanSchema).optional(),\n  scenarioTags: z.array(z.string()).optional(),\n});\n\n/**\n * Schema for provenance tracking of generated segments\n */\nexport const segmentGeneratedSchema = z.object({\n  source: z.enum(['storybook', 'manual', 'ai']),\n  sourceFile: z.string().optional(),\n  confidence: z.number().min(0).max(1).optional(),\n  timestamp: z.string().datetime().optional(),\n});\n\n/**\n * Schema for AI-specific metadata for playground context generation\n */\nexport const aiMetadataSchema = z.object({\n  compositionPattern: z.enum(['compound', 'simple', 'controlled']).optional(),\n  subComponents: z.array(z.string()).optional(),\n  requiredChildren: z.array(z.string()).optional(),\n  commonPatterns: z.array(z.string()).optional(),\n});\n\n/**\n * Schema for block definitions\n */\nexport const blockDefinitionSchema = z.object({\n  name: z.string().min(1),\n  description: z.string().min(1),\n  category: z.string().min(1),\n  components: z.array(z.string().min(1)).min(1),\n  code: z.string().min(1),\n  tags: z.array(z.string()).optional(),\n});\n\nexport const segmentDefinitionSchema = z.object({\n  component: z.any(), // Allow any component type (function, class, forwardRef, etc.)\n  meta: segmentMetaSchema,\n  usage: segmentUsageSchema,\n  props: z.record(propDefinitionSchema),\n  relations: z.array(componentRelationSchema).optional(),\n  variants: z.array(segmentVariantSchema), // Allow empty variants array\n  contract: segmentContractSchema.optional(),\n  ai: aiMetadataSchema.optional(),\n  _generated: segmentGeneratedSchema.optional(),\n});\n\n/**\n * Config schema - validates required fields, passes through optional config objects.\n * Type definitions are in types.ts - schema just ensures basic structure.\n */\nexport const segmentsConfigSchema = z.object({\n  include: z.array(z.string()).min(1),\n  exclude: z.array(z.string()).optional(),\n  components: z.array(z.string()).optional(),\n  outFile: z.string().optional(),\n  framework: z.enum(['react', 'vue', 'svelte']).optional(),\n  figmaFile: z.string().url().optional(),\n  figmaToken: z.string().optional(),\n  screenshots: z.object({}).passthrough().optional(),\n  service: z.object({}).passthrough().optional(),\n  registry: z.object({}).passthrough().optional(),\n  tokens: z.object({\n    include: z.array(z.string()).min(1),\n  }).passthrough().optional(),\n});\n\n/**\n * @deprecated Use blockDefinitionSchema instead\n */\nexport const recipeDefinitionSchema = blockDefinitionSchema;\n"],"mappings":"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","names":[]}

package/dist/{chunk-U4GQ2JTD.js → chunk-D35RGPAG.js}

@@ -1,4 +1,4 @@
-import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
 import {
   BrowserPool,
   CaptureEngine,
@@ -8,7 +8,7 @@ import {
   formatMs,
   generateHtmlReport,
   getGrade
-} from "./chunk-IOJE35DZ.js";
+} from "./chunk-NWQ4CJOQ.js";
 import {
   discoverBlockFiles,
   discoverComponentFiles,
@@ -19,16 +19,16 @@ import {
   generateRegistry,
   loadSegmentFile,
   parseSegmentFile
-} from "./chunk-2H2JAA3U.js";
+} from "./chunk-SSLQXHNX.js";
 import {
   compileBlock,
   parseTokenFile
-} from "./chunk-V7YLRR4C.js";
+} from "./chunk-Q7GOHVOK.js";
 import {
   BRAND,
   DEFAULTS,
   segmentDefinitionSchema
-} from "./chunk-ICAIQ57V.js";
+} from "./chunk-6JBGU74P.js";
 
 // src/validators.ts
 async function validateSchema(config, configDir) {
@@ -120,8 +120,350 @@ async function validateAll(config, configDir) {
 
 // src/build.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { resolve, join } from "path";
-import { existsSync } from "fs";
+import { resolve as resolve2, join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+
+// src/core/auto-props.ts
+import { existsSync, statSync } from "fs";
+import { dirname, extname, join, resolve } from "path";
+import ts from "typescript";
+function toPosixPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function isFile(filePath) {
+  if (!existsSync(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`,
+      join(basePath, "index.tsx"),
+      join(basePath, "index.ts"),
+      join(basePath, "index.jsx"),
+      join(basePath, "index.js")
+    );
+  }
+  for (const candidate of candidates) {
+    if (isFile(candidate)) {
+      return resolve(candidate);
+    }
+  }
+  return null;
+}
+function resolveComponentSourcePath(segmentFileAbsolutePath, componentImportPath) {
+  if (!componentImportPath) return null;
+  if (!componentImportPath.startsWith(".")) return null;
+  const segmentDir = dirname(segmentFileAbsolutePath);
+  const basePath = resolve(segmentDir, 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 (ts.isInterfaceDeclaration(node)) {
+      typeDeclarations.set(node.name.text, node);
+      continue;
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      typeDeclarations.set(node.name.text, node);
+      continue;
+    }
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      functionDeclarations.set(node.name.text, node);
+      continue;
+    }
+    if (ts.isVariableStatement(node)) {
+      for (const declaration of node.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name)) {
+          variableDeclarations.set(declaration.name.text, declaration);
+        }
+      }
+    }
+  }
+  return { typeDeclarations, functionDeclarations, variableDeclarations };
+}
+function readDefaultValue(expression) {
+  if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts.isNumericLiteral(expression)) {
+    return Number(expression.text);
+  }
+  if (expression.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (expression.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (expression.kind === ts.SyntaxKind.NullKeyword) return null;
+  if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.MinusToken && ts.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 (!ts.isObjectBindingPattern(firstParam.name)) return defaults;
+  for (const element of firstParam.name.elements) {
+    let propName = null;
+    if (element.propertyName) {
+      if (ts.isIdentifier(element.propertyName) || ts.isStringLiteral(element.propertyName)) {
+        propName = element.propertyName.text;
+      }
+    } else if (ts.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 & ts.TypeFlags.Null) !== 0 || (type.flags & ts.TypeFlags.Undefined) !== 0 || (type.flags & ts.TypeFlags.Void) !== 0;
+}
+function isBooleanLikeType(type) {
+  return (type.flags & ts.TypeFlags.BooleanLike) !== 0 || type.flags === ts.TypeFlags.BooleanLiteral;
+}
+function inferPropType(type, checker) {
+  const typeText = checker.typeToString(type, void 0, ts.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 & ts.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 & ts.TypeFlags.StringLike) !== 0) {
+    return { type: "string" };
+  }
+  if ((type.flags & ts.TypeFlags.NumberLike) !== 0) {
+    return { type: "number" };
+  }
+  if ((type.flags & ts.TypeFlags.BooleanLike) !== 0) {
+    return { type: "boolean" };
+  }
+  if ((type.flags & ts.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 (ts.isParenthesizedExpression(expression)) {
+      return resolveFromExpression(expression.expression);
+    }
+    if (ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression)) {
+      return resolveFromExpression(expression.expression);
+    }
+    if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+      return typeNodeFromFunction(expression);
+    }
+    if (ts.isIdentifier(expression)) {
+      return resolveFromIdentifier(expression.text);
+    }
+    if (ts.isCallExpression(expression)) {
+      if (ts.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "forwardRef") {
+        const forwardRefPropsType = expression.typeArguments?.[1] ?? null;
+        const innerArg = expression.arguments[0];
+        const inner = innerArg && (ts.isArrowFunction(innerArg) || ts.isFunctionExpression(innerArg)) ? typeNodeFromFunction(innerArg) : innerArg && ts.isIdentifier(innerArg) ? resolveFromIdentifier(innerArg.text) : { propsTypeNode: null, componentNode: null };
+        return {
+          propsTypeNode: forwardRefPropsType ?? inner.propsTypeNode,
+          componentNode: inner.componentNode
+        };
+      }
+      if (ts.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "memo" && expression.arguments[0]) {
+        return resolveFromExpression(expression.arguments[0]);
+      }
+      if (ts.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 && ts.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 && (ts.isArrowFunction(declaration.initializer) || ts.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 = resolve(componentFilePath);
+  if (!existsSync(resolvedPath)) {
+    return {
+      props: {},
+      warnings: [`Component file not found: ${resolvedPath}`],
+      resolved: false
+    };
+  }
+  const compilerOptions = {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    jsx: ts.JsxEmit.ReactJSX,
+    allowSyntheticDefaultImports: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    strict: false,
+    noEmit: true
+  };
+  const program = ts.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 = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+    extractedProps[propName] = {
+      type: inferredType.type,
+      description,
+      required: (symbol.getFlags() & ts.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/build.ts
+function normalizeParsedProps(parsedProps) {
+  return Object.fromEntries(
+    Object.entries(parsedProps).map(([name, prop]) => [
+      name,
+      {
+        type: prop.type ?? "custom",
+        description: prop.description ?? "",
+        default: prop.default,
+        required: prop.required,
+        values: prop.values,
+        constraints: prop.constraints
+      }
+    ])
+  );
+}
+function mergeDocumentedAndAutoProps(documentedProps, autoProps) {
+  return Object.fromEntries(
+    Object.keys(autoProps).map((name) => {
+      const documented = documentedProps[name];
+      const auto = autoProps[name];
+      return [
+        name,
+        {
+          type: auto.type,
+          description: documented?.description ?? auto.description ?? "",
+          default: auto.default !== void 0 ? auto.default : documented?.default,
+          required: auto.required,
+          values: auto.values ?? documented?.values,
+          constraints: documented?.constraints
+        }
+      ];
+    })
+  );
+}
 async function buildSegments(config, configDir) {
   const files = await discoverSegmentFiles(config, configDir);
   const errors = [];
@@ -141,6 +483,53 @@ async function buildSegments(config, configDir) {
         });
         continue;
       }
+      const documentedProps = normalizeParsedProps(parsed.props);
+      let mergedProps = documentedProps;
+      const componentExportName = parsed.componentName ?? parsed.meta.name;
+      const componentSourcePath = resolveComponentSourcePath(
+        file.absolutePath,
+        parsed.componentImport
+      );
+      if (componentExportName && componentSourcePath) {
+        const autoPropsResult = extractCustomPropsFromComponentFile(
+          componentSourcePath,
+          componentExportName
+        );
+        for (const warning of autoPropsResult.warnings) {
+          warnings.push({ file: file.relativePath, warning });
+        }
+        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) {
+            warnings.push({
+              file: file.relativePath,
+              warning: `Removed ${removedDocumentedProps.length} documented props not present in source API: ${removedDocumentedProps.join(", ")}`
+            });
+          }
+          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({
+          file: file.relativePath,
+          warning: "Unable to resolve component export name for auto-props extraction"
+        });
+      } else if (!componentSourcePath) {
+        warnings.push({
+          file: file.relativePath,
+          warning: `Unable to resolve component source path from import: ${parsed.componentImport ?? "unknown"}`
+        });
+      }
       const compiled = {
         filePath: file.relativePath,
         meta: {
@@ -158,19 +547,7 @@ async function buildSegments(config, configDir) {
           guidelines: parsed.usage.guidelines,
           accessibility: parsed.usage.accessibility
         },
-        props: Object.fromEntries(
-          Object.entries(parsed.props).map(([name, prop]) => [
-            name,
-            {
-              type: prop.type ?? "custom",
-              description: prop.description ?? "",
-              default: prop.default,
-              required: prop.required,
-              values: prop.values,
-              constraints: prop.constraints
-            }
-          ])
-        ),
+        props: mergedProps,
         relations: parsed.relations.map((rel) => ({
           component: rel.component,
           relationship: rel.relationship,
@@ -248,8 +625,8 @@ async function buildSegments(config, configDir) {
   } catch {
   }
   let packageName;
-  const pkgJsonPath = resolve(configDir, "package.json");
-  if (existsSync(pkgJsonPath)) {
+  const pkgJsonPath = resolve2(configDir, "package.json");
+  if (existsSync2(pkgJsonPath)) {
     try {
       const pkg = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
       if (pkg.name) packageName = pkg.name;
@@ -264,7 +641,7 @@ async function buildSegments(config, configDir) {
     ...Object.keys(blocks).length > 0 && { blocks },
     ...tokens && { tokens }
   };
-  const outputPath = resolve(configDir, config.outFile ?? BRAND.outFile);
+  const outputPath = resolve2(configDir, config.outFile ?? BRAND.outFile);
   await writeFile(outputPath, JSON.stringify(output));
   return {
     success: errors.length === 0,
@@ -275,8 +652,8 @@ async function buildSegments(config, configDir) {
   };
 }
 async function buildFragmentsDir(config, configDir) {
-  const fragmentsDir = join(configDir, BRAND.dataDir);
-  const componentsDir = join(fragmentsDir, BRAND.componentsDir);
+  const fragmentsDir = join2(configDir, BRAND.dataDir);
+  const componentsDir = join2(fragmentsDir, BRAND.componentsDir);
   await mkdir(fragmentsDir, { recursive: true });
   await mkdir(componentsDir, { recursive: true });
   const registryResult = await generateRegistry({
@@ -288,9 +665,9 @@ async function buildFragmentsDir(config, configDir) {
   });
   const errors = [...registryResult.errors];
   const warnings = [...registryResult.warnings];
-  const indexPath = join(fragmentsDir, "index.json");
+  const indexPath = join2(fragmentsDir, "index.json");
   await writeFile(indexPath, JSON.stringify(registryResult.index, null, 2));
-  const registryPath = join(fragmentsDir, BRAND.registryFile);
+  const registryPath = join2(fragmentsDir, BRAND.registryFile);
   await writeFile(registryPath, JSON.stringify(registryResult.registry, null, 2));
   const contextResult = generateContextMd(registryResult.registry, {
     format: "markdown",
@@ -302,7 +679,7 @@ async function buildFragmentsDir(config, configDir) {
       code: false
     }
   });
-  const contextPath = join(fragmentsDir, BRAND.contextFile);
+  const contextPath = join2(fragmentsDir, BRAND.contextFile);
   await writeFile(contextPath, contextResult.content);
   return {
     success: errors.length === 0,
@@ -655,9 +1032,9 @@ ${BRAND.name} Diff
 }
 
 // src/analyze.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join2, dirname } from "path";
+import { join as join3, dirname as dirname2 } from "path";
 import pc3 from "picocolors";
 async function runAnalyzeCommand(config, configDir, options = {}) {
   const format = options.format ?? "html";
@@ -665,8 +1042,8 @@ async function runAnalyzeCommand(config, configDir, options = {}) {
   console.log(pc3.cyan(`
 ${BRAND.name} Analyzer
 `));
-  const segmentsPath = join2(configDir, config.outFile ?? "segments.json");
-  if (!existsSync2(segmentsPath)) {
+  const segmentsPath = join3(configDir, config.outFile ?? "segments.json");
+  if (!existsSync3(segmentsPath)) {
     console.log(pc3.red(`\u2717 No segments.json found. Run \`${BRAND.cliCommand} build\` first.
 `));
     return {
@@ -682,7 +1059,7 @@ ${BRAND.name} Analyzer
   let outputPath;
   if (format === "html" || format === "json") {
     outputPath = options.output ?? getDefaultOutputPath(format, configDir);
-    await mkdir2(dirname(outputPath), { recursive: true });
+    await mkdir2(dirname2(outputPath), { recursive: true });
     if (format === "html") {
       const html = generateHtmlReport(analytics);
       await writeFile2(outputPath, html);
@@ -761,7 +1138,7 @@ function colorizeScore(score) {
 }
 function getDefaultOutputPath(format, configDir) {
   const filename = format === "html" ? "segments-report.html" : "segments-report.json";
-  return join2(configDir, filename);
+  return join3(configDir, filename);
 }
 async function openInBrowser(path) {
   const { platform } = await import("os");
@@ -829,4 +1206,4 @@ export {
   runDiffCommand,
   runAnalyzeCommand
 };
-//# sourceMappingURL=chunk-U4GQ2JTD.js.map
+//# sourceMappingURL=chunk-D35RGPAG.js.map