@wtdlee/repomap 0.3.1 → 0.3.2

package/dist/chunk-OWM6WNLE.js

@@ -1,2610 +0,0 @@
-import * as fs from 'fs';
-import * as path7 from 'path';
-import { Parser, Language } from 'web-tree-sitter';
-import { fileURLToPath } from 'url';
-import { glob } from 'glob';
-import * as fs7 from 'fs/promises';
-
-// src/analyzers/rails/rails-routes-analyzer.ts
-var __filename$1 = fileURLToPath(import.meta.url);
-var __dirname$1 = path7.dirname(__filename$1);
-var parserInitialized = false;
-var rubyLanguage = null;
-var parser = null;
-async function initRubyParser() {
-  if (parser && rubyLanguage) {
-    return parser;
-  }
-  if (!parserInitialized) {
-    await Parser.init();
-    parserInitialized = true;
-  }
-  parser = new Parser();
-  const possiblePaths = [
-    // When running from source
-    path7.join(process.cwd(), "node_modules/tree-sitter-wasms/out/tree-sitter-ruby.wasm"),
-    // When installed as dependency
-    path7.join(__dirname$1, "../../../node_modules/tree-sitter-wasms/out/tree-sitter-ruby.wasm"),
-    path7.join(__dirname$1, "../../../../tree-sitter-wasms/out/tree-sitter-ruby.wasm")
-  ];
-  let wasmPath = null;
-  for (const p of possiblePaths) {
-    if (fs.existsSync(p)) {
-      wasmPath = p;
-      break;
-    }
-  }
-  if (!wasmPath) {
-    throw new Error("tree-sitter-ruby.wasm not found. Please install tree-sitter-wasms package.");
-  }
-  rubyLanguage = await Language.load(wasmPath);
-  parser.setLanguage(rubyLanguage);
-  return parser;
-}
-async function parseRuby(code) {
-  const p = await initRubyParser();
-  const tree = p.parse(code);
-  if (!tree) {
-    throw new Error("Failed to parse Ruby code");
-  }
-  return tree;
-}
-async function parseRubyFile(filePath) {
-  const code = fs.readFileSync(filePath, "utf-8");
-  return parseRuby(code);
-}
-function findNodes(node, type) {
-  const results = [];
-  if (node.type === type) {
-    results.push(node);
-  }
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child) {
-      results.push(...findNodes(child, type));
-    }
-  }
-  return results;
-}
-function getChildByType(node, type) {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child && child.type === type) {
-      return child;
-    }
-  }
-  return null;
-}
-function getChildrenByType(node, type) {
-  const results = [];
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child && child.type === type) {
-      results.push(child);
-    }
-  }
-  return results;
-}
-function getCallArguments(callNode) {
-  const args = callNode.childForFieldName("arguments");
-  if (!args) return [];
-  const results = [];
-  for (let i = 0; i < args.childCount; i++) {
-    const child = args.child(i);
-    if (child && child.type !== "(" && child.type !== ")" && child.type !== ",") {
-      results.push(child);
-    }
-  }
-  return results;
-}
-function getClassName(classNode) {
-  const nameNode = classNode.childForFieldName("name");
-  return nameNode ? nameNode.text : null;
-}
-function getSuperclass(classNode) {
-  const superclassNode = classNode.childForFieldName("superclass");
-  if (!superclassNode) return null;
-  const constantNode = getChildByType(superclassNode, "constant") || getChildByType(superclassNode, "scope_resolution");
-  return constantNode ? constantNode.text : null;
-}
-function getMethodName(methodNode) {
-  const nameNode = methodNode.childForFieldName("name");
-  return nameNode ? nameNode.text : null;
-}
-function getMethodParameters(methodNode) {
-  const paramsNode = methodNode.childForFieldName("parameters");
-  if (!paramsNode) return [];
-  const params = [];
-  for (let i = 0; i < paramsNode.childCount; i++) {
-    const child = paramsNode.child(i);
-    if (child && (child.type === "identifier" || child.type === "keyword_parameter" || child.type === "optional_parameter" || child.type === "splat_parameter")) {
-      const nameNode = child.childForFieldName("name") || child;
-      if (nameNode.type === "identifier") {
-        params.push(nameNode.text);
-      } else {
-        params.push(child.text);
-      }
-    }
-  }
-  return params;
-}
-
-// src/analyzers/rails/rails-routes-analyzer.ts
-var RailsRoutesAnalyzer = class {
-  constructor(rootPath) {
-    this.rootPath = rootPath;
-    this.routesDir = path7.join(rootPath, "config", "routes");
-  }
-  routesDir;
-  routes = [];
-  namespaces = [];
-  resources = [];
-  mountedEngines = [];
-  drawnFiles = [];
-  errors = [];
-  async analyze() {
-    const mainRoutesFile = path7.join(this.rootPath, "config", "routes.rb");
-    if (!fs.existsSync(mainRoutesFile)) {
-      return {
-        routes: [],
-        namespaces: [],
-        resources: [],
-        mountedEngines: [],
-        drawnFiles: [],
-        errors: [`routes.rb not found at ${mainRoutesFile}`]
-      };
-    }
-    try {
-      await this.parseRoutesFile(mainRoutesFile, []);
-    } catch (error) {
-      this.errors.push(`Error parsing ${mainRoutesFile}: ${error}`);
-    }
-    return {
-      routes: this.routes,
-      namespaces: [...new Set(this.namespaces)],
-      resources: this.resources,
-      mountedEngines: this.mountedEngines,
-      drawnFiles: this.drawnFiles,
-      errors: this.errors
-    };
-  }
-  async parseRoutesFile(filePath, currentNamespaces) {
-    const tree = await parseRubyFile(filePath);
-    const rootNode = tree.rootNode;
-    const calls = findNodes(rootNode, "call");
-    for (const call of calls) {
-      const methodNode = call.childForFieldName("method");
-      if (!methodNode) continue;
-      const methodName = methodNode.text;
-      const line = call.startPosition.row + 1;
-      switch (methodName) {
-        case "get":
-        case "post":
-        case "put":
-        case "patch":
-        case "delete":
-        case "match":
-          this.parseHttpRoute(call, methodName, currentNamespaces, line);
-          break;
-        case "resources":
-        case "resource":
-          await this.parseResources(call, currentNamespaces, line, methodName === "resource");
-          break;
-        case "namespace":
-          await this.parseNamespace(call, currentNamespaces, filePath);
-          break;
-        case "mount":
-          this.parseMount(call, line);
-          break;
-        case "draw":
-          await this.parseDraw(call, currentNamespaces);
-          break;
-        case "devise_for":
-          this.parseDeviseFor(call, currentNamespaces, line);
-          break;
-        case "root":
-          this.parseRoot(call, currentNamespaces, line);
-          break;
-      }
-    }
-  }
-  parseHttpRoute(call, method, namespaces, line) {
-    const args = getCallArguments(call);
-    if (args.length === 0) return;
-    const pathArg = args[0];
-    const routePath = this.extractStringValue(pathArg);
-    if (!routePath) return;
-    let controller = "";
-    let action = "";
-    for (const arg of args) {
-      if (arg.type === "hash" || arg.type === "pair") {
-        const pairs = arg.type === "hash" ? getChildrenByType(arg, "pair") : [arg];
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (key === "to" && value) {
-            const toValue = this.extractStringValue(value);
-            if (toValue && toValue.includes("#")) {
-              [controller, action] = toValue.split("#");
-            }
-          }
-        }
-      } else if (arg.type === "string" || arg.type === "string_content") {
-        const strValue = this.extractStringValue(arg);
-        if (strValue && strValue.includes("#") && !controller) {
-          [controller, action] = strValue.split("#");
-        }
-      }
-    }
-    if (!controller && !action) {
-      const pathParts = routePath.replace(/^\//, "").split("/");
-      controller = pathParts[0] || "";
-      action = pathParts[1] || "index";
-    }
-    if (namespaces.length > 0 && controller && !controller.includes("/")) {
-      controller = `${namespaces.join("/")}/${controller}`;
-    }
-    const fullPath = this.buildPath(namespaces, routePath);
-    this.routes.push({
-      method: method === "match" ? "ALL" : method.toUpperCase(),
-      path: fullPath,
-      controller,
-      action,
-      namespace: namespaces.join("/") || void 0,
-      line
-    });
-  }
-  async parseResources(call, namespaces, line, singular) {
-    const args = getCallArguments(call);
-    if (args.length === 0) return;
-    const nameArg = args[0];
-    const resourceName = nameArg.text.replace(/^:/, "");
-    const resource = {
-      name: resourceName,
-      controller: namespaces.length > 0 ? `${namespaces.join("/")}/${resourceName}` : resourceName,
-      nested: [],
-      memberRoutes: [],
-      collectionRoutes: [],
-      line
-    };
-    for (const arg of args) {
-      if (arg.type === "hash") {
-        const pairs = getChildrenByType(arg, "pair");
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (key === "only" && value) {
-            resource.only = this.extractArrayValues(value);
-          } else if (key === "except" && value) {
-            resource.except = this.extractArrayValues(value);
-          }
-        }
-      }
-    }
-    this.generateResourceRoutes(resource, namespaces, singular);
-    this.resources.push(resource);
-    const block = call.childForFieldName("block");
-    if (block) {
-      const nestedCalls = findNodes(block, "call");
-      for (const nestedCall of nestedCalls) {
-        const nestedMethod = nestedCall.childForFieldName("method")?.text;
-        if (nestedMethod === "member") {
-          const memberBlock = nestedCall.childForFieldName("block");
-          if (memberBlock) {
-            this.parseMemberCollectionRoutes(memberBlock, resource, namespaces, "member");
-          }
-        } else if (nestedMethod === "collection") {
-          const collectionBlock = nestedCall.childForFieldName("block");
-          if (collectionBlock) {
-            this.parseMemberCollectionRoutes(collectionBlock, resource, namespaces, "collection");
-          }
-        }
-      }
-    }
-  }
-  parseMemberCollectionRoutes(block, resource, namespaces, type) {
-    const calls = findNodes(block, "call");
-    for (const call of calls) {
-      const methodNode = call.childForFieldName("method");
-      if (!methodNode) continue;
-      const method = methodNode.text;
-      if (!["get", "post", "put", "patch", "delete"].includes(method)) continue;
-      const args = getCallArguments(call);
-      if (args.length === 0) continue;
-      const actionName = args[0].text.replace(/^:/, "");
-      const basePath = type === "member" ? `/${resource.name}/:id/${actionName}` : `/${resource.name}/${actionName}`;
-      const route = {
-        method: method.toUpperCase(),
-        path: this.buildPath(namespaces, basePath),
-        controller: resource.controller,
-        action: actionName,
-        namespace: namespaces.join("/") || void 0,
-        line: call.startPosition.row + 1
-      };
-      if (type === "member") {
-        resource.memberRoutes.push(route);
-      } else {
-        resource.collectionRoutes.push(route);
-      }
-      this.routes.push(route);
-    }
-  }
-  async parseNamespace(call, currentNamespaces, _currentFile) {
-    const args = getCallArguments(call);
-    if (args.length === 0) return;
-    const nsName = args[0].text.replace(/^:/, "");
-    this.namespaces.push(nsName);
-    const newNamespaces = [...currentNamespaces, nsName];
-    const block = call.childForFieldName("block");
-    if (block) {
-      const nestedCalls = findNodes(block, "call");
-      for (const nestedCall of nestedCalls) {
-        const methodNode = nestedCall.childForFieldName("method");
-        if (!methodNode) continue;
-        const methodName = methodNode.text;
-        const line = nestedCall.startPosition.row + 1;
-        switch (methodName) {
-          case "get":
-          case "post":
-          case "put":
-          case "patch":
-          case "delete":
-          case "match":
-            this.parseHttpRoute(nestedCall, methodName, newNamespaces, line);
-            break;
-          case "resources":
-          case "resource":
-            await this.parseResources(nestedCall, newNamespaces, line, methodName === "resource");
-            break;
-          case "draw":
-            await this.parseDraw(nestedCall, newNamespaces);
-            break;
-        }
-      }
-    }
-  }
-  parseMount(call, line) {
-    const args = getCallArguments(call);
-    if (args.length === 0) return;
-    const engineArg = args[0];
-    const engine = engineArg.text;
-    let mountPath = "/";
-    for (const arg of args) {
-      if (arg.type === "hash" || arg.type === "pair") {
-        const pairs = arg.type === "hash" ? getChildrenByType(arg, "pair") : [arg];
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (key === "at" && value) {
-            mountPath = this.extractStringValue(value) || mountPath;
-          }
-        }
-      } else if (arg.type === "string") {
-        const strValue = this.extractStringValue(arg);
-        if (strValue && strValue.startsWith("/")) {
-          mountPath = strValue;
-        }
-      }
-    }
-    this.mountedEngines.push({
-      engine,
-      mountPath,
-      line
-    });
-  }
-  async parseDraw(call, namespaces) {
-    const args = getCallArguments(call);
-    if (args.length === 0) return;
-    const drawName = args[0].text.replace(/^:/, "");
-    const drawFile = path7.join(this.routesDir, `${drawName}.rb`);
-    if (fs.existsSync(drawFile)) {
-      this.drawnFiles.push(drawFile);
-      try {
-        await this.parseRoutesFile(drawFile, namespaces);
-      } catch (error) {
-        this.errors.push(`Error parsing drawn file ${drawFile}: ${error}`);
-      }
-    }
-  }
-  parseDeviseFor(call, namespaces, line) {
-    const args = getCallArguments(call);
-    if (args.length === 0) return;
-    const resource = args[0].text.replace(/^:/, "");
-    const deviseRoutes = [
-      { method: "GET", path: `/${resource}/sign_in`, action: "new", controller: "devise/sessions" },
-      {
-        method: "POST",
-        path: `/${resource}/sign_in`,
-        action: "create",
-        controller: "devise/sessions"
-      },
-      {
-        method: "DELETE",
-        path: `/${resource}/sign_out`,
-        action: "destroy",
-        controller: "devise/sessions"
-      },
-      {
-        method: "GET",
-        path: `/${resource}/password/new`,
-        action: "new",
-        controller: "devise/passwords"
-      },
-      {
-        method: "POST",
-        path: `/${resource}/password`,
-        action: "create",
-        controller: "devise/passwords"
-      },
-      {
-        method: "GET",
-        path: `/${resource}/sign_up`,
-        action: "new",
-        controller: "devise/registrations"
-      },
-      {
-        method: "POST",
-        path: `/${resource}`,
-        action: "create",
-        controller: "devise/registrations"
-      }
-    ];
-    for (const dr of deviseRoutes) {
-      this.routes.push({
-        method: dr.method,
-        path: this.buildPath(namespaces, dr.path),
-        controller: dr.controller,
-        action: dr.action,
-        namespace: namespaces.join("/") || void 0,
-        line,
-        authenticated: false
-      });
-    }
-  }
-  parseRoot(call, namespaces, line) {
-    const args = getCallArguments(call);
-    let controller = "";
-    let action = "index";
-    for (const arg of args) {
-      if (arg.type === "string") {
-        const value = this.extractStringValue(arg);
-        if (value && value.includes("#")) {
-          [controller, action] = value.split("#");
-        }
-      } else if (arg.type === "hash" || arg.type === "pair") {
-        const pairs = arg.type === "hash" ? getChildrenByType(arg, "pair") : [arg];
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (key === "to" && value) {
-            const toValue = this.extractStringValue(value);
-            if (toValue && toValue.includes("#")) {
-              [controller, action] = toValue.split("#");
-            }
-          }
-        }
-      }
-    }
-    if (controller) {
-      this.routes.push({
-        method: "GET",
-        path: this.buildPath(namespaces, "/"),
-        controller,
-        action,
-        namespace: namespaces.join("/") || void 0,
-        line
-      });
-    }
-  }
-  generateResourceRoutes(resource, namespaces, singular) {
-    const basePath = this.buildPath(namespaces, `/${resource.name}`);
-    const allActions = singular ? ["show", "new", "create", "edit", "update", "destroy"] : ["index", "show", "new", "create", "edit", "update", "destroy"];
-    const actions = resource.only || (resource.except ? allActions.filter((a) => !resource.except.includes(a)) : allActions);
-    const restfulRoutes = [];
-    if (!singular) {
-      if (actions.includes("index")) {
-        restfulRoutes.push({ method: "GET", path: basePath, action: "index" });
-      }
-    }
-    if (actions.includes("new")) {
-      restfulRoutes.push({ method: "GET", path: `${basePath}/new`, action: "new" });
-    }
-    if (actions.includes("create")) {
-      restfulRoutes.push({ method: "POST", path: basePath, action: "create" });
-    }
-    const showPath = singular ? basePath : `${basePath}/:id`;
-    if (actions.includes("show")) {
-      restfulRoutes.push({ method: "GET", path: showPath, action: "show" });
-    }
-    if (actions.includes("edit")) {
-      restfulRoutes.push({ method: "GET", path: `${showPath}/edit`, action: "edit" });
-    }
-    if (actions.includes("update")) {
-      restfulRoutes.push({ method: "PUT", path: showPath, action: "update" });
-      restfulRoutes.push({ method: "PATCH", path: showPath, action: "update" });
-    }
-    if (actions.includes("destroy")) {
-      restfulRoutes.push({ method: "DELETE", path: showPath, action: "destroy" });
-    }
-    for (const route of restfulRoutes) {
-      this.routes.push({
-        method: route.method,
-        path: route.path,
-        controller: resource.controller,
-        action: route.action,
-        namespace: namespaces.join("/") || void 0,
-        line: resource.line
-      });
-    }
-  }
-  buildPath(namespaces, routePath) {
-    if (routePath.startsWith("/")) {
-      return routePath;
-    }
-    const nsPath = namespaces.length > 0 ? `/${namespaces.join("/")}` : "";
-    return `${nsPath}/${routePath}`;
-  }
-  extractStringValue(node) {
-    if (node.type === "string") {
-      const content = getChildByType(node, "string_content");
-      return content ? content.text : node.text.replace(/^["']|["']$/g, "");
-    }
-    if (node.type === "string_content") {
-      return node.text;
-    }
-    if (node.type === "simple_symbol" || node.type === "symbol") {
-      return node.text.replace(/^:/, "");
-    }
-    return node.text.replace(/^["']|["']$/g, "");
-  }
-  extractArrayValues(node) {
-    const values = [];
-    if (node.type === "array") {
-      for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child && child.type !== "[" && child.type !== "]" && child.type !== ",") {
-          const value = this.extractStringValue(child);
-          if (value) values.push(value);
-        }
-      }
-    } else {
-      const value = this.extractStringValue(node);
-      if (value) values.push(value);
-    }
-    return values;
-  }
-};
-async function main() {
-  const targetPath = process.argv[2] || process.cwd();
-  console.log(`Analyzing routes in: ${targetPath}`);
-  const analyzer = new RailsRoutesAnalyzer(targetPath);
-  const result = await analyzer.analyze();
-  console.log("\n=== Rails Routes Analysis ===\n");
-  console.log(`Total routes: ${result.routes.length}`);
-  console.log(`Namespaces: ${result.namespaces.join(", ") || "(none)"}`);
-  console.log(`Resources: ${result.resources.length}`);
-  console.log(`Mounted engines: ${result.mountedEngines.length}`);
-  console.log(`External route files: ${result.drawnFiles.length}`);
-  if (result.errors.length > 0) {
-    console.log(`
---- Errors ---`);
-    for (const error of result.errors) {
-      console.log(`  \u274C ${error}`);
-    }
-  }
-  console.log("\n--- Sample Routes (first 30) ---");
-  for (const route of result.routes.slice(0, 30)) {
-    console.log(
-      `  ${route.method.padEnd(7)} ${route.path.padEnd(50)} => ${route.controller}#${route.action}`
-    );
-  }
-  console.log("\n--- Mounted Engines ---");
-  for (const engine of result.mountedEngines) {
-    console.log(`  ${engine.engine} => ${engine.mountPath}`);
-  }
-  console.log("\n--- External Route Files ---");
-  for (const file of result.drawnFiles) {
-    console.log(`  ${path7.basename(file)}`);
-  }
-}
-var isMainModule = import.meta.url === `file://${process.argv[1]}`;
-if (isMainModule) {
-  main().catch(console.error);
-}
-var RailsControllerAnalyzer = class {
-  constructor(rootPath) {
-    this.rootPath = rootPath;
-    this.controllersDir = path7.join(rootPath, "app", "controllers");
-  }
-  controllersDir;
-  controllers = [];
-  errors = [];
-  async analyze() {
-    if (!fs.existsSync(this.controllersDir)) {
-      return {
-        controllers: [],
-        totalActions: 0,
-        namespaces: [],
-        concerns: [],
-        errors: [`Controllers directory not found at ${this.controllersDir}`]
-      };
-    }
-    const controllerFiles = await glob("**/*_controller.rb", {
-      cwd: this.controllersDir,
-      ignore: ["concerns/**"]
-    });
-    for (const file of controllerFiles) {
-      const fullPath = path7.join(this.controllersDir, file);
-      try {
-        const controller = await this.parseControllerFile(fullPath, file);
-        if (controller) {
-          this.controllers.push(controller);
-        }
-      } catch (error) {
-        this.errors.push(`Error parsing ${file}: ${error}`);
-      }
-    }
-    const namespaces = [
-      ...new Set(this.controllers.filter((c) => c.namespace).map((c) => c.namespace))
-    ];
-    const concerns = [...new Set(this.controllers.flatMap((c) => c.concerns))];
-    const totalActions = this.controllers.reduce((sum, c) => sum + c.actions.length, 0);
-    return {
-      controllers: this.controllers,
-      totalActions,
-      namespaces,
-      concerns,
-      errors: this.errors
-    };
-  }
-  async parseControllerFile(filePath, relativePath) {
-    const tree = await parseRubyFile(filePath);
-    const rootNode = tree.rootNode;
-    const pathParts = relativePath.replace(/_controller\.rb$/, "").split("/");
-    const namespace = pathParts.length > 1 ? pathParts.slice(0, -1).join("/") : void 0;
-    const controllerName = pathParts[pathParts.length - 1];
-    const classNodes = findNodes(rootNode, "class");
-    if (classNodes.length === 0) return null;
-    const classNode = classNodes[0];
-    const className = getClassName(classNode);
-    const parentClass = getSuperclass(classNode);
-    if (!className) return null;
-    const controller = {
-      name: controllerName,
-      filePath: relativePath,
-      className,
-      parentClass: parentClass || "ApplicationController",
-      namespace,
-      actions: [],
-      beforeActions: [],
-      afterActions: [],
-      aroundActions: [],
-      skipBeforeActions: [],
-      concerns: [],
-      helpers: [],
-      rescueFrom: [],
-      line: classNode.startPosition.row + 1
-    };
-    const calls = findNodes(classNode, "call");
-    for (const call of calls) {
-      const methodNode = call.childForFieldName("method");
-      if (!methodNode) continue;
-      const methodName = methodNode.text;
-      const line = call.startPosition.row + 1;
-      switch (methodName) {
-        case "before_action":
-        case "before_filter":
-          this.parseFilter(call, controller.beforeActions, line);
-          break;
-        case "after_action":
-        case "after_filter":
-          this.parseFilter(call, controller.afterActions, line);
-          break;
-        case "around_action":
-        case "around_filter":
-          this.parseFilter(call, controller.aroundActions, line);
-          break;
-        case "skip_before_action":
-        case "skip_before_filter":
-          this.parseFilter(call, controller.skipBeforeActions, line);
-          break;
-        case "include":
-          this.parseInclude(call, controller.concerns);
-          break;
-        case "helper":
-          this.parseHelper(call, controller.helpers);
-          break;
-        case "layout":
-          controller.layoutInfo = this.parseLayout(call);
-          break;
-        case "rescue_from":
-          this.parseRescueFrom(call, controller.rescueFrom, line);
-          break;
-      }
-    }
-    findNodes(classNode, "method");
-    let currentVisibility = "public";
-    const bodyStatement = classNode.childForFieldName("body");
-    if (bodyStatement) {
-      for (let i = 0; i < bodyStatement.childCount; i++) {
-        const child = bodyStatement.child(i);
-        if (!child) continue;
-        if (child.type === "identifier") {
-          const text = child.text;
-          if (text === "private") currentVisibility = "private";
-          else if (text === "protected") currentVisibility = "protected";
-          else if (text === "public") currentVisibility = "public";
-        } else if (child.type === "method") {
-          const action = this.parseMethod(child, currentVisibility);
-          if (action) {
-            controller.actions.push(action);
-          }
-        }
-      }
-    }
-    return controller;
-  }
-  parseFilter(call, filters, line) {
-    const args = this.getCallArguments(call);
-    if (args.length === 0) return;
-    const nameArg = args[0];
-    const filterName = nameArg.text.replace(/^:/, "");
-    const filter = {
-      name: filterName,
-      line
-    };
-    for (const arg of args.slice(1)) {
-      if (arg.type === "hash") {
-        const pairs = getChildrenByType(arg, "pair");
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (!key || !value) continue;
-          switch (key) {
-            case "only":
-              filter.only = this.extractArrayValues(value);
-              break;
-            case "except":
-              filter.except = this.extractArrayValues(value);
-              break;
-            case "if":
-              filter.if = value.text;
-              break;
-            case "unless":
-              filter.unless = value.text;
-              break;
-          }
-        }
-      }
-    }
-    filters.push(filter);
-  }
-  parseInclude(call, concerns) {
-    const args = this.getCallArguments(call);
-    for (const arg of args) {
-      if (arg.type === "constant" || arg.type === "scope_resolution") {
-        concerns.push(arg.text);
-      }
-    }
-  }
-  parseHelper(call, helpers) {
-    const args = this.getCallArguments(call);
-    for (const arg of args) {
-      const value = arg.text.replace(/^:/, "");
-      helpers.push(value);
-    }
-  }
-  parseLayout(call) {
-    const args = this.getCallArguments(call);
-    if (args.length === 0) return void 0;
-    const nameArg = args[0];
-    let layoutName = nameArg.text.replace(/^["']|["']$/g, "");
-    if (layoutName.startsWith(":")) {
-      layoutName = layoutName.substring(1);
-    }
-    if (nameArg.type === "lambda" || nameArg.type === "proc") {
-      layoutName = "(dynamic)";
-    }
-    const layout = { name: layoutName };
-    for (const arg of args.slice(1)) {
-      if (arg.type === "hash") {
-        layout.conditions = arg.text;
-      }
-    }
-    return layout;
-  }
-  parseRescueFrom(call, rescues, line) {
-    const args = this.getCallArguments(call);
-    if (args.length === 0) return;
-    const exception = args[0].text;
-    let handler = "unknown";
-    for (const arg of args.slice(1)) {
-      if (arg.type === "hash" || arg.type === "pair") {
-        const pairs = arg.type === "hash" ? getChildrenByType(arg, "pair") : [arg];
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (key === "with" && value) {
-            handler = value.text.replace(/^:/, "");
-          }
-        }
-      }
-    }
-    rescues.push({ exception, handler, line });
-  }
-  parseMethod(methodNode, visibility) {
-    const name = getMethodName(methodNode);
-    if (!name) return null;
-    if (methodNode.text.includes("def self.")) return null;
-    const action = {
-      name,
-      line: methodNode.startPosition.row + 1,
-      visibility,
-      parameters: getMethodParameters(methodNode),
-      servicesCalled: [],
-      modelsCalled: [],
-      methodCalls: [],
-      instanceVarAssignments: []
-    };
-    const bodyContent = methodNode.text;
-    const ivarRegex = /@([a-z_][a-z0-9_]*)\s*=\s*([^\n]+)/gi;
-    let ivarMatch;
-    while ((ivarMatch = ivarRegex.exec(bodyContent)) !== null) {
-      const varName = ivarMatch[1];
-      const assignedValue = ivarMatch[2].trim().slice(0, 100);
-      let assignedType;
-      const modelMatch = assignedValue.match(
-        /^([A-Z][a-zA-Z0-9]+)\.(find|find_by|find_by!|where|all|first|last|new|create|create!|build)/
-      );
-      if (modelMatch) {
-        assignedType = modelMatch[1];
-      }
-      const assocMatch = assignedValue.match(/^@([a-z_]+)\.([a-z_]+)/);
-      if (assocMatch && !assignedType) {
-        assignedType = `${assocMatch[1]}.${assocMatch[2]}`;
-      }
-      const currentMatch = assignedValue.match(/^current_([a-z_]+)/);
-      if (currentMatch && !assignedType) {
-        assignedType = currentMatch[1].charAt(0).toUpperCase() + currentMatch[1].slice(1);
-      }
-      const serviceMatch = assignedValue.match(/^([A-Z][a-zA-Z0-9]+Service)\.(call|new|perform)/);
-      if (serviceMatch && !assignedType) {
-        assignedType = `Service:${serviceMatch[1]}`;
-      }
-      if (action.instanceVarAssignments) {
-        action.instanceVarAssignments.push({
-          name: varName,
-          assignedType,
-          assignedValue: assignedValue.length > 60 ? assignedValue.slice(0, 57) + "..." : assignedValue
-        });
-      }
-    }
-    if (bodyContent.includes("render json:") || bodyContent.includes("render :json")) {
-      action.rendersJson = true;
-    }
-    if (bodyContent.includes("render") && !action.rendersJson) {
-      action.rendersHtml = true;
-    }
-    const redirectMatch = bodyContent.match(/redirect_to\s+([^,\n]+)/);
-    if (redirectMatch) {
-      action.redirectsTo = redirectMatch[1].trim();
-    }
-    if (bodyContent.includes("respond_to")) {
-      const formats = [];
-      if (bodyContent.includes("format.html")) formats.push("html");
-      if (bodyContent.includes("format.json")) formats.push("json");
-      if (bodyContent.includes("format.xml")) formats.push("xml");
-      if (bodyContent.includes("format.js")) formats.push("js");
-      if (bodyContent.includes("format.csv")) formats.push("csv");
-      if (bodyContent.includes("format.pdf")) formats.push("pdf");
-      if (formats.length > 0) {
-        action.respondsTo = formats;
-      }
-    }
-    const serviceCalls = findNodes(methodNode, "call");
-    for (const call of serviceCalls) {
-      const receiver = call.childForFieldName("receiver");
-      const method = call.childForFieldName("method");
-      if (receiver && method) {
-        const receiverText = receiver.text;
-        const methodText = method.text;
-        if (receiverText.endsWith("Service") && ["call", "new", "perform", "execute"].includes(methodText)) {
-          if (!action.servicesCalled.includes(receiverText)) {
-            action.servicesCalled.push(receiverText);
-          }
-        }
-        const arMethods = [
-          "find",
-          "find_by",
-          "find_by!",
-          "where",
-          "all",
-          "first",
-          "last",
-          "create",
-          "create!",
-          "new",
-          "update",
-          "update!",
-          "destroy",
-          "delete"
-        ];
-        if (/^[A-Z][a-zA-Z]+$/.test(receiverText) && arMethods.includes(methodText)) {
-          if (!["Rails", "ActiveRecord", "ActionController", "ApplicationRecord"].includes(
-            receiverText
-          )) {
-            if (!action.modelsCalled.includes(receiverText)) {
-              action.modelsCalled.push(receiverText);
-            }
-          }
-        }
-        action.methodCalls.push(`${receiverText}.${methodText}`);
-      } else if (method && !receiver) {
-        action.methodCalls.push(method.text);
-      }
-    }
-    return action;
-  }
-  getCallArguments(call) {
-    const args = call.childForFieldName("arguments");
-    if (!args) {
-      const results2 = [];
-      for (let i = 0; i < call.childCount; i++) {
-        const child = call.child(i);
-        if (child && !["identifier", "(", ")", ",", "call"].includes(child.type)) {
-          if (child !== call.childForFieldName("method") && child !== call.childForFieldName("receiver")) {
-            results2.push(child);
-          }
-        }
-      }
-      return results2;
-    }
-    const results = [];
-    for (let i = 0; i < args.childCount; i++) {
-      const child = args.child(i);
-      if (child && child.type !== "(" && child.type !== ")" && child.type !== ",") {
-        results.push(child);
-      }
-    }
-    return results;
-  }
-  extractArrayValues(node) {
-    const values = [];
-    if (node.type === "array") {
-      for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child && child.type !== "[" && child.type !== "]" && child.type !== ",") {
-          values.push(child.text.replace(/^:/, ""));
-        }
-      }
-    } else {
-      values.push(node.text.replace(/^:/, ""));
-    }
-    return values;
-  }
-};
-async function main2() {
-  const targetPath = process.argv[2] || process.cwd();
-  console.log(`Analyzing controllers in: ${targetPath}`);
-  const analyzer = new RailsControllerAnalyzer(targetPath);
-  const result = await analyzer.analyze();
-  console.log("\n=== Rails Controllers Analysis ===\n");
-  console.log(`Total controllers: ${result.controllers.length}`);
-  console.log(`Total actions: ${result.totalActions}`);
-  console.log(`Namespaces: ${result.namespaces.join(", ") || "(none)"}`);
-  console.log(`Shared concerns: ${result.concerns.length}`);
-  if (result.errors.length > 0) {
-    console.log(`
---- Errors (${result.errors.length}) ---`);
-    for (const error of result.errors.slice(0, 5)) {
-      console.log(`  \u274C ${error}`);
-    }
-    if (result.errors.length > 5) {
-      console.log(`  ... and ${result.errors.length - 5} more`);
-    }
-  }
-  console.log("\n--- Sample Controllers (first 10) ---");
-  for (const controller of result.controllers.slice(0, 10)) {
-    console.log(`
-  \u{1F4C1} ${controller.className} (${controller.filePath})`);
-    console.log(`     Parent: ${controller.parentClass}`);
-    console.log(
-      `     Actions (${controller.actions.length}): ${controller.actions.map((a) => a.name).slice(0, 5).join(", ")}${controller.actions.length > 5 ? "..." : ""}`
-    );
-    if (controller.beforeActions.length > 0) {
-      console.log(`     Before: ${controller.beforeActions.map((f) => f.name).join(", ")}`);
-    }
-    if (controller.concerns.length > 0) {
-      console.log(`     Concerns: ${controller.concerns.join(", ")}`);
-    }
-  }
-  const publicActions = result.controllers.flatMap(
-    (c) => c.actions.filter((a) => a.visibility === "public")
-  );
-  const privateActions = result.controllers.flatMap(
-    (c) => c.actions.filter((a) => a.visibility === "private")
-  );
-  console.log("\n--- Action Visibility Summary ---");
-  console.log(`  Public: ${publicActions.length}`);
-  console.log(`  Private: ${privateActions.length}`);
-}
-var isMainModule2 = import.meta.url === `file://${process.argv[1]}`;
-if (isMainModule2) {
-  main2().catch(console.error);
-}
-var RailsModelAnalyzer = class {
-  constructor(rootPath) {
-    this.rootPath = rootPath;
-    this.modelsDir = path7.join(rootPath, "app", "models");
-  }
-  modelsDir;
-  models = [];
-  errors = [];
-  async analyze() {
-    if (!fs.existsSync(this.modelsDir)) {
-      return {
-        models: [],
-        totalAssociations: 0,
-        totalValidations: 0,
-        concerns: [],
-        namespaces: [],
-        errors: [`Models directory not found at ${this.modelsDir}`]
-      };
-    }
-    const modelFiles = await glob("**/*.rb", {
-      cwd: this.modelsDir,
-      ignore: ["concerns/**", "application_record.rb"]
-    });
-    for (const file of modelFiles) {
-      const fullPath = path7.join(this.modelsDir, file);
-      try {
-        const model = await this.parseModelFile(fullPath, file);
-        if (model) {
-          this.models.push(model);
-        }
-      } catch (error) {
-        this.errors.push(`Error parsing ${file}: ${error}`);
-      }
-    }
-    const concerns = [...new Set(this.models.flatMap((m) => m.concerns))];
-    const namespaces = [
-      ...new Set(
-        this.models.map((m) => {
-          const parts = m.filePath.split("/");
-          return parts.length > 1 ? parts.slice(0, -1).join("/") : null;
-        }).filter((n) => n !== null)
-      )
-    ];
-    const totalAssociations = this.models.reduce((sum, m) => sum + m.associations.length, 0);
-    const totalValidations = this.models.reduce((sum, m) => sum + m.validations.length, 0);
-    return {
-      models: this.models,
-      totalAssociations,
-      totalValidations,
-      concerns,
-      namespaces,
-      errors: this.errors
-    };
-  }
-  async parseModelFile(filePath, relativePath) {
-    const tree = await parseRubyFile(filePath);
-    const rootNode = tree.rootNode;
-    const classNodes = findNodes(rootNode, "class");
-    if (classNodes.length === 0) return null;
-    const classNode = classNodes[0];
-    const className = getClassName(classNode);
-    const parentClass = getSuperclass(classNode);
-    if (!className) return null;
-    if (parentClass && !this.isActiveRecordModel(parentClass)) ;
-    const model = {
-      name: className.replace(/.*::/, ""),
-      // Remove namespace prefix
-      filePath: relativePath,
-      className,
-      parentClass: parentClass || "ApplicationRecord",
-      associations: [],
-      validations: [],
-      callbacks: [],
-      scopes: [],
-      concerns: [],
-      enums: [],
-      attributes: [],
-      classMethodsCount: 0,
-      instanceMethodsCount: 0,
-      line: classNode.startPosition.row + 1
-    };
-    model.tableName = this.parseTableName(classNode);
-    const calls = findNodes(classNode, "call");
-    for (const call of calls) {
-      const methodNode = call.childForFieldName("method");
-      if (!methodNode) continue;
-      const methodName = methodNode.text;
-      const line = call.startPosition.row + 1;
-      if (["belongs_to", "has_one", "has_many", "has_and_belongs_to_many"].includes(methodName)) {
-        this.parseAssociation(
-          call,
-          methodName,
-          model.associations,
-          line
-        );
-      } else if (methodName.startsWith("validates") || methodName === "validate") {
-        this.parseValidation(call, methodName, model.validations, line);
-      } else if (this.isCallback(methodName)) {
-        this.parseCallback(call, methodName, model.callbacks, line);
-      } else if (methodName === "scope") {
-        this.parseScope(call, model.scopes, line);
-      } else if (methodName === "include") {
-        this.parseInclude(call, model.concerns);
-      } else if (methodName === "enum") {
-        this.parseEnum(call, model.enums, line);
-      } else if (methodName === "attribute") {
-        this.parseAttribute(call, model.attributes, line);
-      }
-    }
-    const methods = findNodes(classNode, "method");
-    const singletonMethods = findNodes(classNode, "singleton_method");
-    model.instanceMethodsCount = methods.length;
-    model.classMethodsCount = singletonMethods.length;
-    return model;
-  }
-  isActiveRecordModel(parentClass) {
-    const arBases = ["ApplicationRecord", "ActiveRecord::Base", "ActiveRecord"];
-    return arBases.some((base) => parentClass.includes(base));
-  }
-  parseTableName(classNode) {
-    const calls = findNodes(classNode, "call");
-    for (const call of calls) {
-      const methodNode = call.childForFieldName("method");
-      if (methodNode?.text === "table_name=") {
-        const args = this.getCallArguments(call);
-        if (args.length > 0) {
-          return args[0].text.replace(/^["']|["']$/g, "");
-        }
-      }
-    }
-    const assignments = findNodes(classNode, "assignment");
-    for (const assignment of assignments) {
-      const left = assignment.child(0);
-      if (left?.text?.includes("table_name")) {
-        const right = assignment.child(2);
-        if (right) {
-          return right.text.replace(/^["']|["']$/g, "");
-        }
-      }
-    }
-    return void 0;
-  }
-  parseAssociation(call, type, associations, line) {
-    const args = this.getCallArguments(call);
-    if (args.length === 0) return;
-    const nameArg = args[0];
-    const assocName = nameArg.text.replace(/^:/, "");
-    const association = {
-      type,
-      name: assocName,
-      line
-    };
-    for (const arg of args.slice(1)) {
-      if (arg.type === "hash") {
-        const pairs = getChildrenByType(arg, "pair");
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (!key || !value) continue;
-          switch (key) {
-            case "class_name":
-              association.className = value.text.replace(/^["']|["']$/g, "");
-              break;
-            case "foreign_key":
-              association.foreignKey = value.text.replace(/^["']|["']$/g, "").replace(/^:/, "");
-              break;
-            case "through":
-              association.through = value.text.replace(/^:/, "");
-              break;
-            case "polymorphic":
-              association.polymorphic = value.text === "true";
-              break;
-            case "dependent":
-              association.dependent = value.text.replace(/^:/, "");
-              break;
-            case "optional":
-              association.optional = value.text === "true";
-              break;
-          }
-        }
-      }
-    }
-    associations.push(association);
-  }
-  parseValidation(call, methodName, validations, line) {
-    const args = this.getCallArguments(call);
-    if (args.length === 0) return;
-    const attributes = [];
-    const options = {};
-    let validationType = methodName;
-    for (const arg of args) {
-      if (arg.type === "simple_symbol" || arg.type === "symbol") {
-        attributes.push(arg.text.replace(/^:/, ""));
-      } else if (arg.type === "hash") {
-        const pairs = getChildrenByType(arg, "pair");
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (key && value) {
-            if ([
-              "presence",
-              "uniqueness",
-              "numericality",
-              "length",
-              "format",
-              "inclusion",
-              "exclusion",
-              "acceptance",
-              "confirmation"
-            ].includes(key)) {
-              validationType = key;
-              options[key] = value.text;
-            } else {
-              options[key] = value.text;
-            }
-          }
-        }
-      }
-    }
-    if (attributes.length > 0 || methodName === "validate") {
-      validations.push({
-        type: validationType,
-        attributes,
-        options: Object.keys(options).length > 0 ? options : void 0,
-        line
-      });
-    }
-  }
-  isCallback(methodName) {
-    const callbacks = [
-      "before_validation",
-      "after_validation",
-      "before_save",
-      "around_save",
-      "after_save",
-      "before_create",
-      "around_create",
-      "after_create",
-      "before_update",
-      "around_update",
-      "after_update",
-      "before_destroy",
-      "around_destroy",
-      "after_destroy",
-      "after_commit",
-      "after_rollback",
-      "after_initialize",
-      "after_find",
-      "after_touch"
-    ];
-    return callbacks.includes(methodName);
-  }
-  parseCallback(call, type, callbacks, line) {
-    const args = this.getCallArguments(call);
-    if (args.length === 0) return;
-    const methodArg = args[0];
-    const methodName = methodArg.text.replace(/^:/, "");
-    const callback = {
-      type,
-      method: methodName,
-      line
-    };
-    for (const arg of args.slice(1)) {
-      if (arg.type === "hash") {
-        const pairs = getChildrenByType(arg, "pair");
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (key && value && ["if", "unless"].includes(key)) {
-            callback.conditions = `${key}: ${value.text}`;
-          }
-        }
-      }
-    }
-    callbacks.push(callback);
-  }
-  parseScope(call, scopes, line) {
-    const args = this.getCallArguments(call);
-    if (args.length === 0) return;
-    const nameArg = args[0];
-    const scopeName = nameArg.text.replace(/^:/, "");
-    const isLambda = args.length > 1 && (args[1].type === "lambda" || args[1].text.includes("->"));
-    scopes.push({
-      name: scopeName,
-      lambda: isLambda,
-      line
-    });
-  }
-  parseInclude(call, concerns) {
-    const args = this.getCallArguments(call);
-    for (const arg of args) {
-      if (arg.type === "constant" || arg.type === "scope_resolution") {
-        concerns.push(arg.text);
-      }
-    }
-  }
-  parseEnum(call, enums, line) {
-    const args = this.getCallArguments(call);
-    if (args.length === 0) return;
-    for (const arg of args) {
-      if (arg.type === "hash") {
-        const pairs = getChildrenByType(arg, "pair");
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (key && value && value.type === "hash") {
-            const enumValues = [];
-            const valuePairs = getChildrenByType(value, "pair");
-            for (const vp of valuePairs) {
-              const vKey = vp.child(0)?.text?.replace(/^:/, "");
-              if (vKey) enumValues.push(vKey);
-            }
-            enums.push({
-              name: key,
-              values: enumValues,
-              line
-            });
-          } else if (key && value && value.type === "array") {
-            const enumValues = [];
-            for (let i = 0; i < value.childCount; i++) {
-              const child = value.child(i);
-              if (child && child.type !== "[" && child.type !== "]" && child.type !== ",") {
-                enumValues.push(child.text.replace(/^:/, ""));
-              }
-            }
-            enums.push({
-              name: key,
-              values: enumValues,
-              line
-            });
-          }
-        }
-      }
-    }
-  }
-  parseAttribute(call, attributes, line) {
-    const args = this.getCallArguments(call);
-    if (args.length === 0) return;
-    const nameArg = args[0];
-    const attrName = nameArg.text.replace(/^:/, "");
-    const attr = {
-      name: attrName,
-      line
-    };
-    if (args.length > 1) {
-      const typeArg = args[1];
-      attr.type = typeArg.text.replace(/^:/, "");
-    }
-    for (const arg of args) {
-      if (arg.type === "hash") {
-        const pairs = getChildrenByType(arg, "pair");
-        for (const pair of pairs) {
-          const key = pair.child(0)?.text?.replace(/^:/, "");
-          const value = pair.child(2);
-          if (key === "default" && value) {
-            attr.default = value.text;
-          }
-        }
-      }
-    }
-    attributes.push(attr);
-  }
-  getCallArguments(call) {
-    const args = call.childForFieldName("arguments");
-    if (!args) {
-      const results2 = [];
-      for (let i = 0; i < call.childCount; i++) {
-        const child = call.child(i);
-        if (child && !["identifier", "(", ")", ",", "call"].includes(child.type)) {
-          if (child !== call.childForFieldName("method") && child !== call.childForFieldName("receiver")) {
-            results2.push(child);
-          }
-        }
-      }
-      return results2;
-    }
-    const results = [];
-    for (let i = 0; i < args.childCount; i++) {
-      const child = args.child(i);
-      if (child && child.type !== "(" && child.type !== ")" && child.type !== ",") {
-        results.push(child);
-      }
-    }
-    return results;
-  }
-};
-async function main3() {
-  const targetPath = process.argv[2] || process.cwd();
-  console.log(`Analyzing models in: ${targetPath}`);
-  const analyzer = new RailsModelAnalyzer(targetPath);
-  const result = await analyzer.analyze();
-  console.log("\n=== Rails Models Analysis ===\n");
-  console.log(`Total models: ${result.models.length}`);
-  console.log(`Total associations: ${result.totalAssociations}`);
-  console.log(`Total validations: ${result.totalValidations}`);
-  console.log(`Shared concerns: ${result.concerns.length}`);
-  console.log(`Namespaces: ${result.namespaces.join(", ") || "(none)"}`);
-  if (result.errors.length > 0) {
-    console.log(`
---- Errors (${result.errors.length}) ---`);
-    for (const error of result.errors.slice(0, 5)) {
-      console.log(`  \u274C ${error}`);
-    }
-    if (result.errors.length > 5) {
-      console.log(`  ... and ${result.errors.length - 5} more`);
-    }
-  }
-  console.log("\n--- Sample Models (first 15) ---");
-  for (const model of result.models.slice(0, 15)) {
-    console.log(`
-  \u{1F4E6} ${model.className} (${model.filePath})`);
-    console.log(`     Parent: ${model.parentClass}`);
-    if (model.associations.length > 0) {
-      const assocs = model.associations.slice(0, 3).map((a) => `${a.type} :${a.name}`);
-      console.log(
-        `     Associations: ${assocs.join(", ")}${model.associations.length > 3 ? "..." : ""}`
-      );
-    }
-    if (model.validations.length > 0) {
-      console.log(`     Validations: ${model.validations.length}`);
-    }
-    if (model.scopes.length > 0) {
-      const scopeNames = model.scopes.slice(0, 3).map((s) => s.name);
-      console.log(`     Scopes: ${scopeNames.join(", ")}${model.scopes.length > 3 ? "..." : ""}`);
-    }
-    if (model.enums.length > 0) {
-      const enumInfo = model.enums.map((e) => `${e.name}(${e.values.length})`);
-      console.log(`     Enums: ${enumInfo.join(", ")}`);
-    }
-    if (model.concerns.length > 0) {
-      console.log(
-        `     Concerns: ${model.concerns.slice(0, 3).join(", ")}${model.concerns.length > 3 ? "..." : ""}`
-      );
-    }
-  }
-  const allAssociations = result.models.flatMap((m) => m.associations);
-  const belongsTo = allAssociations.filter((a) => a.type === "belongs_to").length;
-  const hasMany = allAssociations.filter((a) => a.type === "has_many").length;
-  const hasOne = allAssociations.filter((a) => a.type === "has_one").length;
-  console.log("\n--- Association Summary ---");
-  console.log(`  belongs_to: ${belongsTo}`);
-  console.log(`  has_many: ${hasMany}`);
-  console.log(`  has_one: ${hasOne}`);
-}
-var isMainModule3 = import.meta.url === `file://${process.argv[1]}`;
-if (isMainModule3) {
-  main3().catch(console.error);
-}
-var RailsGrpcAnalyzer = class {
-  constructor(rootPath) {
-    this.rootPath = rootPath;
-    this.grpcDir = path7.join(rootPath, "app", "grpc_services");
-  }
-  grpcDir;
-  services = [];
-  errors = [];
-  async analyze() {
-    if (!fs.existsSync(this.grpcDir)) {
-      return {
-        services: [],
-        totalRpcs: 0,
-        namespaces: [],
-        errors: [`gRPC services directory not found at ${this.grpcDir}`]
-      };
-    }
-    const serviceFiles = await glob("**/*_grpc_service.rb", {
-      cwd: this.grpcDir
-    });
-    for (const file of serviceFiles) {
-      const fullPath = path7.join(this.grpcDir, file);
-      try {
-        const service = await this.parseServiceFile(fullPath, file);
-        if (service) {
-          this.services.push(service);
-        }
-      } catch (error) {
-        this.errors.push(`Error parsing ${file}: ${error}`);
-      }
-    }
-    const namespaces = [
-      ...new Set(this.services.filter((s) => s.namespace).map((s) => s.namespace))
-    ];
-    const totalRpcs = this.services.reduce((sum, s) => sum + s.rpcs.length, 0);
-    return {
-      services: this.services,
-      totalRpcs,
-      namespaces,
-      errors: this.errors
-    };
-  }
-  async parseServiceFile(filePath, relativePath) {
-    const tree = await parseRubyFile(filePath);
-    const rootNode = tree.rootNode;
-    const pathParts = relativePath.replace(/_grpc_service\.rb$/, "").split("/");
-    const namespace = pathParts.length > 1 ? pathParts.slice(0, -1).join("/") : void 0;
-    const serviceName = pathParts[pathParts.length - 1];
-    const classNodes = findNodes(rootNode, "class");
-    if (classNodes.length === 0) return null;
-    const classNode = classNodes[0];
-    const className = getClassName(classNode);
-    const parentClass = getSuperclass(classNode);
-    if (!className) return null;
-    const service = {
-      name: serviceName,
-      filePath: relativePath,
-      className,
-      parentClass: parentClass || "Unknown",
-      namespace,
-      rpcs: [],
-      policies: [],
-      serializers: [],
-      concerns: [],
-      line: classNode.startPosition.row + 1
-    };
-    if (parentClass) {
-      const protoMatch = parentClass.match(/(\w+)::Service$/);
-      if (protoMatch) {
-        service.protoService = parentClass.replace("::Service", "");
-      }
-    }
-    const calls = findNodes(classNode, "call");
-    for (const call of calls) {
-      const methodNode = call.childForFieldName("method");
-      if (methodNode?.text === "include") {
-        const args = this.getCallArguments(call);
-        for (const arg of args) {
-          if (arg.type === "constant" || arg.type === "scope_resolution") {
-            service.concerns.push(arg.text);
-          }
-        }
-      }
-    }
-    findNodes(classNode, "method");
-    let currentVisibility = "public";
-    const bodyStatement = classNode.childForFieldName("body");
-    if (bodyStatement) {
-      for (let i = 0; i < bodyStatement.childCount; i++) {
-        const child = bodyStatement.child(i);
-        if (!child) continue;
-        if (child.type === "identifier") {
-          const text = child.text;
-          if (text === "private") currentVisibility = "private";
-          else if (text === "protected") currentVisibility = "protected";
-          else if (text === "public") currentVisibility = "public";
-        } else if (child.type === "method" && currentVisibility === "public") {
-          const rpc = this.parseRpcMethod(child);
-          if (rpc) {
-            const methodCalls = findNodes(child, "call");
-            for (const mc of methodCalls) {
-              const methodName = mc.childForFieldName("method")?.text;
-              const receiver = mc.childForFieldName("receiver")?.text;
-              if (methodName === "authorize!" || methodName === "new") {
-                if (receiver?.includes("Policy")) {
-                  if (!service.policies.includes(receiver)) {
-                    service.policies.push(receiver);
-                  }
-                  rpc.policyMethod = "authorize!";
-                }
-              }
-              if (receiver?.includes("Serializer") && methodName === "new") {
-                if (!service.serializers.includes(receiver)) {
-                  service.serializers.push(receiver);
-                }
-              }
-            }
-            service.rpcs.push(rpc);
-          }
-        }
-      }
-    }
-    return service;
-  }
-  parseRpcMethod(methodNode) {
-    const name = getMethodName(methodNode);
-    if (!name) return null;
-    const skipMethods = ["initialize", "to_s", "inspect", "call", "perform", "execute"];
-    if (skipMethods.includes(name)) return null;
-    getMethodParameters(methodNode);
-    const methodBody = methodNode.text;
-    const rpc = {
-      name,
-      line: methodNode.startPosition.row + 1,
-      streaming: "none",
-      modelsUsed: [],
-      servicesUsed: []
-    };
-    const requestMatch = methodBody.match(/@param\s+\[([^\]]+)\]\s+req/);
-    if (requestMatch) {
-      rpc.requestType = requestMatch[1];
-    }
-    const responseMatch = methodBody.match(/@return\s+\[([^\]]+)\]/);
-    if (responseMatch) {
-      rpc.responseType = responseMatch[1];
-    }
-    const modelMatches = methodBody.matchAll(
-      /\b([A-Z][a-zA-Z]+)\.(find|find_by|where|all|first|last|create|joins|includes)\b/g
-    );
-    for (const match of modelMatches) {
-      const modelName = match[1];
-      if (!["Rails", "ActiveRecord", "GRPC", "Visit", "Google"].includes(modelName) && !rpc.modelsUsed.includes(modelName)) {
-        rpc.modelsUsed.push(modelName);
-      }
-    }
-    const serviceMatches = methodBody.matchAll(/\b(\w+Service)\.(call|new|perform)\b/g);
-    for (const match of serviceMatches) {
-      const serviceName = match[1];
-      if (!rpc.servicesUsed.includes(serviceName)) {
-        rpc.servicesUsed.push(serviceName);
-      }
-    }
-    return rpc;
-  }
-  getCallArguments(call) {
-    const args = call.childForFieldName("arguments");
-    if (!args) {
-      const results2 = [];
-      for (let i = 0; i < call.childCount; i++) {
-        const child = call.child(i);
-        if (child && !["identifier", "(", ")", ",", "call"].includes(child.type)) {
-          if (child !== call.childForFieldName("method") && child !== call.childForFieldName("receiver")) {
-            results2.push(child);
-          }
-        }
-      }
-      return results2;
-    }
-    const results = [];
-    for (let i = 0; i < args.childCount; i++) {
-      const child = args.child(i);
-      if (child && child.type !== "(" && child.type !== ")" && child.type !== ",") {
-        results.push(child);
-      }
-    }
-    return results;
-  }
-};
-async function main4() {
-  const targetPath = process.argv[2] || process.cwd();
-  console.log(`Analyzing gRPC services in: ${targetPath}`);
-  const analyzer = new RailsGrpcAnalyzer(targetPath);
-  const result = await analyzer.analyze();
-  console.log("\n=== Rails gRPC Services Analysis ===\n");
-  console.log(`Total services: ${result.services.length}`);
-  console.log(`Total RPCs: ${result.totalRpcs}`);
-  console.log(`Namespaces: ${result.namespaces.join(", ") || "(none)"}`);
-  if (result.errors.length > 0) {
-    console.log(`
---- Errors (${result.errors.length}) ---`);
-    for (const error of result.errors.slice(0, 5)) {
-      console.log(`  \u274C ${error}`);
-    }
-  }
-  console.log("\n--- Sample Services (first 15) ---");
-  for (const service of result.services.slice(0, 15)) {
-    console.log(`
-  \u{1F4E1} ${service.className} (${service.filePath})`);
-    console.log(`     Proto: ${service.protoService || "unknown"}`);
-    console.log(
-      `     RPCs (${service.rpcs.length}): ${service.rpcs.map((r) => r.name).join(", ")}`
-    );
-    if (service.policies.length > 0) {
-      console.log(`     Policies: ${service.policies.join(", ")}`);
-    }
-    if (service.serializers.length > 0) {
-      console.log(`     Serializers: ${service.serializers.join(", ")}`);
-    }
-  }
-  const allRpcs = result.services.flatMap((s) => s.rpcs);
-  const rpcsWithModels = allRpcs.filter((r) => r.modelsUsed.length > 0);
-  console.log("\n--- RPC Summary ---");
-  console.log(`  Total RPCs: ${allRpcs.length}`);
-  console.log(`  RPCs using models: ${rpcsWithModels.length}`);
-}
-var isMainModule4 = import.meta.url === `file://${process.argv[1]}`;
-if (isMainModule4) {
-  main4().catch(console.error);
-}
-async function analyzeRailsViews(rootPath) {
-  const viewsPath = path7.join(rootPath, "app/views");
-  const controllersPath = path7.join(rootPath, "app/controllers");
-  try {
-    await fs7.access(viewsPath);
-  } catch {
-    return {
-      views: [],
-      pages: [],
-      summary: { totalViews: 0, totalPages: 0, byController: {}, byTemplate: {} }
-    };
-  }
-  const viewFiles = await glob("**/*.{haml,erb,html.haml,html.erb,yml}", {
-    cwd: viewsPath,
-    nodir: true
-  });
-  const views = [];
-  const byController = {};
-  const byTemplate = {};
-  for (const file of viewFiles) {
-    const view = await parseViewFile(viewsPath, file);
-    if (view) {
-      views.push(view);
-      byController[view.controller] = (byController[view.controller] || 0) + 1;
-      byTemplate[view.template] = (byTemplate[view.template] || 0) + 1;
-    }
-  }
-  const pages = await analyzeControllersForPages(controllersPath, views, rootPath);
-  return {
-    views,
-    pages,
-    summary: {
-      totalViews: views.length,
-      totalPages: pages.length,
-      byController,
-      byTemplate
-    }
-  };
-}
-async function parseViewFile(viewsPath, relativePath) {
-  const fullPath = path7.join(viewsPath, relativePath);
-  try {
-    const content = await fs7.readFile(fullPath, "utf-8");
-    const parts = relativePath.split("/");
-    if (parts.some(
-      (p) => p.endsWith("_mailer") || p === "layouts" || p === "shared" || p === "devise"
-    )) {
-      return null;
-    }
-    const fileName = parts.pop() || "";
-    const controller = parts.join("/") || "application";
-    const nameParts = fileName.split(".");
-    const action = nameParts[0].replace(/^_/, "");
-    const isPartial = fileName.startsWith("_");
-    let template;
-    if (fileName.endsWith(".yml")) {
-      template = "yml";
-    } else if (fileName.endsWith(".haml")) {
-      template = "haml";
-    } else if (fileName.endsWith(".erb")) {
-      template = "erb";
-    } else {
-      template = "other";
-    }
-    const format = nameParts.length > 2 ? nameParts[1] : "html";
-    if (isPartial) return null;
-    let partials = [];
-    let helpers = [];
-    let instanceVars = [];
-    let reactComponents = [];
-    if (template === "yml") {
-      instanceVars = extractYmlFields(content);
-      reactComponents = [{ name: "App", ssr: true, propsVar: "@yml_data" }];
-    } else {
-      partials = extractPartials(content, template);
-      helpers = extractHelpers(content, template);
-      instanceVars = extractInstanceVars(content);
-      reactComponents = extractReactComponents(content, template);
-    }
-    return {
-      name: action,
-      path: relativePath,
-      controller,
-      action,
-      format,
-      template,
-      partials,
-      helpers,
-      instanceVars,
-      reactComponents
-    };
-  } catch {
-    return null;
-  }
-}
-function extractPartials(content, template) {
-  const partials = [];
-  if (template === "haml") {
-    const matches = content.matchAll(/=\s*render\s+(?:partial:\s*)?['"]([^'"]+)['"]/g);
-    for (const match of matches) {
-      partials.push(match[1]);
-    }
-  } else if (template === "erb") {
-    const matches = content.matchAll(/<%=?\s*render\s+(?:partial:\s*)?['"]([^'"]+)['"]/g);
-    for (const match of matches) {
-      partials.push(match[1]);
-    }
-  }
-  return [...new Set(partials)];
-}
-function extractHelpers(content, _template) {
-  const helpers = [];
-  const helperPattern = /\b(link_to|form_for|form_with|image_tag|content_for|yield|render|t|l|raw|html_safe|simple_form_for)\b/g;
-  const matches = content.matchAll(helperPattern);
-  for (const match of matches) {
-    helpers.push(match[1]);
-  }
-  return [...new Set(helpers)];
-}
-function extractReactComponents(content, _template) {
-  const components = [];
-  const renderReactPattern = /render_react_component\s*\(?\s*["']([^"']+)["'](?:,\s*\{[^}]*\})?\s*(?:,\s*ssr:\s*(true|false))?\)?/g;
-  let match;
-  while ((match = renderReactPattern.exec(content)) !== null) {
-    components.push({
-      name: match[1],
-      ssr: match[2] === "true"
-    });
-  }
-  const dataReactPattern = /data:\s*\{\s*react_component:\s*["']([^"']+)["'](?:,\s*react_component_props:\s*(@?\w+)(?:\.to_json)?)?/g;
-  while ((match = dataReactPattern.exec(content)) !== null) {
-    components.push({
-      name: match[1],
-      propsVar: match[2],
-      ssr: false
-    });
-  }
-  const reactComponentPattern = /ReactComponent\s+name=["']([^"']+)["']/g;
-  while ((match = reactComponentPattern.exec(content)) !== null) {
-    components.push({
-      name: match[1],
-      ssr: false
-    });
-  }
-  const seen = /* @__PURE__ */ new Set();
-  return components.filter((c) => {
-    if (seen.has(c.name)) return false;
-    seen.add(c.name);
-    return true;
-  });
-}
-function extractYmlFields(content) {
-  const fields = [];
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const topMatch = line.match(/^([a-z_]+):/);
-    if (topMatch && !topMatch[1].startsWith("_")) {
-      fields.push(topMatch[1]);
-    }
-    const fieldMatch = line.match(/^\s+-\s+(\w+)/);
-    if (fieldMatch) {
-      fields.push(fieldMatch[1]);
-    }
-  }
-  return [...new Set(fields)].slice(0, 50);
-}
-function extractInstanceVars(content) {
-  const vars = [];
-  const matches = content.matchAll(/@(\w+)/g);
-  for (const match of matches) {
-    if (!["import", "media", "keyframes", "charset"].includes(match[1])) {
-      vars.push(match[1]);
-    }
-  }
-  return [...new Set(vars)];
-}
-async function analyzeControllersForPages(controllersPath, views, rootPath) {
-  const pages = [];
-  try {
-    await fs7.access(controllersPath);
-  } catch {
-    return pages;
-  }
-  const controllerFiles = await glob("**/*_controller.rb", {
-    cwd: controllersPath,
-    nodir: true
-  });
-  const routesMap = await loadRoutesMap(rootPath);
-  for (const file of controllerFiles) {
-    const fullPath = path7.join(controllersPath, file);
-    const content = await fs7.readFile(fullPath, "utf-8");
-    const controllerName = file.replace(/_controller\.rb$/, "").replace(/\//g, "/");
-    const controllerPages = parseControllerActions(content, controllerName, file, views, routesMap);
-    pages.push(...controllerPages);
-  }
-  return pages;
-}
-async function loadRoutesMap(rootPath) {
-  const routesMap = /* @__PURE__ */ new Map();
-  try {
-    const railsDataPath = path7.join(rootPath, ".repomap", "rails-routes.json");
-    const data = await fs7.readFile(railsDataPath, "utf-8");
-    const routes = JSON.parse(data);
-    for (const route of routes) {
-      const key = `${route.controller}#${route.action}`;
-      routesMap.set(key, { path: route.path, method: route.method });
-    }
-  } catch {
-  }
-  return routesMap;
-}
-function parseControllerActions(content, controllerName, sourceFile, views, routesMap) {
-  const pages = [];
-  const publicSection = content.split(/\n\s*(private|protected)\b/)[0];
-  const actionPattern = /def\s+(\w+)/g;
-  let match;
-  while ((match = actionPattern.exec(publicSection)) !== null) {
-    const action = match[1];
-    if (["initialize", "new", "create", "update", "destroy", "index", "show", "edit"].includes(
-      action
-    ) || action.startsWith("set_") || action.startsWith("_")) ;
-    const actionStart = match.index;
-    const actionBody = extractActionBody(publicSection, actionStart);
-    const apis = extractApiCalls(actionBody, sourceFile);
-    const services = extractServiceCalls(actionBody);
-    const grpcCalls = extractGrpcCalls(actionBody);
-    const modelAccess = extractModelAccess(actionBody);
-    const view = views.find((v) => v.controller === controllerName && v.action === action);
-    const routeKey = `${controllerName}#${action}`;
-    const routeInfo = routesMap.get(routeKey);
-    pages.push({
-      route: routeInfo?.path || `/${controllerName}/${action}`,
-      method: routeInfo?.method || "GET",
-      controller: controllerName,
-      action,
-      view,
-      apis,
-      services,
-      grpcCalls,
-      modelAccess
-    });
-  }
-  return pages;
-}
-function extractActionBody(content, startIndex) {
-  let depth = 0;
-  let started = false;
-  let body = "";
-  for (let i = startIndex; i < content.length; i++) {
-    const line = content.slice(i, content.indexOf("\n", i) + 1 || content.length);
-    if (line.match(/^\s*(def|class|module|if|unless|case|while|until|for|begin|do)\b/)) {
-      depth++;
-      started = true;
-    }
-    if (line.match(/^\s*end\b/)) {
-      depth--;
-      if (started && depth === 0) {
-        break;
-      }
-    }
-    body += line;
-    i = content.indexOf("\n", i);
-    if (i === -1) break;
-  }
-  return body;
-}
-function extractApiCalls(content, sourceFile) {
-  const apis = [];
-  const httpPatterns = [
-    /HTTPClient\.(get|post|put|patch|delete)\s*\(\s*['"]([^'"]+)['"]/gi,
-    /RestClient\.(get|post|put|patch|delete)\s*\(\s*['"]([^'"]+)['"]/gi,
-    /Faraday\.(get|post|put|patch|delete)\s*\(\s*['"]([^'"]+)['"]/gi,
-    /Net::HTTP\.(get|post)\s*\(/gi
-  ];
-  for (const pattern of httpPatterns) {
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      apis.push({
-        type: "http",
-        name: match[2] || "HTTP call",
-        method: match[1]?.toUpperCase(),
-        source: sourceFile
-      });
-    }
-  }
-  return apis;
-}
-function extractServiceCalls(content) {
-  const services = [];
-  const pattern = /(\w+(?:::\w+)*Service)\.(?:call!?|new)/g;
-  let match;
-  while ((match = pattern.exec(content)) !== null) {
-    services.push(match[1]);
-  }
-  return [...new Set(services)];
-}
-function extractGrpcCalls(content) {
-  const grpcCalls = [];
-  const patterns = [
-    /(\w+(?:::\w+)*Grpc(?:::\w+)?)\./g,
-    /Grpc::(\w+(?:::\w+)*)/g,
-    /(\w+GrpcService)\./g
-  ];
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      grpcCalls.push(match[1]);
-    }
-  }
-  return [...new Set(grpcCalls)];
-}
-function extractModelAccess(content) {
-  const models = [];
-  const pattern = /([A-Z][a-zA-Z0-9]+)\.(?:find|where|find_by|first|last|all|create|update|destroy|new)/g;
-  let match;
-  while ((match = pattern.exec(content)) !== null) {
-    if (!["File", "Dir", "Time", "Date", "DateTime", "JSON", "YAML", "CSV", "Logger"].includes(
-      match[1]
-    )) {
-      models.push(match[1]);
-    }
-  }
-  return [...new Set(models)];
-}
-var COMMON_ENTRY_PATTERNS = [
-  // Webpacker (Rails 5.1+)
-  "app/javascript/packs",
-  "app/javascript/entrypoints",
-  // Vite Rails
-  "app/frontend/entrypoints",
-  // jsbundling-rails
-  "app/javascript/application",
-  // Custom patterns
-  "frontend/assets/javascripts/entries",
-  "frontend/entries",
-  "app/assets/javascripts/entries",
-  "client/entries",
-  "src/entries"
-];
-var COMMON_COMPONENT_PATTERNS = [
-  // Standard Rails
-  "app/javascript/components",
-  "app/javascript/react",
-  "app/javascript/src/components",
-  // Webpacker
-  "app/javascript/bundles",
-  // Vite
-  "app/frontend/components",
-  "app/frontend/react",
-  // Custom patterns
-  "frontend/assets/javascripts/react",
-  "frontend/assets/javascripts/components",
-  "frontend/src",
-  "frontend/src/components",
-  "frontend/components",
-  "client/components",
-  "src/components"
-];
-var VIEW_PATTERNS = {
-  // react-rails gem
-  dataReactComponent: /react_component:\s*["']([A-Za-z0-9_/]+)["']/g,
-  renderReactComponent: /render_react_component\s*\(?\s*["']([A-Za-z0-9_/]+)["']/g,
-  // react_on_rails gem
-  reactComponent: /<%=?\s*react_component\s*\(\s*["']([A-Za-z0-9_/]+)["']/g,
-  reduxStore: /<%=?\s*redux_store\s*\(\s*["']([A-Za-z0-9_/]+)["']/g,
-  // Generic patterns
-  dataComponent: /data-component\s*[=:]\s*["']([A-Za-z0-9_/]+)["']/g,
-  dataReactClass: /data-react-class\s*[=:]\s*["']([A-Za-z0-9_/]+)["']/g
-};
-async function analyzeReactComponents(rootPath) {
-  const components = /* @__PURE__ */ new Map();
-  const entryPoints = [];
-  const detectedPaths = await detectProjectStructure(rootPath);
-  console.log(
-    `   \u{1F4C2} Detected paths: ${detectedPaths.entryDirs.length} entry dirs, ${detectedPaths.componentDirs.length} component dirs (${detectedPaths.integrationPattern})`
-  );
-  for (const entryDir of detectedPaths.entryDirs) {
-    const fullEntryDir = path7.join(rootPath, entryDir);
-    try {
-      await fs7.access(fullEntryDir);
-      const entryFiles = await glob("**/*.{tsx,ts,jsx,js}", {
-        cwd: fullEntryDir,
-        nodir: true,
-        ignore: ["**/*.d.ts", "**/*.test.*", "**/*.spec.*"]
-      });
-      for (const file of entryFiles) {
-        const entryInfo = await parseEntryPoint(path7.join(fullEntryDir, file), file, entryDir);
-        if (entryInfo) {
-          entryPoints.push(entryInfo);
-          if (entryInfo.componentName) {
-            const existing = components.get(entryInfo.componentName);
-            if (existing) {
-              existing.entryFile = path7.join(entryDir, file);
-              existing.importPath = entryInfo.imports[0];
-            } else {
-              components.set(entryInfo.componentName, {
-                name: entryInfo.componentName,
-                entryFile: path7.join(entryDir, file),
-                importPath: entryInfo.imports[0],
-                ssr: false,
-                usedIn: []
-              });
-            }
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  const viewsPath = path7.join(rootPath, "app/views");
-  try {
-    await fs7.access(viewsPath);
-    const viewFiles = await glob("**/*.{haml,erb,html.haml,html.erb,slim}", {
-      cwd: viewsPath,
-      nodir: true
-    });
-    for (const viewFile of viewFiles) {
-      const usages = await findReactUsageInView(path7.join(viewsPath, viewFile), viewFile);
-      for (const usage of usages) {
-        const existing = components.get(usage.componentName);
-        if (existing) {
-          existing.usedIn.push({
-            viewPath: viewFile,
-            controller: usage.controller,
-            action: usage.action,
-            propsVar: usage.propsVar,
-            line: usage.line,
-            pattern: usage.pattern
-          });
-          if (usage.ssr) existing.ssr = true;
-        } else {
-          components.set(usage.componentName, {
-            name: usage.componentName,
-            ssr: usage.ssr,
-            usedIn: [
-              {
-                viewPath: viewFile,
-                controller: usage.controller,
-                action: usage.action,
-                propsVar: usage.propsVar,
-                line: usage.line,
-                pattern: usage.pattern
-              }
-            ]
-          });
-        }
-      }
-    }
-  } catch {
-  }
-  await resolveSourceFiles(rootPath, components, detectedPaths.componentDirs);
-  const componentList = Array.from(components.values());
-  const ssrCount = componentList.filter((c) => c.ssr).length;
-  return {
-    components: componentList,
-    entryPoints,
-    detectedPaths,
-    summary: {
-      totalComponents: componentList.length,
-      totalEntryPoints: entryPoints.length,
-      ssrComponents: ssrCount,
-      clientComponents: componentList.length - ssrCount
-    }
-  };
-}
-async function detectProjectStructure(rootPath) {
-  const entryDirs = [];
-  const componentDirs = [];
-  let integrationPattern = "unknown";
-  for (const pattern of COMMON_ENTRY_PATTERNS) {
-    const fullPath = path7.join(rootPath, pattern);
-    try {
-      const stat2 = await fs7.stat(fullPath);
-      if (stat2.isDirectory()) {
-        entryDirs.push(pattern);
-      }
-    } catch {
-    }
-  }
-  for (const pattern of COMMON_COMPONENT_PATTERNS) {
-    const fullPath = path7.join(rootPath, pattern);
-    try {
-      const stat2 = await fs7.stat(fullPath);
-      if (stat2.isDirectory()) {
-        componentDirs.push(pattern);
-      }
-    } catch {
-    }
-  }
-  integrationPattern = await detectIntegrationPattern(rootPath);
-  if (entryDirs.length === 0) {
-    const fallbackDirs = await findEntryPointDirectories(rootPath);
-    entryDirs.push(...fallbackDirs);
-  }
-  if (componentDirs.length === 0 && entryDirs.length > 0) {
-    componentDirs.push(...entryDirs);
-  }
-  return { entryDirs, componentDirs, integrationPattern };
-}
-async function detectIntegrationPattern(rootPath) {
-  try {
-    const gemfilePath = path7.join(rootPath, "Gemfile");
-    const gemfile = await fs7.readFile(gemfilePath, "utf-8");
-    if (gemfile.includes("react_on_rails")) return "react_on_rails";
-    if (gemfile.includes("react-rails")) return "react-rails";
-    if (gemfile.includes("vite_rails") || gemfile.includes("vite_ruby")) return "vite";
-    if (gemfile.includes("webpacker")) return "webpacker";
-    try {
-      await fs7.access(path7.join(rootPath, "vite.config.ts"));
-      return "vite";
-    } catch {
-    }
-    try {
-      await fs7.access(path7.join(rootPath, "vite.config.js"));
-      return "vite";
-    } catch {
-    }
-    return "custom";
-  } catch {
-    return "unknown";
-  }
-}
-async function findEntryPointDirectories(rootPath) {
-  const dirs = [];
-  const searchPatterns = [
-    "app/**/entries",
-    "app/**/packs",
-    "frontend/**/entries",
-    "client/**/entries",
-    "src/**/entries"
-  ];
-  for (const pattern of searchPatterns) {
-    try {
-      const matches = await glob(pattern, {
-        cwd: rootPath,
-        nodir: false
-      });
-      for (const match of matches) {
-        const fullPath = path7.join(rootPath, match);
-        try {
-          const stat2 = await fs7.stat(fullPath);
-          if (stat2.isDirectory()) {
-            dirs.push(match);
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  return dirs;
-}
-async function parseEntryPoint(fullPath, relativePath, entryDir) {
-  try {
-    const content = await fs7.readFile(fullPath, "utf-8");
-    const selectorPatterns = [
-      /\[data-react-component[=:][\s]*["']?([A-Za-z0-9_]+)["']?\]/,
-      /\[data-component[=:][\s]*["']?([A-Za-z0-9_]+)["']?\]/,
-      /\[data-react-class[=:][\s]*["']?([A-Za-z0-9_]+)["']?\]/,
-      /getElementById\s*\(\s*["']([A-Za-z0-9_-]+)["']\s*\)/,
-      /querySelector\s*\(\s*["']#([A-Za-z0-9_-]+)["']\s*\)/
-    ];
-    let componentName = null;
-    let selector;
-    for (const pattern of selectorPatterns) {
-      const match = content.match(pattern);
-      if (match) {
-        componentName = match[1];
-        selector = match[0];
-        break;
-      }
-    }
-    if (!componentName) {
-      const baseName = path7.basename(relativePath, path7.extname(relativePath));
-      componentName = baseName.split(/[-_]/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
-    }
-    const imports = [];
-    const importMatches = content.matchAll(
-      /import\s+(?:\{[^}]+\}|\*\s+as\s+\w+|\w+)\s+from\s+["']([^"']+)["']/g
-    );
-    for (const match of importMatches) {
-      const importPath = match[1];
-      if (importPath.includes("/react/") || importPath.includes("/components/") || importPath.includes("/containers/") || importPath.includes("/bundles/") || importPath.includes("/pages/") || importPath.match(/\/[A-Z][a-zA-Z0-9]*/)) {
-        imports.push(importPath);
-      }
-    }
-    const requireMatches = content.matchAll(/require\s*\(\s*["']([^"']+)["']\s*\)/g);
-    for (const match of requireMatches) {
-      const requirePath = match[1];
-      if (requirePath.includes("/react/") || requirePath.includes("/components/") || requirePath.includes("/containers/")) {
-        imports.push(requirePath);
-      }
-    }
-    if (!componentName && imports.length === 0) return null;
-    return {
-      file: relativePath,
-      fullPath: path7.join(entryDir, relativePath),
-      componentName: componentName || "",
-      imports,
-      selector
-    };
-  } catch {
-    return null;
-  }
-}
-async function findReactUsageInView(fullPath, relativePath) {
-  const usages = [];
-  try {
-    const content = await fs7.readFile(fullPath, "utf-8");
-    const lines = content.split("\n");
-    const parts = relativePath.split("/");
-    const fileName = parts.pop() || "";
-    const controller = parts.join("/") || "application";
-    const action = fileName.split(".")[0].replace(/^_/, "");
-    let lineNum = 0;
-    for (const line of lines) {
-      lineNum++;
-      const dataMatches = line.matchAll(VIEW_PATTERNS.dataReactComponent);
-      for (const match of dataMatches) {
-        const propsMatch = line.match(/react_component_props:\s*(@?\w+(?:\.\w+)*)/);
-        usages.push({
-          componentName: match[1],
-          controller,
-          action,
-          propsVar: propsMatch ? propsMatch[1] : void 0,
-          line: lineNum,
-          pattern: "data-react-component",
-          ssr: false
-        });
-      }
-      const renderMatch = line.match(VIEW_PATTERNS.renderReactComponent);
-      if (renderMatch) {
-        const ssrMatch = line.match(/ssr:\s*(true|false|@\w+)/);
-        usages.push({
-          componentName: renderMatch[1],
-          controller,
-          action,
-          line: lineNum,
-          pattern: "render_react_component",
-          ssr: ssrMatch ? ssrMatch[1] === "true" || ssrMatch[1].startsWith("@") : false
-        });
-      }
-      const reactOnRailsMatch = line.match(VIEW_PATTERNS.reactComponent);
-      if (reactOnRailsMatch) {
-        const propsMatch = line.match(/props:\s*(@?\w+(?:\.\w+)*)/);
-        const prerenderMatch = line.match(/prerender:\s*(true|false)/);
-        usages.push({
-          componentName: reactOnRailsMatch[1],
-          controller,
-          action,
-          propsVar: propsMatch ? propsMatch[1] : void 0,
-          line: lineNum,
-          pattern: "react_component",
-          ssr: prerenderMatch ? prerenderMatch[1] === "true" : false
-        });
-      }
-      const reduxMatch = line.match(VIEW_PATTERNS.reduxStore);
-      if (reduxMatch) {
-        usages.push({
-          componentName: reduxMatch[1],
-          controller,
-          action,
-          line: lineNum,
-          pattern: "redux_store",
-          ssr: false
-        });
-      }
-      const dataCompMatch = line.match(VIEW_PATTERNS.dataComponent);
-      if (dataCompMatch) {
-        usages.push({
-          componentName: dataCompMatch[1],
-          controller,
-          action,
-          line: lineNum,
-          pattern: "data-react-component",
-          ssr: false
-        });
-      }
-      const reactClassMatch = line.match(VIEW_PATTERNS.dataReactClass);
-      if (reactClassMatch) {
-        usages.push({
-          componentName: reactClassMatch[1],
-          controller,
-          action,
-          line: lineNum,
-          pattern: "data-react-component",
-          ssr: false
-        });
-      }
-    }
-  } catch {
-  }
-  return usages;
-}
-async function resolveSourceFiles(rootPath, components, componentDirs) {
-  for (const [name, component] of components) {
-    if (!name || typeof name !== "string") continue;
-    if (component.importPath && typeof component.importPath === "string") {
-      const cleanPath = component.importPath.replace(/\.js$/, "").replace(/\.tsx?$/, "").replace(/^\.\.\//, "").replace(/^\.\//, "");
-      component.sourceFile = cleanPath;
-    } else if (!component.sourceFile) {
-      const extensions = [".tsx", ".ts", ".jsx", ".js"];
-      const namingPatterns = [
-        name,
-        // PascalCase
-        toSnakeCase(name),
-        // snake_case
-        toKebabCase(name)
-        // kebab-case
-      ].filter(Boolean);
-      let found = false;
-      for (const dir of componentDirs) {
-        if (found) break;
-        for (const naming of namingPatterns) {
-          if (found) break;
-          for (const ext of extensions) {
-            const possiblePaths = [
-              path7.join(rootPath, dir, naming, `index${ext}`),
-              path7.join(rootPath, dir, naming, `${naming}${ext}`),
-              path7.join(rootPath, dir, `${naming}${ext}`),
-              path7.join(rootPath, dir, "components", `${naming}${ext}`),
-              path7.join(rootPath, dir, "containers", `${naming}${ext}`)
-            ];
-            for (const possiblePath of possiblePaths) {
-              try {
-                await fs7.access(possiblePath);
-                component.sourceFile = path7.relative(rootPath, possiblePath);
-                found = true;
-                break;
-              } catch {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-function toSnakeCase(str) {
-  if (!str) return "";
-  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
-}
-function toKebabCase(str) {
-  if (!str) return "";
-  return str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
-}
-
-// src/analyzers/rails/index.ts
-async function analyzeRailsApp(rootPath) {
-  console.log(`
-\u{1F4E6} Analyzing Rails application at: ${rootPath}
-`);
-  console.log("\u{1F504} Analyzing routes...");
-  const routesAnalyzer = new RailsRoutesAnalyzer(rootPath);
-  const routes = await routesAnalyzer.analyze();
-  console.log(`   \u2705 Found ${routes.routes.length} routes`);
-  console.log("\u{1F504} Analyzing controllers...");
-  const controllersAnalyzer = new RailsControllerAnalyzer(rootPath);
-  const controllers = await controllersAnalyzer.analyze();
-  console.log(
-    `   \u2705 Found ${controllers.controllers.length} controllers with ${controllers.totalActions} actions`
-  );
-  console.log("\u{1F504} Analyzing models...");
-  const modelsAnalyzer = new RailsModelAnalyzer(rootPath);
-  const models = await modelsAnalyzer.analyze();
-  console.log(
-    `   \u2705 Found ${models.models.length} models with ${models.totalAssociations} associations`
-  );
-  console.log("\u{1F504} Analyzing gRPC services...");
-  const grpcAnalyzer = new RailsGrpcAnalyzer(rootPath);
-  const grpc = await grpcAnalyzer.analyze();
-  console.log(`   \u2705 Found ${grpc.services.length} gRPC services with ${grpc.totalRpcs} RPCs`);
-  console.log("\u{1F504} Analyzing views...");
-  const views = await analyzeRailsViews(rootPath);
-  console.log(
-    `   \u2705 Found ${views.summary.totalViews} views and ${views.summary.totalPages} pages`
-  );
-  console.log("\u{1F504} Analyzing React components...");
-  const react = await analyzeReactComponents(rootPath);
-  console.log(
-    `   \u2705 Found ${react.summary.totalComponents} React components (${react.summary.ssrComponents} SSR, ${react.summary.clientComponents} client)`
-  );
-  const allNamespaces = [
-    .../* @__PURE__ */ new Set([
-      ...routes.namespaces,
-      ...controllers.namespaces,
-      ...models.namespaces,
-      ...grpc.namespaces
-    ])
-  ];
-  const allConcerns = [.../* @__PURE__ */ new Set([...controllers.concerns, ...models.concerns])];
-  const summary = {
-    totalRoutes: routes.routes.length,
-    totalControllers: controllers.controllers.length,
-    totalActions: controllers.totalActions,
-    totalModels: models.models.length,
-    totalAssociations: models.totalAssociations,
-    totalValidations: models.totalValidations,
-    totalGrpcServices: grpc.services.length,
-    totalRpcs: grpc.totalRpcs,
-    totalViews: views.summary.totalViews,
-    totalPages: views.summary.totalPages,
-    totalReactComponents: react.summary.totalComponents,
-    ssrReactComponents: react.summary.ssrComponents,
-    namespaces: allNamespaces,
-    concerns: allConcerns
-  };
-  return {
-    routes,
-    controllers,
-    models,
-    grpc,
-    views,
-    react,
-    summary
-  };
-}
-async function main5() {
-  const targetPath = process.argv[2] || process.cwd();
-  const result = await analyzeRailsApp(targetPath);
-  console.log("\n" + "=".repeat(60));
-  console.log("\u{1F4CA} RAILS APPLICATION ANALYSIS SUMMARY");
-  console.log("=".repeat(60) + "\n");
-  console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  console.log("\u2502 Routes                                              \u2502");
-  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-  console.log(
-    `\u2502  Total routes:         ${String(result.summary.totalRoutes).padStart(6)}                      \u2502`
-  );
-  console.log(
-    `\u2502  Resources:            ${String(result.routes.resources.length).padStart(6)}                      \u2502`
-  );
-  console.log(
-    `\u2502  Mounted engines:      ${String(result.routes.mountedEngines.length).padStart(6)}                      \u2502`
-  );
-  console.log(
-    `\u2502  External files:       ${String(result.routes.drawnFiles.length).padStart(6)}                      \u2502`
-  );
-  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  console.log("\u2502 Controllers                                         \u2502");
-  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-  console.log(
-    `\u2502  Total controllers:    ${String(result.summary.totalControllers).padStart(6)}                      \u2502`
-  );
-  console.log(
-    `\u2502  Total actions:        ${String(result.summary.totalActions).padStart(6)}                      \u2502`
-  );
-  console.log(
-    `\u2502  Namespaces:           ${String(result.controllers.namespaces.length).padStart(6)}                      \u2502`
-  );
-  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  console.log("\u2502 Models                                              \u2502");
-  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-  console.log(
-    `\u2502  Total models:         ${String(result.summary.totalModels).padStart(6)}                      \u2502`
-  );
-  console.log(
-    `\u2502  Associations:         ${String(result.summary.totalAssociations).padStart(6)}                      \u2502`
-  );
-  console.log(
-    `\u2502  Validations:          ${String(result.summary.totalValidations).padStart(6)}                      \u2502`
-  );
-  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  console.log("\u2502 gRPC Services                                       \u2502");
-  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-  console.log(
-    `\u2502  Total services:       ${String(result.summary.totalGrpcServices).padStart(6)}                      \u2502`
-  );
-  console.log(
-    `\u2502  Total RPCs:           ${String(result.summary.totalRpcs).padStart(6)}                      \u2502`
-  );
-  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  console.log("\u2502 Shared                                              \u2502");
-  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-  console.log(
-    `\u2502  Total namespaces:     ${String(result.summary.namespaces.length).padStart(6)}                      \u2502`
-  );
-  console.log(
-    `\u2502  Total concerns:       ${String(result.summary.concerns.length).padStart(6)}                      \u2502`
-  );
-  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  const totalErrors = result.routes.errors.length + result.controllers.errors.length + result.models.errors.length + result.grpc.errors.length;
-  if (totalErrors > 0) {
-    console.log(`
-\u26A0\uFE0F  Total errors: ${totalErrors}`);
-  } else {
-    console.log("\n\u2705 Analysis completed without errors!");
-  }
-}
-var isMainModule5 = import.meta.url === `file://${process.argv[1]}`;
-if (isMainModule5) {
-  main5().catch(console.error);
-}
-
-export { RailsControllerAnalyzer, RailsGrpcAnalyzer, RailsModelAnalyzer, RailsRoutesAnalyzer, analyzeRailsApp, analyzeRailsViews, analyzeReactComponents, findNodes, initRubyParser, parseRuby, parseRubyFile };