@fragments-sdk/cli 0.14.3 → 0.15.0

package/dist/{chunk-APTQIBS5.js → chunk-XJQ5BIWI.js}

@@ -2,7 +2,10 @@ import { createRequire as __banner_createRequire } from 'module'; const require
 import {
   BRAND,
   DEFAULTS
-} from "./chunk-I34BC3CU.js";
+} from "./chunk-32LIWN2P.js";
+import {
+  BABEL_PARSER_OPTIONS
+} from "./chunk-7DZC4YEV.js";
 
 // src/service/browser-pool.ts
 var BrowserPool = class {
@@ -72,8 +75,8 @@ var BrowserPool = class {
     }
     await this.clearContext(context);
     if (this.waitingQueue.length > 0) {
-      const resolve5 = this.waitingQueue.shift();
-      resolve5(context);
+      const resolve4 = this.waitingQueue.shift();
+      resolve4(context);
       return;
     }
     this.available.push(context);
@@ -100,7 +103,7 @@ var BrowserPool = class {
       clearTimeout(this.idleTimeout);
       this.idleTimeout = null;
     }
-    for (const resolve5 of this.waitingQueue) {
+    for (const resolve4 of this.waitingQueue) {
     }
     this.waitingQueue = [];
     for (const context of this.contexts) {
@@ -187,9 +190,9 @@ var BrowserPool = class {
    * Wait for an available context.
    */
   waitForAvailable() {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve4, reject) => {
       const timeout = setTimeout(() => {
-        const index = this.waitingQueue.indexOf(resolve5);
+        const index = this.waitingQueue.indexOf(resolve4);
         if (index > -1) {
           this.waitingQueue.splice(index, 1);
         }
@@ -202,7 +205,7 @@ var BrowserPool = class {
       }, 3e4);
       const wrappedResolve = (ctx) => {
         clearTimeout(timeout);
-        resolve5(ctx);
+        resolve4(ctx);
       };
       this.waitingQueue.push(wrappedResolve);
     });
@@ -285,16 +288,16 @@ var Timer = class {
   }
 };
 function createDeferred() {
-  let resolve5;
+  let resolve4;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve5 = res;
+    resolve4 = res;
     reject = rej;
   });
-  return { promise, resolve: resolve5, reject };
+  return { promise, resolve: resolve4, reject };
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function bufferToBase64Url(buffer, mimeType = "image/png") {
   return `data:${mimeType};base64,${buffer.toString("base64")}`;
@@ -450,7 +453,7 @@ var CaptureEngine = class {
       await page.evaluate(async (timeoutMs) => {
         await Promise.race([
           document.fonts.ready,
-          new Promise((resolve5) => setTimeout(resolve5, timeoutMs))
+          new Promise((resolve4) => setTimeout(resolve4, timeoutMs))
         ]);
       }, timeout);
     } catch {
@@ -3116,7 +3119,7 @@ var TokenRegistryManager = class {
     }
     if (theme) {
       candidates = candidates.filter(
-        (t5) => t5.theme === theme || t5.theme === "default"
+        (t4) => t4.theme === theme || t4.theme === "default"
       );
     }
     if (isColor) {
@@ -3633,28 +3636,11 @@ import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
 import generate from "@babel/generator";
 import * as t from "@babel/types";
-var PARSER_OPTIONS = {
-  sourceType: "module",
-  plugins: [
-    "jsx",
-    "typescript",
-    ["decorators", { decoratorsBeforeExport: true }],
-    "classProperties",
-    "classPrivateProperties",
-    "classPrivateMethods",
-    "exportDefaultFrom",
-    "exportNamespaceFrom",
-    "dynamicImport",
-    "nullishCoalescingOperator",
-    "optionalChaining",
-    "objectRestSpread"
-  ]
-};
 function extractStyleLocations(sourceCode, filePath) {
   const locations = [];
   let ast;
   try {
-    ast = parse(sourceCode, PARSER_OPTIONS);
+    ast = parse(sourceCode, BABEL_PARSER_OPTIONS);
   } catch (error) {
     console.error(`Failed to parse ${filePath}:`, error);
     return locations;
@@ -3760,7 +3746,7 @@ function extractFromTemplateLiteral(template, path, filePath, type, locations) {
 function applyPatch(sourceCode, styleLocation, oldValue, newValue) {
   let ast;
   try {
-    ast = parse(sourceCode, PARSER_OPTIONS);
+    ast = parse(sourceCode, BABEL_PARSER_OPTIONS);
   } catch (error) {
     return {
       success: false,
@@ -4042,907 +4028,22 @@ function createMetricsStore(projectRoot) {
   return new MetricsStore(projectRoot);
 }
 
-// src/service/enhance/scanner.ts
+// src/service/enhance/doc-extractor.ts
 import { parse as parse2 } from "@babel/parser";
 import _traverse from "@babel/traverse";
 import * as t2 from "@babel/types";
 import { readFile as readFile4 } from "fs/promises";
-var traverse2 = _traverse.default || _traverse;
-var PARSER_OPTIONS2 = {
-  sourceType: "module",
-  plugins: [
-    "jsx",
-    "typescript",
-    ["decorators", { decoratorsBeforeExport: true }],
-    "classProperties",
-    "classPrivateProperties",
-    "classPrivateMethods",
-    "exportDefaultFrom",
-    "exportNamespaceFrom",
-    "dynamicImport",
-    "nullishCoalescingOperator",
-    "optionalChaining",
-    "objectRestSpread"
-  ]
-};
-async function scanFileForImports(filePath) {
-  const imports = [];
-  try {
-    const sourceCode = await readFile4(filePath, "utf-8");
-    const ast = parse2(sourceCode, PARSER_OPTIONS2);
-    traverse2(ast, {
-      ImportDeclaration(path) {
-        const source = path.node.source.value;
-        const line = path.node.loc?.start.line ?? 0;
-        for (const specifier of path.node.specifiers) {
-          if (t2.isImportSpecifier(specifier)) {
-            const importedName = t2.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
-            const localName = specifier.local.name;
-            if (isPascalCase(importedName)) {
-              imports.push({
-                componentName: importedName,
-                localName,
-                source,
-                isDefault: false,
-                filePath,
-                line
-              });
-            }
-          } else if (t2.isImportDefaultSpecifier(specifier)) {
-            const localName = specifier.local.name;
-            if (isPascalCase(localName)) {
-              imports.push({
-                componentName: localName,
-                localName,
-                source,
-                isDefault: true,
-                filePath,
-                line
-              });
-            }
-          }
-        }
-      }
-    });
-  } catch (error) {
-    console.warn(`Failed to parse ${filePath}:`, error.message);
-    return [];
-  }
-  return imports;
-}
-async function scanFileForUsages(filePath, componentNames) {
-  const usages = [];
-  try {
-    const sourceCode = await readFile4(filePath, "utf-8");
-    const lines = sourceCode.split("\n");
-    const ast = parse2(sourceCode, PARSER_OPTIONS2);
-    traverse2(ast, {
-      JSXOpeningElement(path) {
-        const elementName = getJSXElementName(path.node.name);
-        if (!elementName) return;
-        const componentName = componentNames.get(elementName);
-        if (!componentName) return;
-        const loc = path.node.loc;
-        if (!loc) return;
-        const props = extractProps(path.node.attributes);
-        const contextLines = getContextLines(lines, loc.start.line - 1, 3);
-        const isConditional = checkIfConditional(path);
-        const parentElement = getParentElementName(path);
-        usages.push({
-          componentName,
-          filePath,
-          line: loc.start.line,
-          column: loc.start.column,
-          props,
-          context: contextLines,
-          parentElement,
-          hasSpreadProps: props.spreads.length > 0,
-          isConditional
-        });
-      }
-    });
-  } catch (error) {
-    console.warn(`Failed to parse ${filePath}:`, error.message);
-    return [];
-  }
-  return usages;
-}
-async function scanFile(filePath, trackedComponents) {
-  const imports = [];
-  const usages = [];
-  try {
-    const sourceCode = await readFile4(filePath, "utf-8");
-    const lines = sourceCode.split("\n");
-    const ast = parse2(sourceCode, PARSER_OPTIONS2);
-    const localToComponent = /* @__PURE__ */ new Map();
-    traverse2(ast, {
-      ImportDeclaration(path) {
-        const source = path.node.source.value;
-        const line = path.node.loc?.start.line ?? 0;
-        for (const specifier of path.node.specifiers) {
-          if (t2.isImportSpecifier(specifier)) {
-            const importedName = t2.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
-            const localName = specifier.local.name;
-            if (isPascalCase(importedName)) {
-              if (!trackedComponents || trackedComponents.has(importedName)) {
-                imports.push({
-                  componentName: importedName,
-                  localName,
-                  source,
-                  isDefault: false,
-                  filePath,
-                  line
-                });
-                localToComponent.set(localName, importedName);
-              }
-            }
-          } else if (t2.isImportDefaultSpecifier(specifier)) {
-            const localName = specifier.local.name;
-            if (isPascalCase(localName)) {
-              if (!trackedComponents || trackedComponents.has(localName)) {
-                imports.push({
-                  componentName: localName,
-                  localName,
-                  source,
-                  isDefault: true,
-                  filePath,
-                  line
-                });
-                localToComponent.set(localName, localName);
-              }
-            }
-          }
-        }
-      },
-      JSXOpeningElement(path) {
-        const elementName = getJSXElementName(path.node.name);
-        if (!elementName) return;
-        const componentName = localToComponent.get(elementName);
-        if (!componentName) return;
-        const loc = path.node.loc;
-        if (!loc) return;
-        const props = extractProps(path.node.attributes);
-        const contextLines = getContextLines(lines, loc.start.line - 1, 3);
-        const isConditional = checkIfConditional(path);
-        const parentElement = getParentElementName(path);
-        usages.push({
-          componentName,
-          filePath,
-          line: loc.start.line,
-          column: loc.start.column,
-          props,
-          context: contextLines,
-          parentElement,
-          hasSpreadProps: props.spreads.length > 0,
-          isConditional
-        });
-      }
-    });
-  } catch (error) {
-    console.warn(`Failed to parse ${filePath}:`, error.message);
-    return { imports: [], usages: [] };
-  }
-  return { imports, usages };
-}
-function isPascalCase(str) {
-  return /^[A-Z][a-zA-Z0-9]*$/.test(str);
-}
-function getJSXElementName(name) {
-  if (t2.isJSXIdentifier(name)) {
-    return name.name;
-  }
-  if (t2.isJSXMemberExpression(name)) {
-    const parts = [];
-    let current = name;
-    while (t2.isJSXMemberExpression(current)) {
-      parts.unshift(current.property.name);
-      current = current.object;
-    }
-    if (t2.isJSXIdentifier(current)) {
-      parts.unshift(current.name);
-    }
-    return parts.join(".");
-  }
-  return null;
-}
-function extractProps(attributes) {
-  const result = {
-    static: {},
-    dynamic: [],
-    spreads: []
-  };
-  for (const attr of attributes) {
-    if (t2.isJSXSpreadAttribute(attr)) {
-      if (t2.isIdentifier(attr.argument)) {
-        result.spreads.push(attr.argument.name);
-      } else {
-        result.spreads.push("(expression)");
-      }
-    } else if (t2.isJSXAttribute(attr)) {
-      const propName = t2.isJSXIdentifier(attr.name) ? attr.name.name : `${attr.name.namespace.name}:${attr.name.name.name}`;
-      const value = attr.value;
-      if (value === null) {
-        result.static[propName] = true;
-      } else if (t2.isStringLiteral(value)) {
-        result.static[propName] = value.value;
-      } else if (t2.isJSXExpressionContainer(value)) {
-        const expr = value.expression;
-        if (t2.isStringLiteral(expr)) {
-          result.static[propName] = expr.value;
-        } else if (t2.isNumericLiteral(expr)) {
-          result.static[propName] = expr.value;
-        } else if (t2.isBooleanLiteral(expr)) {
-          result.static[propName] = expr.value;
-        } else if (t2.isTemplateLiteral(expr) && expr.expressions.length === 0) {
-          result.static[propName] = expr.quasis.map((q) => q.value.raw).join("");
-        } else {
-          result.dynamic.push(propName);
-        }
-      }
-    }
-  }
-  return result;
-}
-function getContextLines(lines, centerLine, radius) {
-  const start = Math.max(0, centerLine - radius);
-  const end = Math.min(lines.length, centerLine + radius + 1);
-  return lines.slice(start, end).join("\n");
-}
-function checkIfConditional(path) {
-  let current = path.parentPath;
-  while (current) {
-    if (current.isLogicalExpression() && current.node.operator === "&&") {
-      return true;
-    }
-    if (current.isConditionalExpression()) {
-      return true;
-    }
-    if (current.isJSXExpressionContainer() && current.parentPath?.isJSXElement()) {
-      const expr = current.node.expression;
-      if (t2.isLogicalExpression(expr) || t2.isConditionalExpression(expr)) {
-        return true;
-      }
-    }
-    current = current.parentPath;
-  }
-  return false;
-}
-function getParentElementName(path) {
-  let current = path.parentPath;
-  const currentElementName = getJSXElementName(path.node.name);
-  while (current) {
-    if (current.isJSXElement()) {
-      const opening = current.node.openingElement;
-      const name = getJSXElementName(opening.name);
-      if (name && name !== currentElementName) {
-        return name;
-      }
-    }
-    current = current.parentPath;
-  }
-  return void 0;
-}
-
-// src/service/enhance/aggregator.ts
-function aggregateComponentUsages(componentName, sourceFile, usages, imports) {
-  const uniqueFiles = new Set(usages.map((u) => u.filePath));
-  const patternMap = /* @__PURE__ */ new Map();
-  for (const usage of usages) {
-    const propKey = createPropKey(usage.props.static);
-    const existing = patternMap.get(propKey);
-    if (existing) {
-      existing.count++;
-      if (!existing.files.includes(usage.filePath)) {
-        existing.files.push(usage.filePath);
-      }
-      if (existing.sampleContexts.length < 3) {
-        existing.sampleContexts.push(usage.context);
-      }
-    } else {
-      patternMap.set(propKey, {
-        props: { ...usage.props.static },
-        count: 1,
-        files: [usage.filePath],
-        sampleContexts: [usage.context]
-      });
-    }
-  }
-  const patterns = Array.from(patternMap.values()).sort(
-    (a, b) => b.count - a.count
-  );
-  const contextMap = /* @__PURE__ */ new Map();
-  for (const usage of usages) {
-    const context = classifyFileContext(usage.filePath, usage.context);
-    const existing = contextMap.get(context);
-    if (existing) {
-      existing.count++;
-      if (!existing.files.includes(usage.filePath)) {
-        existing.files.push(usage.filePath);
-      }
-    } else {
-      contextMap.set(context, { count: 1, files: [usage.filePath] });
-    }
-  }
-  const contexts = Array.from(contextMap.entries()).map(([type, data]) => ({ type, ...data })).sort((a, b) => b.count - a.count);
-  return {
-    name: componentName,
-    sourceFile,
-    totalUsages: usages.length,
-    uniqueFiles: uniqueFiles.size,
-    patterns,
-    contexts,
-    usages,
-    imports
-  };
-}
-function aggregateAllUsages(usages, imports, componentSources) {
-  const usagesByComponent = /* @__PURE__ */ new Map();
-  for (const usage of usages) {
-    const existing = usagesByComponent.get(usage.componentName) ?? [];
-    existing.push(usage);
-    usagesByComponent.set(usage.componentName, existing);
-  }
-  const importsByComponent = /* @__PURE__ */ new Map();
-  for (const imp of imports) {
-    const existing = importsByComponent.get(imp.componentName) ?? [];
-    existing.push(imp);
-    importsByComponent.set(imp.componentName, existing);
-  }
-  const components = {};
-  const allComponentNames = /* @__PURE__ */ new Set([
-    ...usagesByComponent.keys(),
-    ...importsByComponent.keys()
-  ]);
-  for (const componentName of allComponentNames) {
-    const componentUsages = usagesByComponent.get(componentName) ?? [];
-    const componentImports = importsByComponent.get(componentName) ?? [];
-    const sourceFile = componentSources.get(componentName) ?? "unknown";
-    components[componentName] = aggregateComponentUsages(
-      componentName,
-      sourceFile,
-      componentUsages,
-      componentImports
-    );
-  }
-  const allFiles = /* @__PURE__ */ new Set();
-  for (const usage of usages) {
-    allFiles.add(usage.filePath);
-  }
-  for (const imp of imports) {
-    allFiles.add(imp.filePath);
-  }
-  return {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    rootDir: "",
-    // Will be set by caller
-    totalFiles: allFiles.size,
-    totalComponents: Object.keys(components).length,
-    components,
-    errorFiles: []
-    // Will be populated by scanner
-  };
-}
-function createPropKey(props) {
-  const entries = Object.entries(props).sort(([a], [b]) => a.localeCompare(b));
-  return entries.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join("|");
-}
-function classifyFileContext(filePath, context) {
-  const lowerPath = filePath.toLowerCase();
-  const lowerContext = context.toLowerCase();
-  if (lowerPath.includes("/modal") || lowerPath.includes("modal.") || lowerContext.includes("<modal")) {
-    return "modal";
-  }
-  if (lowerPath.includes("/dialog") || lowerPath.includes("dialog.") || lowerContext.includes("<dialog")) {
-    return "dialog";
-  }
-  if (lowerPath.includes("/form") || lowerPath.includes("form.") || lowerContext.includes("<form") || lowerContext.includes("onsubmit")) {
-    return "form";
-  }
-  if (lowerPath.includes("/page") || lowerPath.includes("pages/") || lowerPath.includes("/routes/")) {
-    return "page";
-  }
-  if (lowerPath.includes("/layout") || lowerPath.includes("layout.") || lowerPath.includes("/layouts/")) {
-    return "layout";
-  }
-  if (lowerPath.includes("/card") || lowerPath.includes("card.") || lowerContext.includes("<card")) {
-    return "card";
-  }
-  if (lowerPath.includes("/table") || lowerPath.includes("table.") || lowerContext.includes("<table") || lowerContext.includes("<tr")) {
-    return "table";
-  }
-  if (lowerPath.includes("/list") || lowerPath.includes("list.") || lowerContext.includes("<ul") || lowerContext.includes("<ol") || lowerContext.includes("<li")) {
-    return "list";
-  }
-  if (lowerPath.includes("/nav") || lowerPath.includes("navigation") || lowerContext.includes("<nav")) {
-    return "navigation";
-  }
-  if (lowerPath.includes("/header") || lowerPath.includes("header.") || lowerContext.includes("<header")) {
-    return "header";
-  }
-  if (lowerPath.includes("/footer") || lowerPath.includes("footer.") || lowerContext.includes("<footer")) {
-    return "footer";
-  }
-  if (lowerPath.includes("/sidebar") || lowerPath.includes("sidebar.") || lowerContext.includes("<aside")) {
-    return "sidebar";
-  }
-  return "unknown";
-}
-function findCommonPropCombinations(usages, minOccurrences = 3) {
-  const combinations = /* @__PURE__ */ new Map();
-  for (const usage of usages) {
-    const allProps = [
-      ...Object.keys(usage.props.static),
-      ...usage.props.dynamic
-    ].sort();
-    for (let size = 2; size <= Math.min(allProps.length, 4); size++) {
-      for (const combo of combinations_k(allProps, size)) {
-        const key = combo.join(",");
-        combinations.set(key, (combinations.get(key) ?? 0) + 1);
-      }
-    }
-  }
-  return Array.from(combinations.entries()).filter(([, count]) => count >= minOccurrences).map(([key, count]) => ({ props: key.split(","), count })).sort((a, b) => b.count - a.count);
-}
-function* combinations_k(arr, k) {
-  if (k === 0) {
-    yield [];
-    return;
-  }
-  if (arr.length < k) return;
-  for (let i = 0; i <= arr.length - k; i++) {
-    for (const combo of combinations_k(arr.slice(i + 1), k - 1)) {
-      yield [arr[i], ...combo];
-    }
-  }
-}
-function inferRelations(componentName, analysis, allAnalyses) {
-  const relations = [];
-  const parentCounts = /* @__PURE__ */ new Map();
-  const siblingCounts = /* @__PURE__ */ new Map();
-  for (const usage of analysis.usages) {
-    if (usage.parentElement && usage.parentElement !== "div" && usage.parentElement !== "span") {
-      const parent = usage.parentElement;
-      const existing = parentCounts.get(parent);
-      if (existing) {
-        existing.count++;
-        if (!existing.files.includes(usage.filePath)) {
-          existing.files.push(usage.filePath);
-        }
-      } else {
-        parentCounts.set(parent, { count: 1, files: [usage.filePath] });
-      }
-    }
-  }
-  const filesWithThisComponent = new Set(analysis.usages.map((u) => u.filePath));
-  for (const [otherName, otherAnalysis] of Object.entries(allAnalyses)) {
-    if (otherName === componentName) continue;
-    let sharedFiles = 0;
-    const sharedFileList = [];
-    for (const usage of otherAnalysis.usages) {
-      if (filesWithThisComponent.has(usage.filePath)) {
-        if (!sharedFileList.includes(usage.filePath)) {
-          sharedFiles++;
-          sharedFileList.push(usage.filePath);
-        }
-      }
-    }
-    if (sharedFiles >= 3) {
-      siblingCounts.set(otherName, {
-        count: sharedFiles,
-        files: sharedFileList.slice(0, 5)
-      });
-    }
-  }
-  for (const [parent, data] of parentCounts) {
-    if (data.count >= 2) {
-      relations.push({
-        component: parent,
-        relationship: "parent",
-        frequency: data.count,
-        sampleFiles: data.files.slice(0, 3)
-      });
-    }
-  }
-  for (const [sibling, data] of siblingCounts) {
-    relations.push({
-      component: sibling,
-      relationship: "sibling",
-      frequency: data.count,
-      sampleFiles: data.files.slice(0, 3)
-    });
-  }
-  relations.sort((a, b) => b.frequency - a.frequency);
-  return relations;
-}
-function inferAllRelations(analysis) {
-  const allRelations = /* @__PURE__ */ new Map();
-  for (const [componentName, componentAnalysis] of Object.entries(analysis.components)) {
-    const relations = inferRelations(componentName, componentAnalysis, analysis.components);
-    if (relations.length > 0) {
-      allRelations.set(componentName, relations);
-    }
-  }
-  return allRelations;
-}
-function summarizePatternsForPrompt(analysis, maxPatterns = 10, maxContexts = 5) {
-  const lines = [];
-  lines.push(`## ${analysis.name}`);
-  lines.push(`Total usages: ${analysis.totalUsages} across ${analysis.uniqueFiles} files`);
-  lines.push("");
-  lines.push("### Usage Patterns (by frequency)");
-  const topPatterns = analysis.patterns.slice(0, maxPatterns);
-  for (const pattern of topPatterns) {
-    const propsStr = Object.entries(pattern.props).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
-    lines.push(`- ${propsStr || "(no props)"}: ${pattern.count} usages in ${pattern.files.length} files`);
-  }
-  lines.push("");
-  lines.push("### File Contexts");
-  const topContexts = analysis.contexts.slice(0, maxContexts);
-  for (const ctx of topContexts) {
-    lines.push(`- ${ctx.type}: ${ctx.count} usages`);
-  }
-  lines.push("");
-  lines.push("### Sample Usages");
-  for (const pattern of topPatterns.slice(0, 3)) {
-    if (pattern.sampleContexts[0]) {
-      lines.push("```tsx");
-      lines.push(pattern.sampleContexts[0].trim());
-      lines.push("```");
-      lines.push("");
-    }
-  }
-  return lines.join("\n");
-}
-
-// src/service/enhance/cache.ts
-import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { createHash as createHash2 } from "crypto";
-import { join as join3, dirname as dirname3 } from "path";
-import { mkdir as mkdir3 } from "fs/promises";
-var CURRENT_CACHE_VERSION = 1;
-var CACHE_FILENAME = "analysis-cache.json";
-function getCachePath(rootDir) {
-  return join3(rootDir, ".fragments", CACHE_FILENAME);
-}
-async function loadCache(rootDir) {
-  const cachePath = getCachePath(rootDir);
-  if (!existsSync2(cachePath)) {
-    return null;
-  }
-  try {
-    const content = await readFile5(cachePath, "utf-8");
-    const cache = JSON.parse(content);
-    if (cache.version !== CURRENT_CACHE_VERSION) {
-      console.warn(
-        `Cache version mismatch: expected ${CURRENT_CACHE_VERSION}, got ${cache.version}. Invalidating cache.`
-      );
-      return null;
-    }
-    if (cache.rootDir !== rootDir) {
-      console.warn(`Cache root mismatch. Invalidating cache.`);
-      return null;
-    }
-    return cache;
-  } catch (error) {
-    console.warn(`Failed to load cache: ${error.message}`);
-    return null;
-  }
-}
-async function saveCache(rootDir, cache) {
-  const cachePath = getCachePath(rootDir);
-  const cacheDir = dirname3(cachePath);
-  if (!existsSync2(cacheDir)) {
-    await mkdir3(cacheDir, { recursive: true });
-  }
-  cache.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile3(cachePath, JSON.stringify(cache, null, 2));
-}
-function createEmptyCache(rootDir) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    version: CURRENT_CACHE_VERSION,
-    createdAt: now,
-    updatedAt: now,
-    rootDir,
-    files: {}
-  };
-}
-function computeFileHash(content) {
-  return createHash2("md5").update(content).digest("hex");
-}
-function getCachedFile(cache, filePath) {
-  return cache.files[filePath] ?? null;
-}
-function updateCacheFile(cache, filePath, hash, imports, usages) {
-  cache.files[filePath] = {
-    hash,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    imports,
-    usages
-  };
-}
-function removeCacheFile(cache, filePath) {
-  delete cache.files[filePath];
-}
-async function detectFileChanges(cache, currentFiles, getFileHash) {
-  const changes = {
-    added: [],
-    modified: [],
-    deleted: [],
-    unchanged: []
-  };
-  const currentFileSet = new Set(currentFiles);
-  const cachedFileSet = new Set(Object.keys(cache.files));
-  for (const filePath of currentFiles) {
-    const entry = cache.files[filePath];
-    if (!entry) {
-      changes.added.push(filePath);
-    } else {
-      const currentHash = await getFileHash(filePath);
-      if (currentHash !== entry.hash) {
-        changes.modified.push(filePath);
-      } else {
-        changes.unchanged.push(filePath);
-      }
-    }
-  }
-  for (const cachedFile of cachedFileSet) {
-    if (!currentFileSet.has(cachedFile)) {
-      changes.deleted.push(cachedFile);
-    }
-  }
-  return changes;
-}
-function getCacheStats(cache) {
-  let totalImports = 0;
-  let totalUsages = 0;
-  for (const entry of Object.values(cache.files)) {
-    totalImports += entry.imports.length;
-    totalUsages += entry.usages.length;
-  }
-  const ageMs = Date.now() - new Date(cache.updatedAt).getTime();
-  const ageMinutes = Math.round(ageMs / 6e4);
-  const cacheAge = ageMinutes < 60 ? `${ageMinutes} minutes ago` : ageMinutes < 1440 ? `${Math.round(ageMinutes / 60)} hours ago` : `${Math.round(ageMinutes / 1440)} days ago`;
-  return {
-    totalFiles: Object.keys(cache.files).length,
-    totalImports,
-    totalUsages,
-    cacheAge
-  };
-}
-
-// src/service/enhance/codebase-scanner.ts
-import fg from "fast-glob";
-import { readFile as readFile6 } from "fs/promises";
-import { relative as relative2, resolve as resolve3, dirname as dirname4 } from "path";
-var DEFAULT_INCLUDE = [
-  "**/*.tsx",
-  "**/*.ts",
-  "**/*.jsx",
-  "**/*.js"
-];
-var DEFAULT_EXCLUDE = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/build/**",
-  "**/.next/**",
-  "**/coverage/**",
-  "**/__tests__/**",
-  "**/*.test.*",
-  "**/*.spec.*",
-  "**/*.stories.*",
-  "**/*.fragment.*",
-  "**/storybook-static/**"
-];
-async function scanCodebase(options) {
-  const {
-    rootDir,
-    include = DEFAULT_INCLUDE,
-    exclude = DEFAULT_EXCLUDE,
-    componentNames,
-    useCache = true,
-    onProgress
-  } = options;
-  const absoluteRoot = resolve3(rootDir);
-  let cache = null;
-  if (useCache) {
-    cache = await loadCache(absoluteRoot);
-  }
-  if (!cache) {
-    cache = createEmptyCache(absoluteRoot);
-  }
-  onProgress?.({
-    current: 0,
-    total: 0,
-    currentFile: "",
-    phase: "discovering"
-  });
-  const files = await fg(include, {
-    cwd: absoluteRoot,
-    ignore: exclude,
-    absolute: true,
-    onlyFiles: true
-  });
-  const totalFiles = files.length;
-  const trackedComponents = componentNames ? new Set(componentNames) : void 0;
-  const allImports = [];
-  const allUsages = [];
-  const errorFiles = [];
-  const componentSources = /* @__PURE__ */ new Map();
-  for (let i = 0; i < files.length; i++) {
-    const filePath = files[i];
-    const relativePath = relative2(absoluteRoot, filePath);
-    onProgress?.({
-      current: i + 1,
-      total: totalFiles,
-      currentFile: relativePath,
-      phase: "scanning"
-    });
-    try {
-      const content = await readFile6(filePath, "utf-8");
-      const fileHash = computeFileHash(content);
-      const cachedEntry = getCachedFile(cache, filePath);
-      if (cachedEntry && cachedEntry.hash === fileHash) {
-        allImports.push(...cachedEntry.imports);
-        allUsages.push(...cachedEntry.usages);
-        for (const imp of cachedEntry.imports) {
-          if (!componentSources.has(imp.componentName)) {
-            const sourceFile = resolveImportSource(filePath, imp.source);
-            if (sourceFile) {
-              componentSources.set(imp.componentName, sourceFile);
-            }
-          }
-        }
-        continue;
-      }
-      const { imports, usages } = await scanFile(filePath, trackedComponents);
-      updateCacheFile(cache, filePath, fileHash, imports, usages);
-      allImports.push(...imports);
-      allUsages.push(...usages);
-      for (const imp of imports) {
-        if (!componentSources.has(imp.componentName)) {
-          const sourceFile = resolveImportSource(filePath, imp.source);
-          if (sourceFile) {
-            componentSources.set(imp.componentName, sourceFile);
-          }
-        }
-      }
-    } catch (error) {
-      errorFiles.push(relativePath);
-      console.warn(`Error scanning ${relativePath}:`, error.message);
-    }
-  }
-  if (useCache) {
-    await saveCache(absoluteRoot, cache);
-  }
-  onProgress?.({
-    current: totalFiles,
-    total: totalFiles,
-    currentFile: "",
-    phase: "aggregating"
-  });
-  const analysis = aggregateAllUsages(allUsages, allImports, componentSources);
-  analysis.rootDir = absoluteRoot;
-  analysis.totalFiles = totalFiles;
-  analysis.errorFiles = errorFiles;
-  return analysis;
-}
-async function incrementalScan(rootDir, changes, existingCache, onProgress) {
-  const absoluteRoot = resolve3(rootDir);
-  const cache = { ...existingCache, files: { ...existingCache.files } };
-  for (const filePath of changes.deleted) {
-    removeCacheFile(cache, filePath);
-  }
-  const filesToScan = [...changes.added, ...changes.modified];
-  const totalFiles = filesToScan.length;
-  const allImports = [];
-  const allUsages = [];
-  const errorFiles = [];
-  const componentSources = /* @__PURE__ */ new Map();
-  for (const filePath of changes.unchanged) {
-    const cachedEntry = getCachedFile(cache, filePath);
-    if (cachedEntry) {
-      allImports.push(...cachedEntry.imports);
-      allUsages.push(...cachedEntry.usages);
-      for (const imp of cachedEntry.imports) {
-        if (!componentSources.has(imp.componentName)) {
-          const sourceFile = resolveImportSource(filePath, imp.source);
-          if (sourceFile) {
-            componentSources.set(imp.componentName, sourceFile);
-          }
-        }
-      }
-    }
-  }
-  for (let i = 0; i < filesToScan.length; i++) {
-    const filePath = filesToScan[i];
-    const relativePath = relative2(absoluteRoot, filePath);
-    onProgress?.({
-      current: i + 1,
-      total: totalFiles,
-      currentFile: relativePath,
-      phase: "scanning"
-    });
-    try {
-      const content = await readFile6(filePath, "utf-8");
-      const fileHash = computeFileHash(content);
-      const { imports, usages } = await scanFile(filePath);
-      updateCacheFile(cache, filePath, fileHash, imports, usages);
-      allImports.push(...imports);
-      allUsages.push(...usages);
-      for (const imp of imports) {
-        if (!componentSources.has(imp.componentName)) {
-          const sourceFile = resolveImportSource(filePath, imp.source);
-          if (sourceFile) {
-            componentSources.set(imp.componentName, sourceFile);
-          }
-        }
-      }
-    } catch (error) {
-      errorFiles.push(relativePath);
-    }
-  }
-  await saveCache(absoluteRoot, cache);
-  const analysis = aggregateAllUsages(allUsages, allImports, componentSources);
-  analysis.rootDir = absoluteRoot;
-  analysis.totalFiles = changes.unchanged.length + filesToScan.length;
-  analysis.errorFiles = errorFiles;
-  return { analysis, cache };
-}
-function resolveImportSource(importingFile, source) {
-  if (!source.startsWith(".") && !source.startsWith("/")) {
-    return null;
-  }
-  const importDir = dirname4(importingFile);
-  const extensions = ["", ".tsx", ".ts", ".jsx", ".js", "/index.tsx", "/index.ts"];
-  for (const ext of extensions) {
-    const fullPath = resolve3(importDir, source + ext);
-    if (ext === "" && source.endsWith(".tsx")) {
-      return fullPath;
-    }
-    if (ext) {
-      return resolve3(importDir, source) + ext;
-    }
-  }
-  return resolve3(importDir, source);
-}
-function getScanStats(analysis) {
-  const totalUsages = Object.values(analysis.components).reduce(
-    (sum, c) => sum + c.totalUsages,
-    0
-  );
-  const topComponents = Object.values(analysis.components).map((c) => ({ name: c.name, usages: c.totalUsages })).sort((a, b) => b.usages - a.usages).slice(0, 10);
-  return {
-    totalFiles: analysis.totalFiles,
-    totalComponents: analysis.totalComponents,
-    totalUsages,
-    topComponents
-  };
-}
-async function hasCachedAnalysis(rootDir) {
-  const cache = await loadCache(resolve3(rootDir));
-  if (!cache) return false;
-  const stats = getCacheStats(cache);
-  return stats.totalFiles > 0;
-}
-
-// src/service/enhance/doc-extractor.ts
-import { parse as parse3 } from "@babel/parser";
-import _traverse2 from "@babel/traverse";
-import * as t3 from "@babel/types";
-import { readFile as readFile7 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { basename as basename2, dirname as dirname5, join as join4 } from "path";
-var traverse3 = _traverse2.default || _traverse2;
+import { basename, dirname as dirname3, join as join3 } from "path";
+var traverse2 = _traverse.default || _traverse;
 async function extractComponentDocs(filePath) {
-  const content = await readFile7(filePath, "utf-8");
+  const content = await readFile4(filePath, "utf-8");
   return extractDocsFromSource(content, filePath);
 }
 function extractDocsFromSource(source, filePath) {
   const isTypeScript = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
   const isJSX = filePath.endsWith(".tsx") || filePath.endsWith(".jsx");
-  const ast = parse3(source, {
+  const ast = parse2(source, {
     sourceType: "module",
     plugins: [
       ...isTypeScript ? ["typescript"] : [],
@@ -4959,7 +4060,7 @@ function extractDocsFromSource(source, filePath) {
     tags: {}
   };
   let mainExportComment;
-  traverse3(ast, {
+  traverse2(ast, {
     // Extract JSDoc from function declarations
     FunctionDeclaration(path) {
       const leadingComments = path.node.leadingComments;
@@ -5095,7 +4196,7 @@ function processTag(docs, tag, content) {
 function extractPropsFromInterface(node) {
   const props = [];
   for (const member of node.body.body) {
-    if (t3.isTSPropertySignature(member) && t3.isIdentifier(member.key)) {
+    if (t2.isTSPropertySignature(member) && t2.isIdentifier(member.key)) {
       const name = member.key.name;
       const type = member.typeAnnotation ? typeAnnotationToString(member.typeAnnotation.typeAnnotation) : "unknown";
       const required = !member.optional;
@@ -5115,9 +4216,9 @@ function extractPropsFromInterface(node) {
 }
 function extractPropsFromTypeAlias(node) {
   const props = [];
-  if (t3.isTSTypeLiteral(node.typeAnnotation)) {
+  if (t2.isTSTypeLiteral(node.typeAnnotation)) {
     for (const member of node.typeAnnotation.members) {
-      if (t3.isTSPropertySignature(member) && t3.isIdentifier(member.key)) {
+      if (t2.isTSPropertySignature(member) && t2.isIdentifier(member.key)) {
         const name = member.key.name;
         const type = member.typeAnnotation ? typeAnnotationToString(member.typeAnnotation.typeAnnotation) : "unknown";
         const required = !member.optional;
@@ -5133,23 +4234,23 @@ function extractPropsFromTypeAlias(node) {
   return props;
 }
 function typeAnnotationToString(node) {
-  if (t3.isTSStringKeyword(node)) return "string";
-  if (t3.isTSNumberKeyword(node)) return "number";
-  if (t3.isTSBooleanKeyword(node)) return "boolean";
-  if (t3.isTSNullKeyword(node)) return "null";
-  if (t3.isTSUndefinedKeyword(node)) return "undefined";
-  if (t3.isTSVoidKeyword(node)) return "void";
-  if (t3.isTSAnyKeyword(node)) return "any";
-  if (t3.isTSNeverKeyword(node)) return "never";
-  if (t3.isTSUnknownKeyword(node)) return "unknown";
-  if (t3.isTSLiteralType(node)) {
-    if (t3.isStringLiteral(node.literal)) return `"${node.literal.value}"`;
-    if (t3.isNumericLiteral(node.literal)) return String(node.literal.value);
-    if (t3.isBooleanLiteral(node.literal)) return String(node.literal.value);
+  if (t2.isTSStringKeyword(node)) return "string";
+  if (t2.isTSNumberKeyword(node)) return "number";
+  if (t2.isTSBooleanKeyword(node)) return "boolean";
+  if (t2.isTSNullKeyword(node)) return "null";
+  if (t2.isTSUndefinedKeyword(node)) return "undefined";
+  if (t2.isTSVoidKeyword(node)) return "void";
+  if (t2.isTSAnyKeyword(node)) return "any";
+  if (t2.isTSNeverKeyword(node)) return "never";
+  if (t2.isTSUnknownKeyword(node)) return "unknown";
+  if (t2.isTSLiteralType(node)) {
+    if (t2.isStringLiteral(node.literal)) return `"${node.literal.value}"`;
+    if (t2.isNumericLiteral(node.literal)) return String(node.literal.value);
+    if (t2.isBooleanLiteral(node.literal)) return String(node.literal.value);
     return "literal";
   }
-  if (t3.isTSTypeReference(node)) {
-    if (t3.isIdentifier(node.typeName)) {
+  if (t2.isTSTypeReference(node)) {
+    if (t2.isIdentifier(node.typeName)) {
       const name = node.typeName.name;
       if (node.typeParameters) {
         const params = node.typeParameters.params.map(typeAnnotationToString).join(", ");
@@ -5158,28 +4259,28 @@ function typeAnnotationToString(node) {
       return name;
     }
   }
-  if (t3.isTSUnionType(node)) {
+  if (t2.isTSUnionType(node)) {
     return node.types.map(typeAnnotationToString).join(" | ");
   }
-  if (t3.isTSIntersectionType(node)) {
+  if (t2.isTSIntersectionType(node)) {
     return node.types.map(typeAnnotationToString).join(" & ");
   }
-  if (t3.isTSArrayType(node)) {
+  if (t2.isTSArrayType(node)) {
     return `${typeAnnotationToString(node.elementType)}[]`;
   }
-  if (t3.isTSFunctionType(node)) {
+  if (t2.isTSFunctionType(node)) {
     return "(...args: any[]) => any";
   }
-  if (t3.isTSTupleType(node)) {
+  if (t2.isTSTupleType(node)) {
     const elements = node.elementTypes.map((el) => {
-      if (t3.isTSNamedTupleMember(el)) {
+      if (t2.isTSNamedTupleMember(el)) {
         return typeAnnotationToString(el.elementType);
       }
       return typeAnnotationToString(el);
     }).join(", ");
     return `[${elements}]`;
   }
-  if (t3.isTSTypeLiteral(node)) {
+  if (t2.isTSTypeLiteral(node)) {
     return "object";
   }
   return "unknown";
@@ -5189,28 +4290,28 @@ function isPropsInterface(name) {
 }
 function isExportedComponent(path) {
   const parent = path.parent;
-  if (t3.isExportDefaultDeclaration(parent)) return true;
-  if (t3.isExportNamedDeclaration(parent)) return true;
-  if (t3.isProgram(parent) && path.node.id && /^[A-Z]/.test(path.node.id.name)) {
+  if (t2.isExportDefaultDeclaration(parent)) return true;
+  if (t2.isExportNamedDeclaration(parent)) return true;
+  if (t2.isProgram(parent) && path.node.id && /^[A-Z]/.test(path.node.id.name)) {
     return true;
   }
   return false;
 }
 function hasExportedArrowFunction(path) {
   const parent = path.parent;
-  if (!t3.isExportNamedDeclaration(parent)) return false;
+  if (!t2.isExportNamedDeclaration(parent)) return false;
   for (const declarator of path.node.declarations) {
-    if (t3.isIdentifier(declarator.id) && /^[A-Z]/.test(declarator.id.name) && (t3.isArrowFunctionExpression(declarator.init) || t3.isFunctionExpression(declarator.init))) {
+    if (t2.isIdentifier(declarator.id) && /^[A-Z]/.test(declarator.id.name) && (t2.isArrowFunctionExpression(declarator.init) || t2.isFunctionExpression(declarator.init))) {
       return true;
     }
   }
   return false;
 }
 function inferComponentName(filePath) {
-  const fileName = basename2(filePath);
+  const fileName = basename(filePath);
   let name = fileName.replace(/\.(tsx?|jsx?)$/, "");
   if (name === "index") {
-    name = basename2(dirname5(filePath));
+    name = basename(dirname3(filePath));
   }
   return name;
 }
@@ -5249,8 +4350,8 @@ async function findComponentSource(componentName, searchDirs) {
   ];
   for (const dir of searchDirs) {
     for (const pattern of patterns) {
-      const fullPath = join4(dir, pattern);
-      if (existsSync3(fullPath)) {
+      const fullPath = join3(dir, pattern);
+      if (existsSync2(fullPath)) {
         return fullPath;
       }
     }
@@ -5275,21 +4376,21 @@ async function extractAllComponentDocs(componentFiles) {
 }
 
 // src/service/enhance/storybook-parser.ts
-import { parse as parse4 } from "@babel/parser";
-import _traverse3 from "@babel/traverse";
-import * as t4 from "@babel/types";
-import { readFile as readFile8 } from "fs/promises";
-import fg2 from "fast-glob";
-import { basename as basename3, relative as relative3 } from "path";
-var traverse4 = _traverse3.default || _traverse3;
+import { parse as parse3 } from "@babel/parser";
+import _traverse2 from "@babel/traverse";
+import * as t3 from "@babel/types";
+import { readFile as readFile5 } from "fs/promises";
+import fg from "fast-glob";
+import { basename as basename2, relative as relative2 } from "path";
+var traverse3 = _traverse2.default || _traverse2;
 async function parseStoryFile(filePath) {
-  const content = await readFile8(filePath, "utf-8");
+  const content = await readFile5(filePath, "utf-8");
   return parseStorySource(content, filePath);
 }
 function parseStorySource(source, filePath) {
   const isTypeScript = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
   const isJSX = filePath.endsWith(".tsx") || filePath.endsWith(".jsx");
-  const ast = parse4(source, {
+  const ast = parse3(source, {
     sourceType: "module",
     plugins: [
       ...isTypeScript ? ["typescript"] : [],
@@ -5305,7 +4406,7 @@ function parseStorySource(source, filePath) {
     stories: []
   };
   let defaultExportNode = null;
-  traverse4(ast, {
+  traverse3(ast, {
     ExportDefaultDeclaration(path) {
       defaultExportNode = path.node.declaration;
     }
@@ -5316,12 +4417,12 @@ function parseStorySource(source, filePath) {
       result.meta = parseMetaObject(metaObject, result.meta.componentName);
     }
   }
-  traverse4(ast, {
+  traverse3(ast, {
     ExportNamedDeclaration(path) {
       const declaration = path.node.declaration;
-      if (t4.isVariableDeclaration(declaration)) {
+      if (t3.isVariableDeclaration(declaration)) {
         for (const declarator of declaration.declarations) {
-          if (!t4.isIdentifier(declarator.id)) continue;
+          if (!t3.isIdentifier(declarator.id)) continue;
           const storyName = declarator.id.name;
           if (!/^[A-Z]/.test(storyName)) continue;
           const story = parseStoryDeclarator(
@@ -5346,25 +4447,25 @@ function parseStorySource(source, filePath) {
   return result;
 }
 function extractMetaObject(node, ast) {
-  if (t4.isObjectExpression(node)) {
+  if (t3.isObjectExpression(node)) {
     return node;
   }
-  if (t4.isIdentifier(node)) {
+  if (t3.isIdentifier(node)) {
     const metaName = node.name;
     let foundObject = null;
-    traverse4(ast, {
+    traverse3(ast, {
       VariableDeclarator(path) {
-        if (t4.isIdentifier(path.node.id) && path.node.id.name === metaName && t4.isObjectExpression(path.node.init)) {
+        if (t3.isIdentifier(path.node.id) && path.node.id.name === metaName && t3.isObjectExpression(path.node.init)) {
           foundObject = path.node.init;
         }
       }
     });
     return foundObject;
   }
-  if (t4.isTSAsExpression(node) && t4.isObjectExpression(node.expression)) {
+  if (t3.isTSAsExpression(node) && t3.isObjectExpression(node.expression)) {
     return node.expression;
   }
-  if (t4.isTSSatisfiesExpression && t4.isTSSatisfiesExpression(node) && t4.isObjectExpression(node.expression)) {
+  if (t3.isTSSatisfiesExpression && t3.isTSSatisfiesExpression(node) && t3.isObjectExpression(node.expression)) {
     return node.expression;
   }
   return null;
@@ -5374,23 +4475,23 @@ function parseMetaObject(obj, fallbackName) {
     componentName: fallbackName
   };
   for (const prop of obj.properties) {
-    if (!t4.isObjectProperty(prop) || !t4.isIdentifier(prop.key)) continue;
+    if (!t3.isObjectProperty(prop) || !t3.isIdentifier(prop.key)) continue;
     const key = prop.key.name;
     switch (key) {
       case "title":
-        if (t4.isStringLiteral(prop.value)) {
+        if (t3.isStringLiteral(prop.value)) {
           meta.title = prop.value.value;
           const parts = meta.title.split("/");
           meta.componentName = parts[parts.length - 1];
         }
         break;
       case "component":
-        if (t4.isIdentifier(prop.value)) {
+        if (t3.isIdentifier(prop.value)) {
           meta.componentName = prop.value.name;
         }
         break;
       case "parameters":
-        if (t4.isObjectExpression(prop.value)) {
+        if (t3.isObjectExpression(prop.value)) {
           meta.parameters = extractObjectLiteral(prop.value);
           const docs = meta.parameters?.docs;
           if (docs?.description) {
@@ -5402,7 +4503,7 @@ function parseMetaObject(obj, fallbackName) {
         }
         break;
       case "argTypes":
-        if (t4.isObjectExpression(prop.value)) {
+        if (t3.isObjectExpression(prop.value)) {
           meta.argTypes = parseArgTypes(prop.value);
         }
         break;
@@ -5413,29 +4514,29 @@ function parseMetaObject(obj, fallbackName) {
 function parseArgTypes(obj) {
   const argTypes = {};
   for (const prop of obj.properties) {
-    if (!t4.isObjectProperty(prop) || !t4.isIdentifier(prop.key)) continue;
+    if (!t3.isObjectProperty(prop) || !t3.isIdentifier(prop.key)) continue;
     const propName = prop.key.name;
     const argType = {};
-    if (t4.isObjectExpression(prop.value)) {
+    if (t3.isObjectExpression(prop.value)) {
       for (const inner of prop.value.properties) {
-        if (!t4.isObjectProperty(inner) || !t4.isIdentifier(inner.key)) continue;
+        if (!t3.isObjectProperty(inner) || !t3.isIdentifier(inner.key)) continue;
         const innerKey = inner.key.name;
-        if (innerKey === "description" && t4.isStringLiteral(inner.value)) {
+        if (innerKey === "description" && t3.isStringLiteral(inner.value)) {
           argType.description = inner.value.value;
         }
         if (innerKey === "defaultValue") {
           argType.defaultValue = extractLiteralValue(inner.value);
         }
         if (innerKey === "control") {
-          if (t4.isStringLiteral(inner.value)) {
+          if (t3.isStringLiteral(inner.value)) {
             argType.control = inner.value.value;
-          } else if (t4.isObjectExpression(inner.value)) {
+          } else if (t3.isObjectExpression(inner.value)) {
             const controlObj = extractObjectLiteral(inner.value);
             argType.control = controlObj?.type;
           }
         }
-        if (innerKey === "options" && t4.isArrayExpression(inner.value)) {
-          argType.options = inner.value.elements.filter((el) => t4.isStringLiteral(el)).map((el) => el.value);
+        if (innerKey === "options" && t3.isArrayExpression(inner.value)) {
+          argType.options = inner.value.elements.filter((el) => t3.isStringLiteral(el)).map((el) => el.value);
         }
       }
     }
@@ -5453,25 +4554,25 @@ function parseStoryDeclarator(name, declarator, source, componentName) {
     code: "",
     isDefault: false
   };
-  if (t4.isObjectExpression(init)) {
+  if (t3.isObjectExpression(init)) {
     parseStoryObject(init, story);
     story.code = generateStoryCode(componentName, story.args);
     return story;
   }
-  if (t4.isTSAsExpression(init) && t4.isObjectExpression(init.expression)) {
+  if (t3.isTSAsExpression(init) && t3.isObjectExpression(init.expression)) {
     parseStoryObject(init.expression, story);
     story.code = generateStoryCode(componentName, story.args);
     return story;
   }
-  if (t4.isArrowFunctionExpression(init) || t4.isFunctionExpression(init)) {
+  if (t3.isArrowFunctionExpression(init) || t3.isFunctionExpression(init)) {
     if (init.start != null && init.end != null) {
       const fnCode = source.slice(init.start, init.end);
       story.code = fnCode;
     }
     return story;
   }
-  if (t4.isTSSatisfiesExpression && t4.isTSSatisfiesExpression(init)) {
-    if (t4.isObjectExpression(init.expression)) {
+  if (t3.isTSSatisfiesExpression && t3.isTSSatisfiesExpression(init)) {
+    if (t3.isObjectExpression(init.expression)) {
       parseStoryObject(init.expression, story);
       story.code = generateStoryCode(componentName, story.args);
       return story;
@@ -5481,21 +4582,21 @@ function parseStoryDeclarator(name, declarator, source, componentName) {
 }
 function parseStoryObject(obj, story) {
   for (const prop of obj.properties) {
-    if (!t4.isObjectProperty(prop) || !t4.isIdentifier(prop.key)) continue;
+    if (!t3.isObjectProperty(prop) || !t3.isIdentifier(prop.key)) continue;
     const key = prop.key.name;
     switch (key) {
       case "name":
-        if (t4.isStringLiteral(prop.value)) {
+        if (t3.isStringLiteral(prop.value)) {
           story.displayName = prop.value.value;
         }
         break;
       case "args":
-        if (t4.isObjectExpression(prop.value)) {
+        if (t3.isObjectExpression(prop.value)) {
           story.args = extractObjectLiteral(prop.value);
         }
         break;
       case "parameters":
-        if (t4.isObjectExpression(prop.value)) {
+        if (t3.isObjectExpression(prop.value)) {
           const params = extractObjectLiteral(prop.value);
           const docs = params?.docs;
           if (docs?.description) {
@@ -5510,15 +4611,15 @@ function parseStoryObject(obj, story) {
   }
 }
 function extractLiteralValue(node) {
-  if (t4.isStringLiteral(node)) return node.value;
-  if (t4.isNumericLiteral(node)) return node.value;
-  if (t4.isBooleanLiteral(node)) return node.value;
-  if (t4.isNullLiteral(node)) return null;
-  if (t4.isIdentifier(node) && node.name === "undefined") return void 0;
-  if (t4.isArrayExpression(node)) {
-    return node.elements.filter((el) => el !== null && t4.isExpression(el)).map(extractLiteralValue);
-  }
-  if (t4.isObjectExpression(node)) {
+  if (t3.isStringLiteral(node)) return node.value;
+  if (t3.isNumericLiteral(node)) return node.value;
+  if (t3.isBooleanLiteral(node)) return node.value;
+  if (t3.isNullLiteral(node)) return null;
+  if (t3.isIdentifier(node) && node.name === "undefined") return void 0;
+  if (t3.isArrayExpression(node)) {
+    return node.elements.filter((el) => el !== null && t3.isExpression(el)).map(extractLiteralValue);
+  }
+  if (t3.isObjectExpression(node)) {
     return extractObjectLiteral(node);
   }
   return void 0;
@@ -5526,12 +4627,12 @@ function extractLiteralValue(node) {
 function extractObjectLiteral(node) {
   const obj = {};
   for (const prop of node.properties) {
-    if (t4.isSpreadElement(prop)) continue;
-    if (!t4.isObjectProperty(prop)) continue;
+    if (t3.isSpreadElement(prop)) continue;
+    if (!t3.isObjectProperty(prop)) continue;
     let key;
-    if (t4.isIdentifier(prop.key)) {
+    if (t3.isIdentifier(prop.key)) {
       key = prop.key.name;
-    } else if (t4.isStringLiteral(prop.key)) {
+    } else if (t3.isStringLiteral(prop.key)) {
       key = prop.key.value;
     } else {
       continue;
@@ -5559,12 +4660,12 @@ function camelToTitle(str) {
   return str.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
 }
 function inferComponentFromPath(filePath) {
-  const fileName = basename3(filePath);
+  const fileName = basename2(filePath);
   const name = fileName.replace(/\.stories\.(tsx?|jsx?|mdx?)$/, "");
   return name;
 }
 async function findStoryFiles(rootDir, include = ["**/*.stories.{tsx,ts,jsx,js}"], exclude = ["**/node_modules/**", "**/dist/**"]) {
-  return fg2(include, {
+  return fg(include, {
     cwd: rootDir,
     ignore: exclude,
     absolute: true,
@@ -5580,7 +4681,7 @@ async function parseAllStories(rootDir) {
       results.set(parsed.meta.componentName, parsed);
     } catch (error) {
       console.warn(
-        `Failed to parse story file ${relative3(rootDir, filePath)}:`,
+        `Failed to parse story file ${relative2(rootDir, filePath)}:`,
         error.message
       );
     }
@@ -5918,12 +5019,12 @@ If there isn't enough usage data to make confident recommendations, indicate tha
 
 // src/service/enhance/props-extractor.ts
 import * as ts from "typescript";
-import { readFile as readFile9 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { basename as basename4, dirname as dirname7, join as join6, resolve as resolve4 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { basename as basename3, dirname as dirname5, join as join5, resolve as resolve3 } from "path";
 async function extractPropsFromFile(filePath, options = {}) {
-  const absPath = resolve4(filePath);
-  if (!existsSync4(absPath)) {
+  const absPath = resolve3(filePath);
+  if (!existsSync3(absPath)) {
     return {
       filePath: absPath,
       componentName: inferComponentName2(absPath),
@@ -5932,7 +5033,7 @@ async function extractPropsFromFile(filePath, options = {}) {
       warnings: [`File not found: ${absPath}`]
     };
   }
-  const content = await readFile9(absPath, "utf-8");
+  const content = await readFile6(absPath, "utf-8");
   return extractPropsFromSource(content, absPath, options);
 }
 function extractPropsFromSource(source, filePath, options = {}) {
@@ -6221,8 +5322,19 @@ function extractPropsFromInlineParams(componentName, sourceFile) {
     }
     if (ts.isVariableStatement(node)) {
       for (const decl of node.declarationList.declarations) {
-        if (ts.isIdentifier(decl.name) && decl.name.text === componentName && decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
-          targetFunc = decl.initializer;
+        if (ts.isIdentifier(decl.name) && decl.name.text === componentName && decl.initializer) {
+          if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {
+            targetFunc = decl.initializer;
+          } else if (ts.isCallExpression(decl.initializer)) {
+            const callee = decl.initializer.expression;
+            const isForwardRef = ts.isPropertyAccessExpression(callee) && callee.name.text === "forwardRef" || ts.isIdentifier(callee) && callee.text === "forwardRef";
+            if (isForwardRef && decl.initializer.arguments.length > 0) {
+              const firstArg = decl.initializer.arguments[0];
+              if (ts.isArrowFunction(firstArg) || ts.isFunctionExpression(firstArg)) {
+                targetFunc = firstArg;
+              }
+            }
+          }
         }
       }
     }
@@ -6340,12 +5452,12 @@ function extractCvaVariants(sourceFile, props) {
   }
 }
 function inferComponentName2(filePath) {
-  const fileName = basename4(filePath);
+  const fileName = basename3(filePath);
   let name = fileName.replace(/\.(tsx?|jsx?)$/, "");
   if (name === "index") {
-    name = basename4(dirname7(filePath));
+    name = basename3(dirname5(filePath));
   }
-  return name;
+  return name.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
 }
 function convertToFragmentProps(props) {
   const result = {};
@@ -6391,10 +5503,11 @@ async function extractPropsForComponent(componentName, searchDirs) {
   ];
   for (const dir of searchDirs) {
     for (const pattern of patterns) {
-      const fullPath = join6(dir, pattern);
-      if (existsSync4(fullPath)) {
+      const fullPath = join5(dir, pattern);
+      if (existsSync3(fullPath)) {
         return extractPropsFromFile(fullPath, {
-          propsTypeName: `${componentName}Props`
+          propsTypeName: `${componentName}Props`,
+          componentName
         });
       }
     }
@@ -6406,7 +5519,8 @@ async function extractAllComponentProps(componentFiles) {
   for (const [componentName, filePath] of componentFiles) {
     try {
       const extraction = await extractPropsFromFile(filePath, {
-        propsTypeName: `${componentName}Props`
+        propsTypeName: `${componentName}Props`,
+        componentName
       });
       results.set(componentName, extraction);
     } catch (error) {
@@ -6730,25 +5844,6 @@ export {
   applyPatches,
   MetricsStore,
   createMetricsStore,
-  scanFileForImports,
-  scanFileForUsages,
-  scanFile,
-  aggregateComponentUsages,
-  aggregateAllUsages,
-  findCommonPropCombinations,
-  inferRelations,
-  inferAllRelations,
-  summarizePatternsForPrompt,
-  loadCache,
-  saveCache,
-  createEmptyCache,
-  computeFileHash,
-  detectFileChanges,
-  getCacheStats,
-  scanCodebase,
-  incrementalScan,
-  getScanStats,
-  hasCachedAnalysis,
   extractComponentDocs,
   extractDocsFromSource,
   findComponentSource,
@@ -6776,4 +5871,4 @@ export {
   getStorybookStoryIds,
   renderAllComponentVariants
 };
-//# sourceMappingURL=chunk-APTQIBS5.js.map
+//# sourceMappingURL=chunk-XJQ5BIWI.js.map