@wtdlee/repomap 0.3.0 → 0.3.1

package/dist/analyzers/index.d.ts

@@ -1,5 +1,69 @@
-export * from './base-analyzer.js';
-export * from './pages-analyzer.js';
-export * from './graphql-analyzer.js';
-export * from './dataflow-analyzer.js';
-export * from './rest-api-analyzer.js';
+import { B as BaseAnalyzer } from '../dataflow-analyzer-BfAiqVUp.js';
+export { D as DataFlowAnalyzer, G as GraphQLAnalyzer, P as PagesAnalyzer } from '../dataflow-analyzer-BfAiqVUp.js';
+import { RepositoryConfig, AnalysisResult } from '../types.js';
+
+/**
+ * Analyzer for REST API calls (fetch, axios, useSWR, etc.)
+ * REST API呼び出しの分析器
+ */
+declare class RestApiAnalyzer extends BaseAnalyzer {
+    private project;
+    private apiCallCounter;
+    constructor(config: RepositoryConfig);
+    getName(): string;
+    analyze(): Promise<Partial<AnalysisResult>>;
+    /**
+     * Find fetch() calls
+     */
+    private findFetchCalls;
+    /**
+     * Find axios calls (axios.get, axios.post, etc.)
+     */
+    private findAxiosCalls;
+    /**
+     * Find useSWR calls
+     */
+    private findSwrCalls;
+    /**
+     * Extract API call info from fetch()
+     */
+    private extractFetchCall;
+    /**
+     * Extract API call info from axios.method()
+     */
+    private extractAxiosCall;
+    /**
+     * Extract API call info from axios() direct call
+     */
+    private extractAxiosDirectCall;
+    /**
+     * Extract API call info from useSWR()
+     */
+    private extractSwrCall;
+    /**
+     * Get the name of the containing function/component
+     */
+    private getContainingFunctionName;
+    /**
+     * Extract URL from argument (handles literals, variables, function calls)
+     */
+    private extractUrlFromArg;
+    /**
+     * Clean string literal (remove quotes)
+     */
+    private cleanStringLiteral;
+    /**
+     * Check if URL looks like an API endpoint
+     */
+    private isApiUrl;
+    /**
+     * Categorize API by URL pattern
+     */
+    private categorizeApi;
+    /**
+     * Normalize HTTP method
+     */
+    private normalizeMethod;
+}
+
+export { BaseAnalyzer, RestApiAnalyzer };

package/dist/analyzers/index.js

@@ -1,5 +1 @@
-export * from './base-analyzer.js';
-export * from './pages-analyzer.js';
-export * from './graphql-analyzer.js';
-export * from './dataflow-analyzer.js';
-export * from './rest-api-analyzer.js';
+export { BaseAnalyzer, DataFlowAnalyzer, GraphQLAnalyzer, PagesAnalyzer, RestApiAnalyzer } from '../chunk-GNBMJMET.js';

package/dist/chunk-3PWXDB7B.js

@@ -0,0 +1,153 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+// src/utils/env-detector.ts
+async function detectEnvironments(rootPath) {
+  const environments = [];
+  const railsEnv = await detectRails(rootPath);
+  if (railsEnv.detected) {
+    environments.push(railsEnv);
+  }
+  const jsEnv = await detectJsEnvironment(rootPath);
+  if (jsEnv.detected) {
+    environments.push(jsEnv);
+  }
+  const hasNextjs = environments.some((e) => e.type === "nextjs");
+  const hasReact = environments.some((e) => e.type === "react" || e.type === "nextjs");
+  const hasRails = environments.some((e) => e.type === "rails");
+  let primary = "generic";
+  if (hasNextjs) {
+    primary = "nextjs";
+  } else if (hasReact) {
+    primary = "react";
+  } else if (hasRails) {
+    primary = "rails";
+  }
+  return {
+    environments,
+    hasNextjs,
+    hasReact,
+    hasRails,
+    primary
+  };
+}
+async function detectRails(rootPath) {
+  const result = {
+    type: "rails",
+    detected: false,
+    path: rootPath,
+    features: []
+  };
+  try {
+    const gemfilePath = path.join(rootPath, "Gemfile");
+    const routesPath = path.join(rootPath, "config", "routes.rb");
+    await fs.access(gemfilePath);
+    await fs.access(routesPath);
+    const gemfile = await fs.readFile(gemfilePath, "utf-8");
+    const isRails = gemfile.includes("gem 'rails'") || gemfile.includes('gem "rails"');
+    if (!isRails) {
+      return result;
+    }
+    result.detected = true;
+    const versionMatch = gemfile.match(/gem ['"]rails['"],\s*['"]([^'"]+)['"]/);
+    if (versionMatch) {
+      result.version = versionMatch[1];
+    }
+    const features = [];
+    try {
+      await fs.access(path.join(rootPath, "app", "grpc_services"));
+      features.push("grpc");
+    } catch {
+    }
+    try {
+      const appConfig = await fs.readFile(path.join(rootPath, "config", "application.rb"), "utf-8");
+      if (appConfig.includes("config.api_only = true")) {
+        features.push("api-only");
+      }
+    } catch {
+    }
+    if (gemfile.includes("gem 'graphql'") || gemfile.includes('gem "graphql"')) {
+      features.push("graphql");
+    }
+    if (gemfile.includes("gem 'devise'") || gemfile.includes('gem "devise"')) {
+      features.push("devise");
+    }
+    result.features = features;
+  } catch {
+  }
+  return result;
+}
+async function detectJsEnvironment(rootPath) {
+  const result = {
+    type: "react",
+    detected: false,
+    path: rootPath,
+    features: []
+  };
+  try {
+    const packageJsonPath = path.join(rootPath, "package.json");
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    if (!deps["react"]) {
+      return result;
+    }
+    result.detected = true;
+    result.version = deps["react"];
+    const features = [];
+    if (deps["next"]) {
+      result.type = "nextjs";
+      result.version = deps["next"];
+      try {
+        await fs.access(path.join(rootPath, "app"));
+        features.push("app-router");
+      } catch {
+      }
+      try {
+        await fs.access(path.join(rootPath, "pages"));
+        features.push("pages-router");
+      } catch {
+      }
+      try {
+        await fs.access(path.join(rootPath, "src", "pages"));
+        features.push("pages-router");
+      } catch {
+      }
+      try {
+        await fs.access(path.join(rootPath, "src", "app"));
+        features.push("app-router");
+      } catch {
+      }
+    }
+    if (deps["@apollo/client"] || deps["graphql"] || deps["graphql-request"] || deps["urql"]) {
+      features.push("graphql");
+    }
+    if (deps["typescript"]) {
+      features.push("typescript");
+    }
+    if (deps["redux"] || deps["@reduxjs/toolkit"]) {
+      features.push("redux");
+    }
+    if (deps["zustand"]) {
+      features.push("zustand");
+    }
+    if (deps["jotai"] || deps["recoil"]) {
+      features.push("atomic-state");
+    }
+    result.features = features;
+  } catch {
+  }
+  return result;
+}
+function getAnalyzersForEnvironments(envResult) {
+  const frontend = [];
+  const backend = [];
+  if (envResult.hasNextjs || envResult.hasReact) {
+    frontend.push("pages", "graphql", "dataflow", "rest-api");
+  }
+  if (envResult.hasRails) {
+    backend.push("routes", "controllers", "models", "grpc");
+  }
+  return { frontend, backend };
+}
+
+export { detectEnvironments, getAnalyzersForEnvironments };