@wtdlee/repomap 0.2.0 → 0.3.1

package/dist/chunk-GNBMJMET.js

@@ -0,0 +1,2519 @@
+import { Project, Node, SyntaxKind } from 'ts-morph';
+import fg from 'fast-glob';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as fs2 from 'fs/promises';
+import { parse } from 'graphql';
+
+// src/analyzers/base-analyzer.ts
+var BaseAnalyzer = class {
+  config;
+  basePath;
+  constructor(config) {
+    this.config = config;
+    this.basePath = config.path;
+  }
+  /**
+   * Resolve path relative to repository root
+   * リポジトリルートからの相対パスを解決
+   */
+  resolvePath(relativePath) {
+    return `${this.basePath}/${relativePath}`;
+  }
+  /**
+   * Get setting value with fallback
+   * 設定値を取得（フォールバック付き）
+   */
+  getSetting(key, defaultValue = "") {
+    return this.config.settings[key] ?? defaultValue;
+  }
+  /**
+   * Log analysis progress
+   * 分析進捗をログ出力
+   */
+  log(message) {
+    console.log(`[${this.getName()}] ${message}`);
+  }
+  /**
+   * Log warning
+   * 警告をログ出力
+   */
+  warn(message) {
+    console.warn(`[${this.getName()}] \u26A0\uFE0F ${message}`);
+  }
+  /**
+   * Log error
+   * エラーをログ出力
+   */
+  error(message, error) {
+    console.error(`[${this.getName()}] \u274C ${message}`, error?.message || "");
+  }
+};
+
+// src/utils/parallel.ts
+async function parallelMapSafe(items, fn, concurrency = 8) {
+  const results = new Array(items.length).fill(null);
+  let currentIndex = 0;
+  async function worker() {
+    while (currentIndex < items.length) {
+      const index = currentIndex++;
+      if (index < items.length) {
+        try {
+          results[index] = await fn(items[index], index);
+        } catch {
+          results[index] = null;
+        }
+      }
+    }
+  }
+  const workers = Array(Math.min(concurrency, items.length)).fill(null).map(() => worker());
+  await Promise.all(workers);
+  return results.filter((r) => r !== null);
+}
+
+// src/analyzers/pages-analyzer.ts
+var PagesAnalyzer = class extends BaseAnalyzer {
+  project;
+  // Codegen Document → Operation name mapping
+  codegenMap = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super(config);
+    this.project = new Project({
+      tsConfigFilePath: this.resolvePath("tsconfig.json"),
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  /**
+   * Extract GraphQL operation name from a gql template literal or function call
+   * Handles multiple patterns:
+   * - gql`query Name { ... }`
+   * - gql(/‌* GraphQL *‌/ `query Name { ... }`)
+   * - graphql(`query Name { ... }`)
+   */
+  extractOperationNameFromGql(text) {
+    const directMatch = text.match(/(?:query|mutation|subscription)\s+(\w+)/);
+    if (directMatch && directMatch[1]) {
+      return directMatch[1];
+    }
+    const backtickMatch = text.match(/`\s*(?:query|mutation|subscription)\s+(\w+)/);
+    if (backtickMatch && backtickMatch[1]) {
+      return backtickMatch[1];
+    }
+    const commentMatch = text.match(
+      /GraphQL[^`]*`\s*(?:\n\s*)?(?:query|mutation|subscription)\s+(\w+)/
+    );
+    if (commentMatch && commentMatch[1]) {
+      return commentMatch[1];
+    }
+    return null;
+  }
+  /**
+   * Find and extract operation name from a variable declaration in source file
+   * Handles cases like: const Query = gql(comment `query ActualName...`)
+   */
+  findOperationNameFromVariable(sourceFile, variableName) {
+    let varDecl = sourceFile.getVariableDeclaration(variableName);
+    if (!varDecl) {
+      const exportedDecls = sourceFile.getExportedDeclarations();
+      const exported = exportedDecls.get(variableName);
+      if (exported && exported.length > 0) {
+        const firstExport = exported[0];
+        if (Node.isVariableDeclaration(firstExport)) {
+          varDecl = firstExport;
+        }
+      }
+    }
+    if (!varDecl) {
+      const allVarDecls = sourceFile.getVariableDeclarations();
+      varDecl = allVarDecls.find((v) => v.getName() === variableName);
+    }
+    if (!varDecl) {
+      const fullText = sourceFile.getFullText();
+      const patterns = [
+        // gql(/* GraphQL */ `query Name...
+        new RegExp(
+          `(?:const|let|var)\\s+${variableName}\\s*=\\s*gql\\s*\\(\\s*/\\*[^*]*\\*/\\s*\`\\s*(?:query|mutation|subscription)\\s+(\\w+)`,
+          "s"
+        ),
+        // gql`query Name...
+        new RegExp(
+          `(?:const|let|var)\\s+${variableName}\\s*=\\s*gql\`\\s*(?:query|mutation|subscription)\\s+(\\w+)`,
+          "s"
+        ),
+        // gql(`query Name... (without comment)
+        new RegExp(
+          `(?:const|let|var)\\s+${variableName}\\s*=\\s*gql\\s*\\(\`\\s*(?:query|mutation|subscription)\\s+(\\w+)`,
+          "s"
+        ),
+        // graphql(`query Name...
+        new RegExp(
+          `(?:const|let|var)\\s+${variableName}\\s*=\\s*graphql\\s*\\(\`\\s*(?:query|mutation|subscription)\\s+(\\w+)`,
+          "s"
+        )
+      ];
+      for (const pattern of patterns) {
+        const match = fullText.match(pattern);
+        if (match && match[1]) {
+          return match[1];
+        }
+      }
+      return null;
+    }
+    const initializer = varDecl.getInitializer();
+    if (!initializer) return null;
+    const text = initializer.getText();
+    return this.extractOperationNameFromGql(text);
+  }
+  getName() {
+    return "PagesAnalyzer";
+  }
+  async analyze() {
+    this.log("Starting page analysis...");
+    await this.loadCodegenMapping();
+    await this.analyzeAppFile();
+    const pageFiles = await this.findPageFiles();
+    this.log(`Found ${pageFiles.length} page files`);
+    for (const filePath of pageFiles) {
+      try {
+        this.project.addSourceFileAtPath(filePath);
+      } catch {
+      }
+    }
+    const pages = await parallelMapSafe(
+      pageFiles,
+      async (filePath) => {
+        const pagesPath = this.detectPagesRoot(filePath);
+        return this.analyzePageFile(filePath, pagesPath);
+      },
+      4
+      // Limit concurrency for ts-morph stability
+    );
+    const validPages = pages.filter((p) => p !== null);
+    this.log(`Analyzed ${validPages.length} pages successfully`);
+    return { pages: validPages };
+  }
+  async analyzePageFile(filePath, pagesPath) {
+    const sourceFile = this.project.getSourceFile(filePath);
+    if (!sourceFile) return null;
+    const relativePath = path.relative(pagesPath, filePath);
+    const routePath = this.filePathToRoutePath(relativePath);
+    const pageComponent = this.findPageComponent(sourceFile);
+    if (!pageComponent) {
+      return null;
+    }
+    const params = this.extractRouteParams(routePath);
+    const layout = this.extractLayout(sourceFile);
+    const authentication = this.extractAuthRequirement(sourceFile);
+    const permissions = this.extractPermissions(sourceFile);
+    const dataFetching = this.extractDataFetching(sourceFile);
+    const navigation = this.extractNavigation(sourceFile);
+    const linkedPages = this.extractLinkedPages(sourceFile);
+    const steps = this.extractSteps(sourceFile);
+    return {
+      path: routePath,
+      filePath: relativePath,
+      component: pageComponent,
+      params,
+      layout,
+      authentication,
+      permissions,
+      dataFetching,
+      navigation,
+      linkedPages,
+      steps: steps.length > 0 ? steps : void 0
+    };
+  }
+  /**
+   * Detect the pages root directory from a file path
+   * e.g., /project/src/pages/users/index.tsx -> /project/src/pages
+   */
+  detectPagesRoot(filePath) {
+    const pagesPatterns = [
+      "/src/pages/",
+      "/pages/",
+      "/src/app/",
+      "/app/",
+      "/frontend/src/pages/",
+      "/app/javascript/pages/"
+    ];
+    for (const pattern of pagesPatterns) {
+      const idx = filePath.indexOf(pattern);
+      if (idx !== -1) {
+        return filePath.substring(0, idx + pattern.length - 1);
+      }
+    }
+    return this.basePath;
+  }
+  filePathToRoutePath(filePath) {
+    return "/" + filePath.replace(/\.tsx?$/, "").replace(/\/index$/, "").replace(/\[\.\.\.(\w+)\]/g, "*").replace(/\[(\w+)\]/g, ":$1");
+  }
+  extractRouteParams(routePath) {
+    const params = [];
+    const paramRegex = /:(\w+)/g;
+    let match;
+    while ((match = paramRegex.exec(routePath)) !== null) {
+      params.push(match[1]);
+    }
+    return params;
+  }
+  findPageComponent(sourceFile) {
+    const defaultExport = sourceFile.getDefaultExportSymbol();
+    if (defaultExport) {
+      const name = defaultExport.getName();
+      if (name !== "default") {
+        return name;
+      }
+    }
+    const exportAssignment = sourceFile.getExportAssignment((e) => !e.isExportEquals());
+    if (exportAssignment) {
+      const expr = exportAssignment.getExpression();
+      if (expr) {
+        const text = expr.getText();
+        if (/^[A-Z][a-zA-Z0-9]*$/.test(text)) {
+          return text;
+        }
+        if (Node.isFunctionExpression(expr) || Node.isArrowFunction(expr)) {
+          return "default";
+        }
+      }
+    }
+    const functions = sourceFile.getFunctions();
+    for (const func of functions) {
+      if (func.isDefaultExport()) {
+        return func.getName() || "default";
+      }
+    }
+    const pageVar = sourceFile.getVariableDeclaration("Page");
+    if (pageVar) {
+      return "Page";
+    }
+    const varDeclarations = sourceFile.getVariableDeclarations();
+    for (const varDecl of varDeclarations) {
+      const typeNode = varDecl.getTypeNode();
+      if (typeNode) {
+        const typeText = typeNode.getText();
+        if (typeText.includes("NextPage") || typeText.includes("FC") || typeText.includes("React.FC")) {
+          return varDecl.getName();
+        }
+      }
+    }
+    for (const varDecl of varDeclarations) {
+      const name = varDecl.getName();
+      if (/^[A-Z][a-zA-Z0-9]*$/.test(name)) {
+        const init = varDecl.getInitializer();
+        if (init && (Node.isArrowFunction(init) || Node.isFunctionExpression(init))) {
+          const text = init.getText();
+          if (text.includes("return") && (text.includes("<") || text.includes("jsx"))) {
+            return name;
+          }
+        }
+      }
+    }
+    return null;
+  }
+  extractLayout(sourceFile) {
+    const getLayoutAssignment = sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression).find((node) => node.getName() === "getLayout");
+    if (getLayoutAssignment) {
+      const parent = getLayoutAssignment.getParent();
+      if (Node.isBinaryExpression(parent)) {
+        const right = parent.getRight();
+        const jsxElements = right.getDescendantsOfKind(SyntaxKind.JsxOpeningElement);
+        if (jsxElements.length > 0) {
+          return jsxElements[0].getTagNameNode().getText();
+        }
+      }
+    }
+    return void 0;
+  }
+  extractAuthRequirement(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    const fileName = filePath.split("/").pop() || "";
+    const publicPages = [
+      "404.tsx",
+      "permission-denied.tsx",
+      "_app.tsx",
+      "_document.tsx",
+      "_error.tsx"
+    ];
+    const isPublicPage = publicPages.some((p) => fileName === p);
+    const result = {
+      required: !isPublicPage
+    };
+    try {
+      const authPatterns = [
+        "RequiredCondition",
+        "ProtectedRoute",
+        "AuthGuard",
+        "PrivateRoute",
+        "WithAuth",
+        "RequireAuth",
+        "Authenticated",
+        "Authorized"
+      ];
+      const authWrapper = sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement).find((node) => {
+        const tagName = node.getTagNameNode().getText();
+        return authPatterns.some((pattern) => tagName.includes(pattern));
+      });
+      if (authWrapper) {
+        result.condition = "Additional permissions required";
+        const attributes = authWrapper.getAttributes();
+        for (const attr of attributes) {
+          if (attr.isKind(SyntaxKind.JsxAttribute)) {
+            try {
+              const name = attr.getNameNode().getText();
+              if (["condition", "roles", "permissions", "requiredRoles", "allowedRoles"].includes(
+                name
+              )) {
+                const initializer = attr.getInitializer();
+                if (initializer) {
+                  result.condition = initializer.getText();
+                  const roles = this.extractRolesFromCondition(initializer.getText());
+                  if (roles.length > 0) {
+                    result.roles = roles;
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  extractRolesFromCondition(condition) {
+    const roles = [];
+    const enumRoleRegex = /(\w+Role|\w+Permission)\.(\w+)/g;
+    let match;
+    while ((match = enumRoleRegex.exec(condition)) !== null) {
+      roles.push(match[2]);
+    }
+    const stringRoleRegex = /['"]([a-zA-Z_-]+)['"]/g;
+    while ((match = stringRoleRegex.exec(condition)) !== null) {
+      const val = match[1];
+      if (/admin|user|owner|member|guest|manager|editor|viewer/i.test(val)) {
+        roles.push(val);
+      }
+    }
+    const constRoleRegex = /\b(ROLE_\w+|[A-Z]+_ROLE)\b/g;
+    while ((match = constRoleRegex.exec(condition)) !== null) {
+      roles.push(match[1]);
+    }
+    return [...new Set(roles)];
+  }
+  extractPermissions(sourceFile) {
+    const permissions = [];
+    const permissionChecks = sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression).filter((node) => {
+      const text = node.getText();
+      return text.includes("Permission") || text.includes("Role") || text.includes("isAdmin");
+    });
+    for (const check of permissionChecks) {
+      const text = check.getText();
+      if (!permissions.includes(text)) {
+        permissions.push(text);
+      }
+    }
+    return permissions;
+  }
+  extractDataFetching(sourceFile) {
+    const dataFetching = [];
+    const apolloHookAliases = /* @__PURE__ */ new Map();
+    const apolloHooks = ["useQuery", "useMutation", "useLazyQuery", "useSubscription"];
+    for (const imp of sourceFile.getImportDeclarations()) {
+      const moduleSpec = imp.getModuleSpecifierValue();
+      if (moduleSpec.includes("@apollo/client") || moduleSpec.includes("apollo")) {
+        for (const named of imp.getNamedImports()) {
+          const originalName = named.getName();
+          const alias = named.getAliasNode()?.getText() || originalName;
+          if (apolloHooks.includes(originalName)) {
+            apolloHookAliases.set(alias, originalName);
+          }
+        }
+      }
+    }
+    const hasApolloImport = apolloHookAliases.size > 0 || sourceFile.getImportDeclarations().some((imp) => {
+      const moduleSpecifier = imp.getModuleSpecifierValue();
+      return moduleSpecifier.includes("@apollo/client") || moduleSpecifier.includes("apollo");
+    });
+    const graphqlHookCalls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => {
+      const expression = call.getExpression().getText();
+      if (apolloHookAliases.has(expression) || apolloHooks.includes(expression)) {
+        return true;
+      }
+      if (/^use[A-Z].*Query$/.test(expression) && !expression.includes("Params") && !expression.includes("String")) {
+        return true;
+      }
+      if (/^use[A-Z].*Mutation$/.test(expression)) {
+        return true;
+      }
+      return false;
+    });
+    for (const call of graphqlHookCalls) {
+      const hookName = call.getExpression().getText();
+      let resolvedType;
+      if (apolloHookAliases.has(hookName)) {
+        resolvedType = apolloHookAliases.get(hookName);
+      } else if (hookName.includes("Mutation")) {
+        resolvedType = "useMutation";
+      } else if (hookName.includes("Lazy")) {
+        resolvedType = "useLazyQuery";
+      } else {
+        resolvedType = "useQuery";
+      }
+      const args = call.getArguments();
+      if (args.length === 0) {
+        if (/^use[A-Z]/.test(hookName)) {
+          const operationName2 = hookName.replace(/^use/, "").replace(/Query$|Mutation$/, "");
+          dataFetching.push({ type: resolvedType, operationName: operationName2, variables: [] });
+        }
+        continue;
+      }
+      const firstArg = args[0];
+      const firstArgText = firstArg.getText();
+      if (firstArgText.startsWith("[") || firstArgText.startsWith("{") || firstArgText.startsWith("'") || firstArgText.startsWith('"') || firstArgText.startsWith("`")) {
+        continue;
+      }
+      const isApolloPattern = hasApolloImport || firstArgText.endsWith("Document") || firstArgText.endsWith("Query") || firstArgText.endsWith("Mutation") || firstArgText.includes("gql") || /^[A-Z_]+$/.test(firstArgText);
+      if (!isApolloPattern) {
+        continue;
+      }
+      const operationName = firstArgText.replace(/Document$/, "").replace(/Query$|Mutation$/, "");
+      const variables = [];
+      if (args.length > 1) {
+        const optionsArg = args[1];
+        const variablesProperty = optionsArg.getDescendantsOfKind(SyntaxKind.PropertyAssignment).find((prop) => {
+          try {
+            return prop.getName() === "variables";
+          } catch {
+            return false;
+          }
+        });
+        if (variablesProperty) {
+          const initializer = variablesProperty.getInitializer();
+          if (initializer) {
+            const props = initializer.getDescendantsOfKind(SyntaxKind.PropertyAssignment);
+            for (const prop of props) {
+              try {
+                variables.push(prop.getName());
+              } catch {
+              }
+            }
+          }
+        }
+      }
+      dataFetching.push({ type: resolvedType, operationName, variables });
+    }
+    const getServerSidePropsVar = sourceFile.getVariableDeclaration("getServerSideProps");
+    const getServerSidePropsFunc = sourceFile.getFunction("getServerSideProps");
+    const ssrNode = getServerSidePropsVar || getServerSidePropsFunc;
+    if (ssrNode) {
+      const imports2 = sourceFile.getImportDeclarations();
+      for (const imp of imports2) {
+        const namedImports = imp.getNamedImports();
+        for (const named of namedImports) {
+          const name = named.getName();
+          if (name.endsWith("Document")) {
+            const usages = sourceFile.getDescendantsOfKind(SyntaxKind.Identifier).filter((id) => id.getText() === name);
+            if (usages.length > 0) {
+              const operationName = name.replace(/Document$/, "");
+              dataFetching.push({
+                type: "getServerSideProps",
+                operationName: `\u2192 ${operationName}`
+              });
+            }
+          }
+        }
+      }
+      const text = ssrNode.getText();
+      const queryMatches = text.match(/query:\s*(\w+)/g);
+      if (queryMatches) {
+        for (const match of queryMatches) {
+          const docName = match.replace(/query:\s*/, "");
+          if (!dataFetching.some((d) => d.operationName?.includes(docName.replace(/Document$/, "")))) {
+            dataFetching.push({
+              type: "getServerSideProps",
+              operationName: `\u2192 ${docName.replace(/Document$/, "")}`
+            });
+          }
+        }
+      }
+    }
+    const getStaticPropsVar = sourceFile.getVariableDeclaration("getStaticProps");
+    const getStaticPropsFunc = sourceFile.getFunction("getStaticProps");
+    if (getStaticPropsVar || getStaticPropsFunc) {
+      dataFetching.push({
+        type: "getStaticProps",
+        operationName: "getStaticProps"
+      });
+    }
+    const imports = sourceFile.getImportDeclarations();
+    const sourceFilePath = sourceFile.getFilePath();
+    const sourceFileDir = path.dirname(sourceFilePath);
+    for (const imp of imports) {
+      const moduleSpec = imp.getModuleSpecifierValue();
+      const isRelativeImport = moduleSpec.startsWith(".") || moduleSpec.startsWith("/");
+      const isInternalAlias = !moduleSpec.includes("node_modules") && !moduleSpec.startsWith("@types/") && moduleSpec.startsWith("@") === false;
+      if (isRelativeImport || isInternalAlias) {
+        if (moduleSpec.includes("__generated__") || moduleSpec.includes("/generated/")) {
+          continue;
+        }
+        const componentNames = [];
+        const namedImports = imp.getNamedImports();
+        for (const named of namedImports) {
+          const name = named.getName();
+          if (this.isComponentName(name)) {
+            componentNames.push(name);
+          }
+        }
+        const defaultImport = imp.getDefaultImport();
+        if (defaultImport) {
+          const name = defaultImport.getText();
+          if (this.isComponentName(name)) {
+            componentNames.push(name);
+          }
+        }
+        for (const componentName of componentNames) {
+          const importedQueries = this.analyzeImportedComponent(
+            sourceFileDir,
+            moduleSpec,
+            componentName
+          );
+          if (importedQueries.length > 0) {
+            for (const query of importedQueries) {
+              dataFetching.push({
+                type: query.type,
+                operationName: query.operationName.startsWith("\u2192") ? `\u2192 ${query.operationName} (${componentName})` : `\u2192 ${query.operationName} (${componentName})`,
+                variables: query.variables
+              });
+            }
+          } else {
+            dataFetching.push({
+              type: "component",
+              operationName: componentName,
+              variables: []
+            });
+          }
+        }
+      }
+    }
+    return dataFetching;
+  }
+  // Symbol tracking cache to avoid re-analyzing the same files
+  symbolTraceCache = /* @__PURE__ */ new Map();
+  /**
+   * Analyze an imported component file for GraphQL queries with full symbol tracing
+   * 임포트된 컴포넌트를 재귀적으로 완전 추적
+   */
+  analyzeImportedComponent(sourceFileDir, moduleSpec, componentName, visited = /* @__PURE__ */ new Set(), depth = 0) {
+    const MAX_DEPTH = 10;
+    if (depth > MAX_DEPTH) return [];
+    const queries = [];
+    try {
+      const resolvedPath = path.resolve(sourceFileDir, moduleSpec);
+      const cacheKey = `${resolvedPath}:${componentName}`;
+      if (visited.has(cacheKey)) {
+        return [];
+      }
+      visited.add(cacheKey);
+      const cachedResult = this.symbolTraceCache.get(cacheKey);
+      if (cachedResult !== void 0) {
+        return cachedResult;
+      }
+      const possiblePaths = [
+        `${resolvedPath}.tsx`,
+        `${resolvedPath}.ts`,
+        `${resolvedPath}/index.tsx`,
+        `${resolvedPath}/index.ts`,
+        `${resolvedPath}/${componentName}.tsx`,
+        `${resolvedPath}/${componentName}.ts`
+      ];
+      let componentFile;
+      let componentFilePath;
+      for (const tryPath of possiblePaths) {
+        try {
+          componentFile = this.project.addSourceFileAtPath(tryPath);
+          if (componentFile) {
+            componentFilePath = tryPath;
+            break;
+          }
+        } catch {
+        }
+      }
+      if (!componentFile || !componentFilePath) return queries;
+      if (componentFilePath.endsWith("index.tsx") || componentFilePath.endsWith("index.ts")) {
+        const actualFile = this.followReExport(
+          componentFile,
+          componentName,
+          path.dirname(componentFilePath)
+        );
+        if (actualFile) {
+          componentFile = actualFile;
+        }
+      }
+      const hasGraphQLImport = componentFile.getImportDeclarations().some((imp) => {
+        const spec = imp.getModuleSpecifierValue();
+        return spec.includes("@apollo/client") || spec.includes("apollo") || spec.includes("gql") || spec.includes("graphql") || // graphql.macro, graphql-tag
+        spec.includes("__generated__");
+      });
+      const relativeImports = componentFile.getImportDeclarations().filter((imp) => {
+        const spec = imp.getModuleSpecifierValue();
+        return spec.startsWith("./") || spec.startsWith("../");
+      });
+      for (const imp of relativeImports) {
+        const hookSpec = imp.getModuleSpecifierValue();
+        const hookNames = imp.getNamedImports().map((n) => n.getName()).filter((n) => /^use[A-Z]/.test(n));
+        for (const hookName of hookNames) {
+          const hookQueries = this.analyzeCustomHook(
+            path.dirname(componentFile.getFilePath()),
+            hookSpec,
+            hookName,
+            visited,
+            depth + 1
+          );
+          queries.push(...hookQueries);
+        }
+      }
+      for (const imp of relativeImports) {
+        const nestedSpec = imp.getModuleSpecifierValue();
+        const namedImports = imp.getNamedImports().map((n) => n.getName());
+        const defaultImport = imp.getDefaultImport()?.getText();
+        const componentImports = namedImports.filter(
+          (n) => /^[A-Z]/.test(n) && this.isComponentName(n)
+        );
+        for (const nestedComponentName of componentImports) {
+          const nestedQueries = this.analyzeImportedComponent(
+            path.dirname(componentFile.getFilePath()),
+            nestedSpec,
+            nestedComponentName,
+            visited,
+            depth + 1
+          );
+          queries.push(...nestedQueries);
+        }
+        if (defaultImport && /^[A-Z]/.test(defaultImport) && this.isComponentName(defaultImport)) {
+          const nestedQueries = this.analyzeImportedComponent(
+            path.dirname(componentFile.getFilePath()),
+            nestedSpec,
+            defaultImport,
+            visited,
+            depth + 1
+          );
+          queries.push(...nestedQueries);
+        }
+      }
+      if (hasGraphQLImport) {
+        const hookCalls = componentFile.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => {
+          const expression = call.getExpression().getText();
+          return ["useQuery", "useMutation", "useLazyQuery", "useSubscription"].includes(
+            expression
+          );
+        });
+        for (const call of hookCalls) {
+          const hookName = call.getExpression().getText();
+          const args = call.getArguments();
+          if (args.length === 0) continue;
+          const firstArg = args[0];
+          const firstArgText = firstArg.getText();
+          let operationName = firstArgText;
+          let operationType = null;
+          const codegenInfo = this.resolveDocumentName(firstArgText);
+          if (codegenInfo) {
+            operationName = codegenInfo.operationName;
+            operationType = codegenInfo.operationType;
+          } else if (firstArgText.endsWith("Document")) {
+            operationName = firstArgText.replace(/Document$/, "");
+          } else if (/^[A-Za-z]/.test(firstArgText)) {
+            const extractedName = this.findOperationNameFromVariable(componentFile, firstArgText);
+            if (extractedName) {
+              operationName = extractedName;
+            }
+            if (operationName === firstArgText && firstArgText !== "Query" && firstArgText !== "Mutation") {
+              const nameMatch = firstArgText.match(/^(.+?)(Query|Mutation|Subscription)$/);
+              if (nameMatch) {
+                operationName = nameMatch[1];
+              }
+            }
+          }
+          if (operationName !== "Query" && operationName !== "Mutation") {
+            const cleanedName = operationName.replace(/Document$/, "").replace(/Query$|Mutation$/, "");
+            operationName = cleanedName || operationName;
+          }
+          if (operationName === "Query" || operationName === "Mutation" || operationName === "") {
+            if (operationName === "") {
+              operationName = firstArgText || "Unknown";
+            }
+          }
+          const type = operationType ? operationType === "mutation" ? "useMutation" : operationType === "subscription" ? "useSubscription" : hookName.includes("Lazy") ? "useLazyQuery" : "useQuery" : hookName.includes("Mutation") ? "useMutation" : hookName.includes("Lazy") ? "useLazyQuery" : "useQuery";
+          queries.push({
+            type,
+            operationName,
+            variables: []
+          });
+        }
+      }
+      this.symbolTraceCache.set(cacheKey, queries);
+    } catch {
+    }
+    return queries;
+  }
+  /**
+   * Analyze a custom hook file for GraphQL queries with recursive tracing
+   */
+  analyzeCustomHook(sourceFileDir, moduleSpec, hookName, visited = /* @__PURE__ */ new Set(), depth = 0) {
+    const MAX_DEPTH = 10;
+    if (depth > MAX_DEPTH) return [];
+    const queries = [];
+    try {
+      const resolvedPath = path.resolve(sourceFileDir, moduleSpec);
+      const cacheKey = `hook:${resolvedPath}:${hookName}`;
+      if (visited.has(cacheKey)) return [];
+      visited.add(cacheKey);
+      const cachedHookResult = this.symbolTraceCache.get(cacheKey);
+      if (cachedHookResult !== void 0) {
+        return cachedHookResult;
+      }
+      const possiblePaths = [
+        `${resolvedPath}.tsx`,
+        `${resolvedPath}.ts`,
+        `${resolvedPath}/${hookName}.tsx`,
+        `${resolvedPath}/${hookName}.ts`,
+        `${resolvedPath}/index.tsx`,
+        `${resolvedPath}/index.ts`
+      ];
+      let hookFile;
+      for (const tryPath of possiblePaths) {
+        try {
+          hookFile = this.project.addSourceFileAtPath(tryPath);
+          if (hookFile) break;
+        } catch {
+        }
+      }
+      if (!hookFile) return queries;
+      const hasGraphQLImport = hookFile.getImportDeclarations().some((imp) => {
+        const spec = imp.getModuleSpecifierValue();
+        return spec.includes("@apollo/client") || spec.includes("apollo") || spec.includes("graphql") || spec.includes("__generated__");
+      });
+      const relativeImports = hookFile.getImportDeclarations().filter((imp) => {
+        const spec = imp.getModuleSpecifierValue();
+        return spec.startsWith("./") || spec.startsWith("../");
+      });
+      for (const imp of relativeImports) {
+        const nestedSpec = imp.getModuleSpecifierValue();
+        const nestedHookNames = imp.getNamedImports().map((n) => n.getName()).filter((n) => /^use[A-Z]/.test(n));
+        for (const nestedHookName of nestedHookNames) {
+          const nestedQueries = this.analyzeCustomHook(
+            path.dirname(hookFile.getFilePath()),
+            nestedSpec,
+            nestedHookName,
+            visited,
+            depth + 1
+          );
+          queries.push(...nestedQueries);
+        }
+      }
+      if (!hasGraphQLImport && queries.length === 0) {
+        return queries;
+      }
+      const hookCalls = hookFile.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => {
+        const expression = call.getExpression().getText();
+        return ["useQuery", "useMutation", "useLazyQuery", "useSubscription"].includes(expression);
+      });
+      for (const call of hookCalls) {
+        const callHookName = call.getExpression().getText();
+        const args = call.getArguments();
+        if (args.length === 0) continue;
+        const firstArgText = args[0].getText();
+        let operationName = firstArgText;
+        let operationType = null;
+        const codegenInfo = this.resolveDocumentName(firstArgText);
+        if (codegenInfo) {
+          operationName = codegenInfo.operationName;
+          operationType = codegenInfo.operationType;
+        } else if (firstArgText.endsWith("Document")) {
+          operationName = firstArgText.replace(/Document$/, "");
+        } else if (/^[A-Za-z]/.test(firstArgText)) {
+          const extractedName = this.findOperationNameFromVariable(hookFile, firstArgText);
+          if (extractedName) {
+            operationName = extractedName;
+          }
+          if (operationName === firstArgText && firstArgText !== "Query" && firstArgText !== "Mutation") {
+            const nameMatch = firstArgText.match(/^(.+?)(Query|Mutation|Subscription)$/);
+            if (nameMatch) {
+              operationName = nameMatch[1];
+            }
+          }
+        }
+        if (operationName !== "Query" && operationName !== "Mutation") {
+          const cleanedName = operationName.replace(/Document$/, "").replace(/Query$|Mutation$/, "");
+          operationName = cleanedName || operationName;
+        }
+        if (operationName === "") {
+          operationName = firstArgText || "Unknown";
+        }
+        const type = operationType ? operationType === "mutation" ? "useMutation" : operationType === "subscription" ? "useSubscription" : callHookName.includes("Lazy") ? "useLazyQuery" : "useQuery" : callHookName.includes("Mutation") ? "useMutation" : callHookName.includes("Lazy") ? "useLazyQuery" : "useQuery";
+        queries.push({
+          type,
+          operationName: `\u2192 ${operationName} (via ${hookName})`,
+          variables: []
+        });
+      }
+      this.symbolTraceCache.set(cacheKey, queries);
+    } catch {
+    }
+    return queries;
+  }
+  // Global context providers and their GraphQL queries
+  globalContextQueries = [];
+  /**
+   * Find page files from multiple possible locations
+   * Next.js, React, Rails+React 구조 모두 지원
+   */
+  async findPageFiles() {
+    const pagesDir = this.getSetting("pagesDir", "src/pages");
+    const allFiles = [];
+    const nextjsDirsSet = /* @__PURE__ */ new Set([pagesDir, "pages", "src/pages", "app", "src/app"]);
+    const nextjsDirs = [...nextjsDirsSet];
+    for (const dir of nextjsDirs) {
+      if (dir === "app" || dir === "src/app") {
+        const railsIndicators = ["controllers", "models", "views", "helpers"];
+        const dirPath2 = this.resolvePath(dir);
+        const hasRailsStructure = railsIndicators.some((subdir) => {
+          try {
+            return fs.existsSync(path.join(dirPath2, subdir));
+          } catch {
+            return false;
+          }
+        });
+        if (hasRailsStructure) {
+          continue;
+        }
+      }
+      const dirPath = this.resolvePath(dir);
+      try {
+        const files = await fg(["**/*.tsx", "**/*.ts", "**/*.jsx", "**/*.js"], {
+          cwd: dirPath,
+          ignore: [
+            "_app.tsx",
+            "_app.ts",
+            "_app.jsx",
+            "_app.js",
+            "_document.tsx",
+            "_document.ts",
+            "_document.jsx",
+            "_document.js",
+            "_error.tsx",
+            "_error.ts",
+            "_error.jsx",
+            "_error.js",
+            "api/**",
+            "**/*.test.*",
+            "**/*.spec.*",
+            "**/node_modules/**",
+            "**/components/pages/**"
+            // Reusable page components, not routes
+          ],
+          absolute: true
+        });
+        allFiles.push(...files);
+        if (files.length > 0) {
+          this.log(`Found ${files.length} pages in ${dir}`);
+        }
+      } catch {
+      }
+    }
+    const railsReactDirs = ["frontend/src/**/pages", "app/javascript/**/pages"];
+    for (const pattern of railsReactDirs) {
+      try {
+        const files = await fg(
+          [
+            `${pattern}/**/*.tsx`,
+            `${pattern}/**/*.ts`,
+            `${pattern}/**/*.jsx`,
+            `${pattern}/**/*.js`
+          ],
+          {
+            cwd: this.basePath,
+            ignore: [
+              "**/*.test.*",
+              "**/*.spec.*",
+              "**/node_modules/**",
+              "**/vendor/**",
+              "**/components/pages/**",
+              // Exclude reusable page components (not actual routes)
+              "**/stories/**"
+              // Exclude storybook files
+            ],
+            absolute: true
+          }
+        );
+        allFiles.push(...files);
+        if (files.length > 0) {
+          this.log(`Found ${files.length} React pages in ${pattern}`);
+        }
+      } catch {
+      }
+    }
+    const entryPatterns = [
+      "frontend/src/**/index.tsx",
+      "frontend/src/**/App.tsx",
+      "app/javascript/packs/*.tsx",
+      "app/javascript/packs/*.jsx"
+    ];
+    for (const pattern of entryPatterns) {
+      try {
+        const files = await fg([pattern], {
+          cwd: this.basePath,
+          ignore: ["**/node_modules/**", "**/vendor/**"],
+          absolute: true
+        });
+        for (const file of files) {
+          if (!allFiles.includes(file)) {
+            allFiles.push(file);
+          }
+        }
+      } catch {
+      }
+    }
+    return [...new Set(allFiles)];
+  }
+  /**
+   * Analyze _app.tsx for global providers that use GraphQL
+   * _app.tsx에서 전역 Context Provider의 GraphQL 분석
+   */
+  async analyzeAppFile() {
+    const pagesDir = this.getSetting("pagesDir", "src/pages");
+    const possiblePaths = [
+      this.resolvePath(`${pagesDir}/_app.tsx`),
+      this.resolvePath(`${pagesDir}/_app.ts`)
+    ];
+    for (const appPath of possiblePaths) {
+      try {
+        const appFile = this.project.addSourceFileAtPath(appPath);
+        if (!appFile) continue;
+        const jsxElements = appFile.getDescendantsOfKind(SyntaxKind.JsxElement);
+        const jsxSelfClosing = appFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement);
+        const providerNames = /* @__PURE__ */ new Set();
+        for (const el of [...jsxElements, ...jsxSelfClosing]) {
+          const tagName = el.getFirstDescendantByKind(SyntaxKind.Identifier)?.getText();
+          if (tagName && (tagName.includes("Provider") || tagName.includes("Context"))) {
+            providerNames.add(tagName);
+          }
+        }
+        for (const imp of appFile.getImportDeclarations()) {
+          const spec = imp.getModuleSpecifierValue();
+          if (!spec.startsWith("./") && !spec.startsWith("../")) continue;
+          const namedImports = imp.getNamedImports().map((n) => n.getName());
+          const defaultImport = imp.getDefaultImport()?.getText();
+          for (const providerName of providerNames) {
+            if (namedImports.includes(providerName) || defaultImport === providerName) {
+              const providerQueries = this.analyzeImportedComponent(
+                path.dirname(appPath),
+                spec,
+                providerName,
+                /* @__PURE__ */ new Set(),
+                0
+              );
+              for (const q of providerQueries) {
+                this.globalContextQueries.push({
+                  ...q,
+                  operationName: `[Global] ${q.operationName}`
+                });
+              }
+            }
+          }
+        }
+        if (this.globalContextQueries.length > 0) {
+          this.log(`Found ${this.globalContextQueries.length} global context queries from _app`);
+        }
+        return;
+      } catch {
+      }
+    }
+  }
+  /**
+   * Load codegen mapping from __generated__ folders (optional)
+   * 코드젠 폴더가 있으면 Document → Operation name 매핑 로드
+   */
+  async loadCodegenMapping() {
+    const possibleDirs = [
+      "__generated__",
+      "src/__generated__",
+      "src/__generated__/gql-graphql-gateway",
+      "generated",
+      "src/generated"
+    ];
+    for (const dir of possibleDirs) {
+      const generatedPath = this.resolvePath(dir);
+      try {
+        const files = await fg(["**/*.ts", "**/*.tsx"], {
+          cwd: generatedPath,
+          absolute: true,
+          onlyFiles: true
+        });
+        for (const file of files) {
+          try {
+            const sourceFile = this.project.addSourceFileAtPath(file);
+            const varDecls = sourceFile.getVariableDeclarations();
+            for (const varDecl of varDecls) {
+              const name = varDecl.getName();
+              if (name.endsWith("Document")) {
+                const initializer = varDecl.getInitializer()?.getText() ?? "";
+                const operationMatch = initializer.match(/(?:query|mutation|subscription)\s+(\w+)/);
+                const typeMatch = initializer.match(/(query|mutation|subscription)\s+/);
+                if (operationMatch) {
+                  this.codegenMap.set(name, {
+                    operationName: operationMatch[1],
+                    operationType: typeMatch ? typeMatch[1] : "query"
+                  });
+                }
+              }
+            }
+            const typeAliases = sourceFile.getTypeAliases();
+            for (const typeAlias of typeAliases) {
+              const name = typeAlias.getName();
+              if ((name.endsWith("Query") || name.endsWith("Mutation") || name.endsWith("Subscription")) && !name.endsWith("Variables")) {
+                const docName = name + "Document";
+                if (!this.codegenMap.has(docName)) {
+                  const operationType = name.endsWith("Mutation") ? "mutation" : name.endsWith("Subscription") ? "subscription" : "query";
+                  this.codegenMap.set(docName, {
+                    operationName: name,
+                    operationType
+                  });
+                }
+              }
+            }
+          } catch {
+          }
+        }
+        if (this.codegenMap.size > 0) {
+          this.log(`Loaded ${this.codegenMap.size} codegen mappings from ${dir}`);
+          return;
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Resolve Document name to operation name using codegen map
+   */
+  resolveDocumentName(documentName) {
+    const genericTypeNames = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]);
+    if (genericTypeNames.has(documentName)) {
+      return null;
+    }
+    const directResult = this.codegenMap.get(documentName);
+    if (directResult !== void 0) {
+      return directResult;
+    }
+    const withSuffix = documentName.endsWith("Document") ? documentName : documentName + "Document";
+    const suffixResult = this.codegenMap.get(withSuffix);
+    if (suffixResult !== void 0) {
+      return suffixResult;
+    }
+    return null;
+  }
+  /**
+   * Follow re-export in index file to find the actual component file
+   */
+  followReExport(indexFile, componentName, indexDir) {
+    try {
+      const exportDecls = indexFile.getExportDeclarations();
+      let firstExportFile = null;
+      for (const exportDecl of exportDecls) {
+        const namedExports = exportDecl.getNamedExports();
+        for (const named of namedExports) {
+          const moduleSpec = exportDecl.getModuleSpecifierValue();
+          if (!moduleSpec) continue;
+          const resolvedPath = path.resolve(indexDir, moduleSpec);
+          const possiblePaths = [
+            `${resolvedPath}.tsx`,
+            `${resolvedPath}.ts`,
+            `${resolvedPath}/index.tsx`,
+            `${resolvedPath}/index.ts`
+          ];
+          let file;
+          for (const tryPath of possiblePaths) {
+            try {
+              file = this.project.addSourceFileAtPath(tryPath);
+              if (file) break;
+            } catch {
+            }
+          }
+          if (!file) continue;
+          if (!firstExportFile) {
+            firstExportFile = file;
+          }
+          if (named.getName() === componentName || named.getAliasNode()?.getText() === componentName) {
+            return file;
+          }
+        }
+      }
+      if (firstExportFile) {
+        return firstExportFile;
+      }
+      for (const exportDecl of indexFile.getExportDeclarations()) {
+        if (exportDecl.isNamespaceExport()) {
+          const moduleSpec = exportDecl.getModuleSpecifierValue();
+          if (moduleSpec) {
+            const resolvedPath = path.resolve(indexDir, moduleSpec);
+            const possiblePaths = [`${resolvedPath}.tsx`, `${resolvedPath}.ts`];
+            for (const tryPath of possiblePaths) {
+              try {
+                const file = this.project.addSourceFileAtPath(tryPath);
+                if (file) {
+                  const hasExport = file.getExportedDeclarations().has(componentName);
+                  if (hasExport) return file;
+                }
+              } catch {
+              }
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Check if a name looks like a React component (PascalCase with common suffixes)
+   */
+  isComponentName(name) {
+    if (!/^[A-Z]/.test(name)) return false;
+    if (name.endsWith("Query") || name.endsWith("Mutation") || name.endsWith("Subscription") || name.endsWith("Fragment") || name.endsWith("Document") || name.endsWith("Variables") || name === "Query" || name === "Mutation" || name === "Subscription") {
+      return false;
+    }
+    const typeDefinitions = /* @__PURE__ */ new Set([
+      "NextPage",
+      "NextPageContext",
+      "NextApiRequest",
+      "NextApiResponse",
+      "GetServerSideProps",
+      "GetStaticProps",
+      "GetStaticPaths",
+      "InferGetServerSidePropsType",
+      "InferGetStaticPropsType",
+      "FC",
+      "FunctionComponent",
+      "VFC",
+      "Component",
+      "PureComponent",
+      "ReactNode",
+      "ReactElement",
+      "PropsWithChildren",
+      "ComponentProps",
+      "ComponentType",
+      "ElementType",
+      "RefObject",
+      "MutableRefObject",
+      "Dispatch",
+      "SetStateAction",
+      "ChangeEvent",
+      "MouseEvent",
+      "KeyboardEvent",
+      "FormEvent",
+      "SyntheticEvent"
+    ]);
+    if (typeDefinitions.has(name)) {
+      return false;
+    }
+    const componentSuffixes = [
+      "Container",
+      "Page",
+      "Screen",
+      "View",
+      "Form",
+      "Modal",
+      "Dialog",
+      "Panel",
+      "Root",
+      "Provider",
+      "Wrapper"
+    ];
+    if (componentSuffixes.some((suffix) => name.endsWith(suffix))) {
+      return true;
+    }
+    if (/Page[A-Z]?\w*$/.test(name) || /Container[A-Z]?\w*$/.test(name)) {
+      return true;
+    }
+    if (/^[A-Z][a-z]+[A-Z][a-z]+/.test(name)) {
+      return true;
+    }
+    return false;
+  }
+  extractNavigation(sourceFile) {
+    const result = {
+      visible: true,
+      currentNavItem: null
+    };
+    try {
+      const navStyleAssignment = sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression).find((node) => {
+        try {
+          return node.getName() === "globalNavigationStyle";
+        } catch {
+          return false;
+        }
+      });
+      if (navStyleAssignment) {
+        const parent = navStyleAssignment.getParent();
+        if (Node.isBinaryExpression(parent)) {
+          const right = parent.getRight();
+          const visibleProp = right.getDescendantsOfKind(SyntaxKind.PropertyAssignment).find((prop) => {
+            try {
+              return prop.getName() === "visible";
+            } catch {
+              return false;
+            }
+          });
+          if (visibleProp) {
+            result.visible = visibleProp.getInitializer()?.getText() === "true";
+          }
+          const navItemProp = right.getDescendantsOfKind(SyntaxKind.PropertyAssignment).find((prop) => {
+            try {
+              return prop.getName() === "currentNavItem";
+            } catch {
+              return false;
+            }
+          });
+          if (navItemProp) {
+            const value = navItemProp.getInitializer()?.getText();
+            result.currentNavItem = value && value !== "null" ? value.replace(/['"]/g, "") : null;
+          }
+          const miniProp = right.getDescendantsOfKind(SyntaxKind.PropertyAssignment).find((prop) => {
+            try {
+              return prop.getName() === "mini";
+            } catch {
+              return false;
+            }
+          });
+          if (miniProp) {
+            result.mini = miniProp.getInitializer()?.getText() === "true";
+          }
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  /**
+   * Extract multi-step flow information (wizard, stepper, onboarding)
+   */
+  extractSteps(sourceFile) {
+    const steps = [];
+    const useStateCalls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => call.getExpression().getText() === "useState");
+    for (const call of useStateCalls) {
+      const parent = call.getParent();
+      if (!parent) continue;
+      const parentText = parent.getText();
+      const stepMatch = parentText.match(
+        /\[\s*(step|currentStep|activeStep|page|currentPage|phase|stage)\s*,/i
+      );
+      if (stepMatch) {
+        const stepVarName = stepMatch[1];
+        const switchStatements = sourceFile.getDescendantsOfKind(SyntaxKind.SwitchStatement);
+        for (const switchStmt of switchStatements) {
+          const expression = switchStmt.getExpression().getText();
+          if (expression.includes(stepVarName)) {
+            const caseBlocks = switchStmt.getClauses();
+            caseBlocks.forEach((clause, idx) => {
+              if (clause.isKind(SyntaxKind.CaseClause)) {
+                const caseExpr = clause.getExpression()?.getText() || String(idx);
+                const jsxElements2 = clause.getDescendantsOfKind(SyntaxKind.JsxOpeningElement);
+                const componentName = jsxElements2.length > 0 ? jsxElements2[0].getTagNameNode().getText() : void 0;
+                steps.push({
+                  id: caseExpr.replace(/['"]/g, ""),
+                  name: `Step ${caseExpr.replace(/['"]/g, "")}`,
+                  component: componentName
+                });
+              }
+            });
+          }
+        }
+        const arrayLiterals = sourceFile.getDescendantsOfKind(SyntaxKind.ArrayLiteralExpression);
+        for (const arr of arrayLiterals) {
+          const parentVar = arr.getParent();
+          if (parentVar && parentVar.getText().match(/steps|pages|screens|views|components/i)) {
+            const elements = arr.getElements();
+            elements.forEach((el, idx) => {
+              const elText = el.getText();
+              if (elText.startsWith("{")) {
+                const nameMatch = elText.match(/(?:name|label|title)\s*:\s*['"]([^'"]+)['"]/);
+                const compMatch = elText.match(/(?:component|content)\s*:\s*<?\s*(\w+)/);
+                steps.push({
+                  id: idx + 1,
+                  name: nameMatch ? nameMatch[1] : `Step ${idx + 1}`,
+                  component: compMatch ? compMatch[1] : void 0
+                });
+              } else if (/^[A-Z]/.test(elText)) {
+                steps.push({
+                  id: idx + 1,
+                  name: elText,
+                  component: elText
+                });
+              }
+            });
+          }
+        }
+      }
+    }
+    const jsxElements = sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement);
+    for (const jsx of jsxElements) {
+      const tagName = jsx.getTagNameNode().getText();
+      if (tagName.match(/Stepper|Wizard|Steps|TabPanel|FormStep/i)) {
+        const parent = jsx.getParent();
+        if (parent && parent.isKind(SyntaxKind.JsxElement)) {
+          const children = parent.getJsxChildren();
+          children.forEach((child, idx) => {
+            if (child.isKind(SyntaxKind.JsxElement) || child.isKind(SyntaxKind.JsxSelfClosingElement)) {
+              const childTag = child.isKind(SyntaxKind.JsxElement) ? child.getOpeningElement().getTagNameNode().getText() : child.getTagNameNode().getText();
+              const attrs = child.isKind(SyntaxKind.JsxElement) ? child.getOpeningElement().getAttributes() : child.getAttributes();
+              let stepName = childTag;
+              for (const attr of attrs) {
+                if (attr.isKind(SyntaxKind.JsxAttribute)) {
+                  const name = attr.getNameNode().getText();
+                  if (name === "label" || name === "title" || name === "name") {
+                    const value = attr.getInitializer()?.getText();
+                    if (value) {
+                      stepName = value.replace(/['"{}]/g, "");
+                      break;
+                    }
+                  }
+                }
+              }
+              steps.push({
+                id: idx + 1,
+                name: stepName,
+                component: childTag
+              });
+            }
+          });
+        }
+      }
+    }
+    const conditionalExprs = sourceFile.getDescendantsOfKind(SyntaxKind.ConditionalExpression);
+    for (const cond of conditionalExprs) {
+      const condition = cond.getCondition().getText();
+      if (condition.match(/step\s*===?\s*\d+|currentStep|activeStep/i)) {
+        const whenTrue = cond.getWhenTrue();
+        const stepNumMatch = condition.match(/===?\s*(\d+)/);
+        if (stepNumMatch && steps.length === 0) {
+          const trueJsx = whenTrue.getDescendantsOfKind(SyntaxKind.JsxOpeningElement);
+          if (trueJsx.length > 0) {
+            steps.push({
+              id: parseInt(stepNumMatch[1]),
+              component: trueJsx[0].getTagNameNode().getText()
+            });
+          }
+        }
+      }
+    }
+    return steps;
+  }
+  extractLinkedPages(sourceFile) {
+    const linkedPages = [];
+    const routerCalls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => {
+      const text = call.getExpression().getText();
+      return text.includes("router.push") || text.includes("router.replace") || text.includes("Link");
+    });
+    for (const call of routerCalls) {
+      const args = call.getArguments();
+      if (args.length > 0) {
+        const pathArg = args[0].getText();
+        const pathMatch = pathArg.match(/['"`]([^'"`]+)['"`]/);
+        if (pathMatch && !linkedPages.includes(pathMatch[1])) {
+          linkedPages.push(pathMatch[1]);
+        }
+      }
+    }
+    const linkElements = sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement).filter((node) => node.getTagNameNode().getText() === "Link");
+    for (const link of linkElements) {
+      try {
+        const attributes = link.getAttributes();
+        for (const attr of attributes) {
+          if (attr.isKind(SyntaxKind.JsxAttribute)) {
+            const nameNode = attr.getNameNode();
+            const name = nameNode.getText();
+            if (name === "href") {
+              const value = attr.getInitializer()?.getText();
+              if (value) {
+                const pathMatch = value.match(/['"`]([^'"`]+)['"`]/);
+                if (pathMatch && !linkedPages.includes(pathMatch[1])) {
+                  linkedPages.push(pathMatch[1]);
+                }
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return linkedPages;
+  }
+};
+var GraphQLAnalyzer = class extends BaseAnalyzer {
+  project;
+  constructor(config) {
+    super(config);
+    this.project = new Project({
+      tsConfigFilePath: this.resolvePath("tsconfig.json"),
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  getName() {
+    return "GraphQLAnalyzer";
+  }
+  async analyze() {
+    this.log("Starting GraphQL analysis...");
+    const operations = [];
+    const graphqlOperations = await this.analyzeGraphQLFiles();
+    operations.push(...graphqlOperations);
+    const inlineOperations = await this.analyzeInlineGraphQL();
+    operations.push(...inlineOperations);
+    await this.findOperationUsage(operations);
+    this.log(`Found ${operations.length} GraphQL operations`);
+    return { graphqlOperations: operations };
+  }
+  async analyzeGraphQLFiles() {
+    const graphqlFiles = await fg(["**/*.graphql"], {
+      cwd: this.basePath,
+      ignore: ["**/node_modules/**", "**/.next/**"],
+      absolute: true
+    });
+    const results = await parallelMapSafe(graphqlFiles, async (filePath) => {
+      const content = await fs2.readFile(filePath, "utf-8");
+      const document = parse(content);
+      return this.extractOperationsFromDocument(document, path.relative(this.basePath, filePath));
+    });
+    return results.flat();
+  }
+  async analyzeInlineGraphQL() {
+    const operations = [];
+    const tsFiles = await fg(["**/*.ts", "**/*.tsx"], {
+      cwd: this.basePath,
+      ignore: [
+        "**/node_modules/**",
+        "**/.next/**",
+        "**/__tests__/**",
+        "**/*.test.*",
+        "**/*.spec.*"
+      ],
+      absolute: true
+    });
+    for (const filePath of tsFiles) {
+      try {
+        const sourceFile = this.project.addSourceFileAtPath(filePath);
+        const relativePath = path.relative(this.basePath, filePath);
+        const hasGqlImport = sourceFile.getImportDeclarations().some((imp) => {
+          const spec = imp.getModuleSpecifierValue();
+          const namedImports = imp.getNamedImports().map((n) => n.getName());
+          const defaultImport = imp.getDefaultImport()?.getText();
+          return (namedImports.includes("gql") || namedImports.includes("graphql") || defaultImport === "gql") && (spec.includes("graphql") || spec.includes("apollo") || spec.includes("gql") || spec.includes("__generated__"));
+        });
+        const taggedTemplates = sourceFile.getDescendantsOfKind(
+          SyntaxKind.TaggedTemplateExpression
+        );
+        for (const template of taggedTemplates) {
+          const tag = template.getTag().getText();
+          if (tag === "gql" || tag === "graphql") {
+            try {
+              const templateLiteral = template.getTemplate();
+              let content = "";
+              if (templateLiteral.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)) {
+                content = templateLiteral.getLiteralValue();
+              } else if (templateLiteral.isKind(SyntaxKind.TemplateExpression)) {
+                const fullText = templateLiteral.getText();
+                content = fullText.slice(1, -1).replace(/\$\{[^}]*\}/g, "");
+              }
+              if (content && content.trim()) {
+                try {
+                  const document = parse(content);
+                  const fileOperations = this.extractOperationsFromDocument(document, relativePath);
+                  operations.push(...fileOperations);
+                } catch {
+                }
+              }
+            } catch {
+            }
+          }
+        }
+        const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+        for (const call of callExpressions) {
+          try {
+            const expression = call.getExpression();
+            const expressionText = expression.getText();
+            if (expressionText === "gql" || expressionText === "graphql") {
+              const args = call.getArguments();
+              if (args.length > 0) {
+                const firstArg = args[0];
+                let content = "";
+                if (firstArg.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)) {
+                  content = firstArg.getLiteralValue();
+                } else if (firstArg.isKind(SyntaxKind.TemplateExpression)) {
+                  const fullText = firstArg.getText();
+                  content = fullText.slice(1, -1).replace(/\$\{[^}]*\}/g, "");
+                } else {
+                  const argText = firstArg.getText();
+                  if (argText.includes("`")) {
+                    const match = argText.match(/\/\*\s*GraphQL\s*\*\/\s*`([^`]*)`/);
+                    if (match) {
+                      content = match[1];
+                    } else {
+                      const simpleMatch = argText.match(/`([^`]*)`/);
+                      if (simpleMatch) {
+                        content = simpleMatch[1];
+                      }
+                    }
+                  }
+                }
+                if (content && content.trim()) {
+                  try {
+                    const document = parse(content);
+                    const fileOperations = this.extractOperationsFromDocument(
+                      document,
+                      relativePath
+                    );
+                    operations.push(...fileOperations);
+                  } catch {
+                  }
+                }
+              }
+            }
+          } catch {
+          }
+        }
+        if (hasGqlImport) {
+          const variableDeclarations = sourceFile.getVariableDeclarations();
+          for (const varDecl of variableDeclarations) {
+            const name = varDecl.getName();
+            const isGraphQLLike = name.includes("QUERY") || name.includes("MUTATION") || name.includes("FRAGMENT") || name.includes("Query") || name.includes("Mutation") || name.includes("Subscription") || // SCREAMING_CASE constants ending in related words
+            /^[A-Z_]+_(QUERY|MUTATION|FRAGMENT|SUBSCRIPTION)$/.test(name) || // PascalCase Query suffix
+            /Query$|Mutation$|Fragment$|Subscription$/.test(name);
+            if (isGraphQLLike) {
+              const initializer = varDecl.getInitializer();
+              if (initializer && initializer.isKind(SyntaxKind.CallExpression)) {
+              }
+            }
+          }
+        }
+      } catch (error) {
+        this.warn(`Failed to analyze ${filePath}: ${error.message}`);
+      }
+    }
+    return operations;
+  }
+  extractOperationsFromDocument(document, filePath) {
+    const operations = [];
+    for (const definition of document.definitions) {
+      const operation = this.extractOperation(definition, filePath);
+      if (operation) {
+        operations.push(operation);
+      }
+    }
+    return operations;
+  }
+  extractOperation(definition, filePath) {
+    if (definition.kind === "OperationDefinition") {
+      const name = definition.name?.value || "anonymous";
+      const type = definition.operation;
+      const variables = this.extractVariables(definition);
+      const fragments = this.extractFragmentReferences(definition);
+      const fields = this.extractFields(definition);
+      return {
+        name,
+        type,
+        filePath,
+        usedIn: [],
+        variables,
+        returnType: this.inferReturnType(definition),
+        fragments,
+        fields
+      };
+    }
+    if (definition.kind === "FragmentDefinition") {
+      return {
+        name: definition.name.value,
+        type: "fragment",
+        filePath,
+        usedIn: [],
+        variables: [],
+        returnType: definition.typeCondition.name.value,
+        fragments: this.extractFragmentReferences(definition),
+        fields: this.extractFields(definition)
+      };
+    }
+    return null;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  extractFields(definition) {
+    const fields = [];
+    const extractFromSelectionSet = (selectionSet, depth = 0) => {
+      if (!selectionSet || !selectionSet.selections || depth > 5) return [];
+      const result = [];
+      for (const selection of selectionSet.selections) {
+        if (selection.kind === "Field") {
+          const field = {
+            name: selection.name.value
+          };
+          if (selection.arguments && selection.arguments.length > 0) {
+            const args = selection.arguments.map((arg) => arg.name.value).join(", ");
+            field.type = `(${args})`;
+          }
+          if (selection.selectionSet) {
+            field.fields = extractFromSelectionSet(selection.selectionSet, depth + 1);
+          }
+          result.push(field);
+        } else if (selection.kind === "FragmentSpread") {
+          result.push({ name: `...${selection.name.value}`, type: "fragment" });
+        } else if (selection.kind === "InlineFragment") {
+          if (selection.selectionSet) {
+            const typeName = selection.typeCondition?.name?.value || "inline";
+            result.push({
+              name: `... on ${typeName}`,
+              type: "inline-fragment",
+              fields: extractFromSelectionSet(selection.selectionSet, depth + 1)
+            });
+          }
+        }
+      }
+      return result;
+    };
+    if (definition.selectionSet) {
+      return extractFromSelectionSet(definition.selectionSet);
+    }
+    return fields;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  extractVariables(definition) {
+    const variables = [];
+    if (definition.variableDefinitions) {
+      for (const varDef of definition.variableDefinitions) {
+        const name = varDef.variable.name.value;
+        const type = this.typeNodeToString(varDef.type);
+        const required = varDef.type.kind === "NonNullType";
+        variables.push({ name, type, required });
+      }
+    }
+    return variables;
+  }
+  typeNodeToString(typeNode) {
+    if (typeNode.kind === "NonNullType") {
+      return `${this.typeNodeToString(typeNode.type)}!`;
+    }
+    if (typeNode.kind === "ListType") {
+      return `[${this.typeNodeToString(typeNode.type)}]`;
+    }
+    if (typeNode.kind === "NamedType") {
+      return typeNode.name.value;
+    }
+    return "unknown";
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  extractFragmentReferences(definition) {
+    const fragments = [];
+    const visit = (node) => {
+      if (!node) return;
+      if (node.kind === "FragmentSpread") {
+        fragments.push(node.name.value);
+      }
+      if (node.selectionSet) {
+        for (const selection of node.selectionSet.selections) {
+          visit(selection);
+        }
+      }
+    };
+    visit(definition);
+    return fragments;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  inferReturnType(definition) {
+    if (definition.selectionSet && definition.selectionSet.selections.length > 0) {
+      const firstSelection = definition.selectionSet.selections[0];
+      if (firstSelection.kind === "Field") {
+        return firstSelection.name.value;
+      }
+    }
+    return "unknown";
+  }
+  async findOperationUsage(operations) {
+    const tsFiles = await fg(["**/*.ts", "**/*.tsx"], {
+      cwd: this.basePath,
+      ignore: ["**/node_modules/**", "**/.next/**"],
+      absolute: true
+    });
+    const operationNames = /* @__PURE__ */ new Map();
+    for (const op of operations) {
+      operationNames.set(op.name, op);
+    }
+    for (const filePath of tsFiles) {
+      try {
+        const content = await fs2.readFile(filePath, "utf-8");
+        const relativePath = path.relative(this.basePath, filePath);
+        for (const [name, operation] of operationNames) {
+          if (content.includes(`useQuery<${name}`) || content.includes(`useMutation<${name}`) || content.includes(`useLazyQuery<${name}`) || content.includes(`${name}Query`) || content.includes(`${name}Mutation`) || content.includes(`${name}Variables`)) {
+            if (!operation.usedIn.includes(relativePath)) {
+              operation.usedIn.push(relativePath);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+};
+var DataFlowAnalyzer = class extends BaseAnalyzer {
+  project;
+  componentCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super(config);
+    this.project = new Project({
+      tsConfigFilePath: this.resolvePath("tsconfig.json"),
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  getName() {
+    return "DataFlowAnalyzer";
+  }
+  async analyze() {
+    this.log("Starting data flow analysis...");
+    const components = await this.analyzeComponents();
+    const dataFlows = await this.analyzeDataFlows(components);
+    this.log(`Analyzed ${components.length} components and ${dataFlows.length} data flows`);
+    return { components, dataFlows };
+  }
+  async analyzeComponents() {
+    const components = [];
+    const configuredDirs = [
+      this.getSetting("featuresDir", ""),
+      this.getSetting("componentsDir", ""),
+      this.getSetting("pagesDir", "")
+    ].filter(Boolean);
+    const commonDirs = [
+      "src/features",
+      "src/components",
+      "src/common/components",
+      "src/common",
+      "src/pages",
+      "src/app",
+      "src/modules",
+      "src/views",
+      "src/screens",
+      "components",
+      "pages",
+      "app"
+    ];
+    const dirs = [.../* @__PURE__ */ new Set([...configuredDirs, ...commonDirs])];
+    for (const dir of dirs) {
+      const files = await fg(["**/*.tsx"], {
+        cwd: this.resolvePath(dir),
+        ignore: ["**/*.test.*", "**/*.spec.*", "**/*.stories.*"],
+        absolute: true
+      });
+      for (const filePath of files) {
+        try {
+          const sourceFile = this.project.addSourceFileAtPath(filePath);
+          const relativePath = path.relative(this.basePath, filePath);
+          const componentInfos = this.analyzeComponentFile(sourceFile, relativePath);
+          components.push(...componentInfos);
+        } catch (error) {
+          this.warn(`Failed to analyze ${filePath}: ${error.message}`);
+        }
+      }
+    }
+    this.buildDependencyGraph(components);
+    return components;
+  }
+  analyzeComponentFile(sourceFile, filePath) {
+    const components = [];
+    const functionDeclarations = sourceFile.getFunctions();
+    for (const func of functionDeclarations) {
+      const name = func.getName();
+      if (name && this.isComponentName(name)) {
+        const info = this.extractComponentInfo(func, name, filePath);
+        components.push(info);
+        this.componentCache.set(name, info);
+      }
+    }
+    const variableDeclarations = sourceFile.getVariableDeclarations();
+    for (const varDecl of variableDeclarations) {
+      const name = varDecl.getName();
+      if (this.isComponentName(name)) {
+        const initializer = varDecl.getInitializer();
+        if (initializer && (initializer.isKind(SyntaxKind.ArrowFunction) || initializer.isKind(SyntaxKind.FunctionExpression))) {
+          const info = this.extractComponentInfo(initializer, name, filePath);
+          components.push(info);
+          this.componentCache.set(name, info);
+        }
+      }
+    }
+    const hookFunctions = sourceFile.getFunctions().filter((f) => {
+      const name = f.getName();
+      return name && name.startsWith("use");
+    });
+    for (const hook of hookFunctions) {
+      const name = hook.getName() ?? "";
+      const info = this.extractHookInfo(hook, name, filePath);
+      components.push(info);
+      this.componentCache.set(name, info);
+    }
+    return components;
+  }
+  isComponentName(name) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+  }
+  extractComponentInfo(node, name, filePath) {
+    const sourceFile = node.getSourceFile();
+    let type = "presentational";
+    const pagePathPatterns = ["/pages/", "/app/", "/routes/", "/views/", "/screens/"];
+    if (pagePathPatterns.some((pattern) => filePath.includes(pattern))) {
+      type = "page";
+    } else if (name.includes("Container") || name.includes("Provider")) {
+      type = "container";
+    } else if (
+      // Layout detection - various naming patterns
+      name.includes("Layout") || name.includes("Shell") || name.includes("Wrapper") || name.includes("Frame") || name.includes("Scaffold") || // Path-based layout detection
+      filePath.includes("/layouts/") || filePath.includes("/layout/")
+    ) {
+      type = "layout";
+    }
+    const props = this.extractProps(node);
+    const hooks = this.extractHooksUsed(node);
+    const dependencies = this.extractDependencies(sourceFile);
+    const stateManagement = this.extractStateManagement(node);
+    return {
+      name,
+      filePath,
+      type,
+      props,
+      dependencies,
+      dependents: [],
+      // Will be filled later
+      hooks,
+      stateManagement
+    };
+  }
+  extractHookInfo(node, name, filePath) {
+    const sourceFile = node.getSourceFile();
+    const props = this.extractProps(node);
+    const hooks = this.extractHooksUsed(node);
+    const dependencies = this.extractDependencies(sourceFile);
+    const stateManagement = this.extractStateManagement(node);
+    return {
+      name,
+      filePath,
+      type: "hook",
+      props,
+      dependencies,
+      dependents: [],
+      hooks,
+      stateManagement
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  extractProps(node) {
+    const props = [];
+    const parameters = node.getParameters?.() || [];
+    if (parameters.length > 0) {
+      const propsParam = parameters[0];
+      const typeNode = propsParam.getTypeNode?.();
+      if (typeNode) {
+        const members = typeNode.getDescendantsOfKind?.(SyntaxKind.PropertySignature) || [];
+        for (const member of members) {
+          props.push({
+            name: member.getName(),
+            type: member.getType().getText(),
+            required: !member.hasQuestionToken()
+          });
+        }
+      }
+    }
+    return props;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  extractHooksUsed(node) {
+    const hooks = [];
+    const callExpressions = node.getDescendantsOfKind?.(SyntaxKind.CallExpression) || [];
+    for (const call of callExpressions) {
+      try {
+        const callName = call.getExpression().getText();
+        if (callName.startsWith("use")) {
+          if (callName === "useQuery" || callName === "useMutation" || callName === "useLazyQuery") {
+            const operationInfo = this.extractOperationName(call, callName);
+            if (!hooks.includes(operationInfo)) {
+              hooks.push(operationInfo);
+            }
+          } else if (callName === "useContext") {
+            const contextInfo = this.extractContextName(call);
+            if (!hooks.includes(contextInfo)) {
+              hooks.push(contextInfo);
+            }
+          } else if (!hooks.includes(callName)) {
+            hooks.push(callName);
+          }
+        }
+      } catch {
+      }
+    }
+    return hooks;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  extractOperationName(call, hookType) {
+    try {
+      const args = call.getArguments?.() || [];
+      if (args.length > 0) {
+        const firstArg = args[0].getText();
+        const cleanName = firstArg.replace(/^(GET_|FETCH_|CREATE_|UPDATE_|DELETE_)/, "").replace(/_QUERY$|_MUTATION$/, "").replace(/Document$/, "").replace(/Query$|Mutation$/, "");
+        const icon = hookType === "useMutation" ? "\u270F\uFE0F" : "\u{1F4E1}";
+        const type = hookType === "useMutation" ? "Mutation" : "Query";
+        return `${icon} ${type}: ${cleanName}`;
+      }
+    } catch {
+    }
+    return hookType;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  extractContextName(call) {
+    try {
+      const args = call.getArguments?.() || [];
+      if (args.length > 0) {
+        const contextName = args[0].getText().replace(/Context$/, "").replace(/^Session|^Token|^Apollo/, (m) => m);
+        return `\u{1F504} Context: ${contextName}`;
+      }
+    } catch {
+    }
+    return "useContext";
+  }
+  extractDependencies(sourceFile) {
+    const dependencies = [];
+    const importDeclarations = sourceFile.getImportDeclarations();
+    for (const importDecl of importDeclarations) {
+      const moduleSpecifier = importDecl.getModuleSpecifierValue();
+      if (moduleSpecifier.startsWith(".") || moduleSpecifier.startsWith("@/")) {
+        const namedImports = importDecl.getNamedImports();
+        for (const namedImport of namedImports) {
+          const name = namedImport.getName();
+          if (this.isComponentName(name) || name.startsWith("use")) {
+            dependencies.push(name);
+          }
+        }
+        const defaultImport = importDecl.getDefaultImport();
+        if (defaultImport) {
+          const name = defaultImport.getText();
+          if (this.isComponentName(name)) {
+            dependencies.push(name);
+          }
+        }
+      }
+    }
+    return dependencies;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  extractStateManagement(node) {
+    const statePatterns = [];
+    const nodeText = node.getText?.() || "";
+    if (nodeText.includes("useState")) statePatterns.push("useState");
+    if (nodeText.includes("useReducer")) statePatterns.push("useReducer");
+    if (nodeText.includes("useContext")) statePatterns.push("useContext");
+    if (nodeText.includes("useQuery")) statePatterns.push("Apollo Query");
+    if (nodeText.includes("useMutation")) statePatterns.push("Apollo Mutation");
+    if (nodeText.includes("useRecoil")) statePatterns.push("Recoil");
+    if (nodeText.includes("useSelector") || nodeText.includes("useDispatch")) {
+      statePatterns.push("Redux");
+    }
+    return statePatterns;
+  }
+  buildDependencyGraph(components) {
+    const componentMap = /* @__PURE__ */ new Map();
+    for (const comp of components) {
+      componentMap.set(comp.name, comp);
+    }
+    for (const comp of components) {
+      for (const dep of comp.dependencies) {
+        const depComponent = componentMap.get(dep);
+        if (depComponent && !depComponent.dependents.includes(comp.name)) {
+          depComponent.dependents.push(comp.name);
+        }
+      }
+    }
+  }
+  async analyzeDataFlows(components) {
+    const dataFlows = [];
+    let flowId = 1;
+    const contextFlows = this.analyzeContextFlows(components);
+    dataFlows.push(...contextFlows.map((flow) => ({ ...flow, id: `flow-${flowId++}` })));
+    const apolloFlows = this.analyzeApolloFlows(components);
+    dataFlows.push(...apolloFlows.map((flow) => ({ ...flow, id: `flow-${flowId++}` })));
+    const propDrillingFlows = this.analyzePropDrilling(components);
+    dataFlows.push(...propDrillingFlows.map((flow) => ({ ...flow, id: `flow-${flowId++}` })));
+    return dataFlows;
+  }
+  analyzeContextFlows(components) {
+    const flows = [];
+    const providers = components.filter(
+      (c) => c.name.includes("Provider") || c.name.includes("Context")
+    );
+    const consumers = components.filter((c) => c.hooks.some((h) => h.includes("Context")));
+    for (const provider of providers) {
+      const contextName = provider.name.replace("Provider", "").replace("Context", "");
+      for (const consumer of consumers) {
+        const contextHook = consumer.hooks.find(
+          (h) => h.includes("Context") && h.includes(contextName)
+        );
+        if (contextHook || consumer.hooks.some((h) => h.includes(contextName))) {
+          flows.push({
+            name: `\u{1F504} ${contextName} Context`,
+            description: `Data flows from ${provider.name} to ${consumer.name} via Context`,
+            source: { type: "context", name: provider.name },
+            target: { type: "component", name: consumer.name },
+            via: [],
+            operations: [contextHook || `useContext(${contextName})`]
+          });
+        }
+      }
+    }
+    return flows;
+  }
+  analyzeApolloFlows(components) {
+    const flows = [];
+    for (const comp of components) {
+      const queryHooks = comp.hooks.filter(
+        (h) => h.includes("Query:") || h === "useQuery" || h === "useLazyQuery"
+      );
+      for (const hook of queryHooks) {
+        const operationName = hook.includes(":") ? hook.split(":")[1].trim() : comp.name;
+        flows.push({
+          name: `\u{1F4E1} ${operationName}`,
+          description: `${comp.name} fetches ${operationName} via Apollo`,
+          source: { type: "api", name: `GraphQL: ${operationName}` },
+          target: { type: "component", name: comp.name },
+          via: [{ type: "cache", name: "Apollo Cache" }],
+          operations: [hook]
+        });
+      }
+      const mutationHooks = comp.hooks.filter(
+        (h) => h.includes("Mutation:") || h === "useMutation"
+      );
+      for (const hook of mutationHooks) {
+        const operationName = hook.includes(":") ? hook.split(":")[1].trim() : comp.name;
+        flows.push({
+          name: `\u270F\uFE0F ${operationName}`,
+          description: `${comp.name} mutates ${operationName} via Apollo`,
+          source: { type: "component", name: comp.name },
+          target: { type: "api", name: `GraphQL: ${operationName}` },
+          via: [],
+          operations: [hook]
+        });
+      }
+    }
+    return flows;
+  }
+  analyzePropDrilling(components) {
+    const flows = [];
+    for (const comp of components) {
+      if (comp.props.length > 5 && comp.dependents.length > 0) {
+        flows.push({
+          name: `Prop Drilling through ${comp.name}`,
+          description: `${comp.name} passes ${comp.props.length} props to children`,
+          source: { type: "component", name: comp.name },
+          target: { type: "component", name: comp.dependents[0] },
+          via: [],
+          operations: ["props"]
+        });
+      }
+    }
+    return flows;
+  }
+};
+var RestApiAnalyzer = class extends BaseAnalyzer {
+  project;
+  apiCallCounter = 0;
+  constructor(config) {
+    super(config);
+    this.project = new Project({
+      tsConfigFilePath: this.resolvePath("tsconfig.json"),
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  getName() {
+    return "RestApiAnalyzer";
+  }
+  async analyze() {
+    this.log("Starting REST API analysis...");
+    const tsFiles = await fg(["**/*.ts", "**/*.tsx"], {
+      cwd: this.basePath,
+      ignore: [
+        "**/node_modules/**",
+        "**/.next/**",
+        "**/__tests__/**",
+        "**/*.test.*",
+        "**/*.spec.*",
+        "**/*.stories.*",
+        "**/__generated__/**",
+        "**/dist/**",
+        "**/build/**"
+      ],
+      absolute: true
+    });
+    const sourceFiles = /* @__PURE__ */ new Map();
+    for (const filePath of tsFiles) {
+      try {
+        sourceFiles.set(filePath, this.project.addSourceFileAtPath(filePath));
+      } catch {
+      }
+    }
+    const results = await parallelMapSafe(
+      Array.from(sourceFiles.entries()),
+      async ([filePath, sourceFile]) => {
+        const relativePath = path.relative(this.basePath, filePath);
+        const calls = [];
+        calls.push(...this.findFetchCalls(sourceFile, relativePath));
+        calls.push(...this.findAxiosCalls(sourceFile, relativePath));
+        calls.push(...this.findSwrCalls(sourceFile, relativePath));
+        return calls;
+      },
+      8
+    );
+    const apiCalls = results.flat();
+    this.log(`Found ${apiCalls.length} REST API calls`);
+    return { apiCalls };
+  }
+  /**
+   * Find fetch() calls
+   */
+  findFetchCalls(sourceFile, filePath) {
+    const calls = [];
+    const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const call of callExpressions) {
+      try {
+        const expression = call.getExpression();
+        const expressionText = expression.getText();
+        if (expressionText === "fetch" || expressionText === "window.fetch") {
+          const apiCall = this.extractFetchCall(call, filePath);
+          if (apiCall) {
+            calls.push(apiCall);
+          }
+        }
+      } catch {
+      }
+    }
+    return calls;
+  }
+  /**
+   * Find axios calls (axios.get, axios.post, etc.)
+   */
+  findAxiosCalls(sourceFile, filePath) {
+    const calls = [];
+    const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const call of callExpressions) {
+      try {
+        const expression = call.getExpression();
+        const expressionText = expression.getText();
+        const axiosMatch = expressionText.match(/^axios\.(get|post|put|delete|patch)$/i);
+        if (axiosMatch) {
+          const apiCall = this.extractAxiosCall(call, filePath, axiosMatch[1].toUpperCase());
+          if (apiCall) {
+            calls.push(apiCall);
+          }
+        }
+        if (expressionText === "axios") {
+          const apiCall = this.extractAxiosDirectCall(call, filePath);
+          if (apiCall) {
+            calls.push(apiCall);
+          }
+        }
+      } catch {
+      }
+    }
+    return calls;
+  }
+  /**
+   * Find useSWR calls
+   */
+  findSwrCalls(sourceFile, filePath) {
+    const calls = [];
+    const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const call of callExpressions) {
+      try {
+        const expression = call.getExpression();
+        const expressionText = expression.getText();
+        if (expressionText === "useSWR" || expressionText === "useSWRImmutable") {
+          const apiCall = this.extractSwrCall(call, filePath);
+          if (apiCall) {
+            calls.push(apiCall);
+          }
+        }
+      } catch {
+      }
+    }
+    return calls;
+  }
+  /**
+   * Extract API call info from fetch()
+   */
+  extractFetchCall(call, filePath) {
+    const args = call.getArguments();
+    if (args.length === 0) return null;
+    const urlArg = args[0].getText();
+    const urlInfo = this.extractUrlFromArg(urlArg);
+    if (!urlInfo.url) return null;
+    if (!urlInfo.isPlaceholder && !this.isApiUrl(urlInfo.url)) return null;
+    let method = "GET";
+    let requiresAuth = false;
+    if (args.length > 1) {
+      const optionsText = args[1].getText();
+      const methodMatch = optionsText.match(/method:\s*["'](\w+)["']/i);
+      if (methodMatch) {
+        method = this.normalizeMethod(methodMatch[1]);
+      }
+      requiresAuth = optionsText.includes("credentials") || optionsText.includes("Authorization") || optionsText.includes("withCredentials");
+    }
+    const containingFunction = this.getContainingFunctionName(call);
+    const line = call.getStartLineNumber();
+    return {
+      id: `api-${++this.apiCallCounter}`,
+      method,
+      url: urlInfo.url,
+      callType: "fetch",
+      filePath,
+      line,
+      containingFunction,
+      usedIn: [],
+      requiresAuth,
+      category: this.categorizeApi(urlInfo.url)
+    };
+  }
+  /**
+   * Extract API call info from axios.method()
+   */
+  extractAxiosCall(call, filePath, method) {
+    const args = call.getArguments();
+    if (args.length === 0) return null;
+    const urlArg = args[0].getText();
+    const urlInfo = this.extractUrlFromArg(urlArg);
+    if (!urlInfo.url) return null;
+    let requiresAuth = false;
+    if (args.length > 1) {
+      const optionsText = args[args.length - 1].getText();
+      requiresAuth = optionsText.includes("withCredentials") || optionsText.includes("Authorization");
+    }
+    const containingFunction = this.getContainingFunctionName(call);
+    const line = call.getStartLineNumber();
+    return {
+      id: `api-${++this.apiCallCounter}`,
+      method: this.normalizeMethod(method),
+      url: urlInfo.url,
+      callType: "axios",
+      filePath,
+      line,
+      containingFunction,
+      usedIn: [],
+      requiresAuth,
+      category: this.categorizeApi(urlInfo.url)
+    };
+  }
+  /**
+   * Extract API call info from axios() direct call
+   */
+  extractAxiosDirectCall(call, filePath) {
+    const args = call.getArguments();
+    if (args.length === 0) return null;
+    const configText = args[0].getText();
+    const urlMatch = configText.match(/url:\s*["'`]([^"'`]+)["'`]/);
+    const methodMatch = configText.match(/method:\s*["'](\w+)["']/i);
+    if (!urlMatch) return null;
+    const url = urlMatch[1];
+    const method = methodMatch ? this.normalizeMethod(methodMatch[1]) : "GET";
+    const requiresAuth = configText.includes("withCredentials") || configText.includes("Authorization");
+    const containingFunction = this.getContainingFunctionName(call);
+    const line = call.getStartLineNumber();
+    return {
+      id: `api-${++this.apiCallCounter}`,
+      method,
+      url,
+      callType: "axios",
+      filePath,
+      line,
+      containingFunction,
+      usedIn: [],
+      requiresAuth,
+      category: this.categorizeApi(url)
+    };
+  }
+  /**
+   * Extract API call info from useSWR()
+   */
+  extractSwrCall(call, filePath) {
+    const args = call.getArguments();
+    if (args.length === 0) return null;
+    const keyArg = args[0].getText();
+    let url = null;
+    if (keyArg.startsWith('"') || keyArg.startsWith("'") || keyArg.startsWith("`")) {
+      url = this.cleanStringLiteral(keyArg);
+    } else if (keyArg.includes("?") && keyArg.includes(":")) {
+      let match = keyArg.match(/\?\s*["'`]([^"'`]+)["'`]/);
+      if (match) {
+        url = match[1];
+      } else {
+        match = keyArg.match(/:\s*["'`]([^"'`]+)["'`]/);
+        if (match) {
+          url = match[1];
+        }
+      }
+      if (!url) {
+        match = keyArg.match(/\?\s*`([^`]+)`/);
+        if (match) {
+          url = match[1].replace(/\$\{[^}]+\}/g, ":param");
+        }
+      }
+    } else {
+      const urlInfo = this.extractUrlFromArg(keyArg);
+      if (urlInfo.url && !keyArg.includes("null") && !keyArg.includes("undefined")) {
+        url = urlInfo.url;
+      }
+    }
+    if (!url) return null;
+    const containingFunction = this.getContainingFunctionName(call);
+    const line = call.getStartLineNumber();
+    return {
+      id: `api-${++this.apiCallCounter}`,
+      method: "GET",
+      // SWR is typically for GET requests
+      url,
+      callType: "useSWR",
+      filePath,
+      line,
+      containingFunction,
+      usedIn: [],
+      requiresAuth: false,
+      category: this.categorizeApi(url)
+    };
+  }
+  /**
+   * Get the name of the containing function/component
+   */
+  getContainingFunctionName(node) {
+    let current = node;
+    while (current) {
+      if (Node.isFunctionDeclaration(current)) {
+        return current.getName() || "anonymous";
+      }
+      if (Node.isVariableDeclaration(current)) {
+        return current.getName();
+      }
+      if (Node.isMethodDeclaration(current)) {
+        return current.getName();
+      }
+      if (Node.isArrowFunction(current)) {
+        const parent = current.getParent();
+        if (parent && Node.isVariableDeclaration(parent)) {
+          return parent.getName();
+        }
+      }
+      current = current.getParent();
+    }
+    return "unknown";
+  }
+  /**
+   * Extract URL from argument (handles literals, variables, function calls)
+   */
+  extractUrlFromArg(argText) {
+    if (/^["'`]/.test(argText)) {
+      const url = this.cleanStringLiteral(argText);
+      return { url, isPlaceholder: false };
+    }
+    const funcCallMatch = argText.match(/^(\w+)\s*\(\s*["'`]([^"'`]+)["'`]/);
+    if (funcCallMatch) {
+      return { url: `[${funcCallMatch[1]}] ${funcCallMatch[2]}`, isPlaceholder: true };
+    }
+    const funcTemplateMatch = argText.match(/^(\w+)\s*\(\s*`([^`]+)`/);
+    if (funcTemplateMatch) {
+      const path5 = funcTemplateMatch[2].replace(/\$\{[^}]+\}/g, ":param");
+      return { url: `[${funcTemplateMatch[1]}] ${path5}`, isPlaceholder: true };
+    }
+    if (/^\w+(\.\w+)*$/.test(argText)) {
+      return { url: `[${argText}]`, isPlaceholder: true };
+    }
+    if (argText.includes(".")) {
+      return { url: `[${argText}]`, isPlaceholder: true };
+    }
+    return { url: null, isPlaceholder: false };
+  }
+  /**
+   * Clean string literal (remove quotes)
+   */
+  cleanStringLiteral(value) {
+    const cleaned = value.replace(/^["'`]|["'`]$/g, "").trim();
+    if (cleaned.includes("${")) {
+      const parameterized = cleaned.replace(/\$\{[^}]+\}/g, ":param");
+      return parameterized;
+    }
+    return cleaned || null;
+  }
+  /**
+   * Check if URL looks like an API endpoint
+   */
+  isApiUrl(url) {
+    if (url.startsWith("data:") || url.startsWith("blob:")) {
+      return false;
+    }
+    if (/\.(css|js|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot|html)$/i.test(url)) {
+      return false;
+    }
+    return url.startsWith("/") || url.startsWith("http") || url.includes("/api/") || url.includes(".json") || // Common external API patterns
+    url.includes("api.") || url.includes("github.io") || // GitHub Pages hosted APIs
+    url.includes("hsforms.com") || // HubSpot
+    url.includes("hubspot") || // HubSpot
+    url.includes("amazonaws.com") || // AWS S3
+    url.includes("s3.") || // AWS S3 alternative
+    url.includes("googleapis.com") || // Google APIs
+    url.includes("stripe.com") || // Stripe
+    url.includes("graph.facebook.com") || // Facebook
+    url.includes("api.twitter.com") || // Twitter
+    url.includes("slack.com") || // Slack
+    url.includes("discord.com") || // Discord
+    url.includes("sendgrid.com") || // SendGrid
+    url.includes("twilio.com") || // Twilio
+    url.includes("firebase") || // Firebase
+    url.includes("supabase") || // Supabase
+    url.includes("auth0.com") || // Auth0
+    url.includes("okta.com") || // Okta
+    url.includes("cloudflare.com") || // Cloudflare
+    url.includes("vercel.com") || // Vercel
+    url.includes("netlify.com");
+  }
+  /**
+   * Categorize API by URL pattern
+   */
+  categorizeApi(url) {
+    if (url.includes("hsforms.com") || url.includes("hubspot")) return "HubSpot";
+    if (url.includes("amazonaws.com") || url.includes("s3.")) return "AWS S3";
+    if (url.includes("googleapis.com")) return "Google API";
+    if (url.includes("stripe.com")) return "Stripe";
+    if (url.includes("graph.facebook.com")) return "Facebook";
+    if (url.includes("api.twitter.com")) return "Twitter";
+    if (url.includes("slack.com")) return "Slack";
+    if (url.includes("discord.com")) return "Discord";
+    if (url.includes("sendgrid.com")) return "SendGrid";
+    if (url.includes("twilio.com")) return "Twilio";
+    if (url.includes("firebase")) return "Firebase";
+    if (url.includes("supabase")) return "Supabase";
+    if (url.includes("auth0.com")) return "Auth0";
+    if (url.includes("okta.com")) return "Okta";
+    if (url.includes("github.io")) return "GitHub Pages API";
+    if (url.startsWith("/api/")) return "Internal API";
+    if (url.startsWith("/")) return "Internal Route";
+    if (url.startsWith("[")) return "Dynamic URL";
+    return void 0;
+  }
+  /**
+   * Normalize HTTP method
+   */
+  normalizeMethod(method) {
+    const upper = method.toUpperCase();
+    if (["GET", "POST", "PUT", "DELETE", "PATCH"].includes(upper)) {
+      return upper;
+    }
+    return "unknown";
+  }
+};
+
+export { BaseAnalyzer, DataFlowAnalyzer, GraphQLAnalyzer, PagesAnalyzer, RestApiAnalyzer };