@wtdlee/repomap 0.3.0 → 0.3.1

package/dist/utils/env-detector.js

@@ -1,188 +0,0 @@
-/**
- * Environment detection utilities
- * 環境検出ユーティリティ
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-/**
- * Detect all environments in the given directory
- * 指定されたディレクトリ内のすべての環境を検出
- */
-export async function detectEnvironments(rootPath) {
-    const environments = [];
-    // Check for Rails
-    const railsEnv = await detectRails(rootPath);
-    if (railsEnv.detected) {
-        environments.push(railsEnv);
-    }
-    // Check for Next.js / React
-    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');
-    // Determine primary environment
-    let primary = 'generic';
-    if (hasNextjs) {
-        primary = 'nextjs';
-    }
-    else if (hasReact) {
-        primary = 'react';
-    }
-    else if (hasRails) {
-        primary = 'rails';
-    }
-    return {
-        environments,
-        hasNextjs,
-        hasReact,
-        hasRails,
-        primary,
-    };
-}
-/**
- * Detect Rails environment
- */
-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');
-        // Check for Gemfile
-        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;
-        // Extract Rails version
-        const versionMatch = gemfile.match(/gem ['"]rails['"],\s*['"]([^'"]+)['"]/);
-        if (versionMatch) {
-            result.version = versionMatch[1];
-        }
-        // Detect features
-        const features = [];
-        // Check for gRPC services
-        try {
-            await fs.access(path.join(rootPath, 'app', 'grpc_services'));
-            features.push('grpc');
-        }
-        catch { }
-        // Check for API mode
-        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 { }
-        // Check for GraphQL
-        if (gemfile.includes("gem 'graphql'") || gemfile.includes('gem "graphql"')) {
-            features.push('graphql');
-        }
-        // Check for Devise
-        if (gemfile.includes("gem 'devise'") || gemfile.includes('gem "devise"')) {
-            features.push('devise');
-        }
-        result.features = features;
-    }
-    catch {
-        // Not a Rails project
-    }
-    return result;
-}
-/**
- * Detect JavaScript environment (Next.js or React)
- */
-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 };
-        // Check for React
-        if (!deps['react']) {
-            return result;
-        }
-        result.detected = true;
-        result.version = deps['react'];
-        const features = [];
-        // Check for Next.js
-        if (deps['next']) {
-            result.type = 'nextjs';
-            result.version = deps['next'];
-            // Check for App Router vs Pages Router
-            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 { }
-        }
-        // Check for GraphQL
-        if (deps['@apollo/client'] || deps['graphql'] || deps['graphql-request'] || deps['urql']) {
-            features.push('graphql');
-        }
-        // Check for TypeScript
-        if (deps['typescript']) {
-            features.push('typescript');
-        }
-        // Check for state management
-        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 {
-        // Not a JS project
-    }
-    return result;
-}
-/**
- * Get analyzer types for detected environments
- */
-export 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 };
-}

package/dist/utils/parallel.d.ts

@@ -1,23 +0,0 @@
-/**
- * Parallel processing utilities
- * 병렬 처리 유틸리티
- */
-/**
- * Process items in parallel with concurrency limit
- * 동시성 제한을 두고 아이템들을 병렬 처리
- *
- * @param items - Items to process
- * @param fn - Async function to apply to each item
- * @param concurrency - Maximum concurrent operations (default: CPU cores)
- */
-export declare function parallelMap<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, concurrency?: number): Promise<R[]>;
-/**
- * Process items in parallel, collecting successful results
- * 실패한 항목은 무시하고 성공한 결과만 수집
- */
-export declare function parallelMapSafe<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, concurrency?: number): Promise<R[]>;
-/**
- * Process items in batches
- * 배치 단위로 처리
- */
-export declare function batchProcess<T, R>(items: T[], fn: (batch: T[]) => Promise<R[]>, batchSize?: number): Promise<R[]>;

package/dist/utils/parallel.js

@@ -1,70 +0,0 @@
-/**
- * Parallel processing utilities
- * 병렬 처리 유틸리티
- */
-/**
- * Process items in parallel with concurrency limit
- * 동시성 제한을 두고 아이템들을 병렬 처리
- *
- * @param items - Items to process
- * @param fn - Async function to apply to each item
- * @param concurrency - Maximum concurrent operations (default: CPU cores)
- */
-export async function parallelMap(items, fn, concurrency = 8) {
-    const results = new Array(items.length);
-    let currentIndex = 0;
-    async function worker() {
-        while (currentIndex < items.length) {
-            const index = currentIndex++;
-            if (index < items.length) {
-                results[index] = await fn(items[index], index);
-            }
-        }
-    }
-    // Create workers up to concurrency limit
-    const workers = Array(Math.min(concurrency, items.length))
-        .fill(null)
-        .map(() => worker());
-    await Promise.all(workers);
-    return results;
-}
-/**
- * Process items in parallel, collecting successful results
- * 실패한 항목은 무시하고 성공한 결과만 수집
- */
-export async function parallelMapSafe(items, fn, concurrency = 8) {
-    const results = new Array(items.length).fill(null);
-    let currentIndex = 0;
-    async function worker() {
-        while (currentIndex < items.length) {
-            const index = currentIndex++;
-            if (index < items.length) {
-                try {
-                    results[index] = await fn(items[index], index);
-                }
-                catch {
-                    // Silently ignore errors
-                    results[index] = null;
-                }
-            }
-        }
-    }
-    const workers = Array(Math.min(concurrency, items.length))
-        .fill(null)
-        .map(() => worker());
-    await Promise.all(workers);
-    return results.filter((r) => r !== null);
-}
-/**
- * Process items in batches
- * 배치 단위로 처리
- */
-export async function batchProcess(items, fn, batchSize = 50) {
-    const results = [];
-    for (let i = 0; i < items.length; i += batchSize) {
-        const batch = items.slice(i, i + batchSize);
-        const batchResults = await fn(batch);
-        results.push(...batchResults);
-    }
-    return results;
-}

package/dist/utils/port.d.ts

@@ -1,15 +0,0 @@
-/**
- * Check if a port is available
- * ポートが使用可能かどうかを確認
- */
-export declare function isPortAvailable(port: number): Promise<boolean>;
-/**
- * Find an available port starting from the given port
- * 指定されたポートから利用可能なポートを探す
- *
- * @param startPort - Port to start searching from
- * @param maxAttempts - Maximum number of ports to try (default: 10)
- * @returns Available port number
- * @throws Error if no available port found within maxAttempts
- */
-export declare function findAvailablePort(startPort: number, maxAttempts?: number): Promise<number>;

package/dist/utils/port.js

@@ -1,41 +0,0 @@
-import * as net from 'net';
-/**
- * Check if a port is available
- * ポートが使用可能かどうかを確認
- */
-export function isPortAvailable(port) {
-    return new Promise((resolve) => {
-        const server = net.createServer();
-        server.once('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                resolve(false);
-            }
-            else {
-                resolve(false);
-            }
-        });
-        server.once('listening', () => {
-            server.close();
-            resolve(true);
-        });
-        server.listen(port);
-    });
-}
-/**
- * Find an available port starting from the given port
- * 指定されたポートから利用可能なポートを探す
- *
- * @param startPort - Port to start searching from
- * @param maxAttempts - Maximum number of ports to try (default: 10)
- * @returns Available port number
- * @throws Error if no available port found within maxAttempts
- */
-export async function findAvailablePort(startPort, maxAttempts = 10) {
-    for (let i = 0; i < maxAttempts; i++) {
-        const port = startPort + i;
-        if (await isPortAvailable(port)) {
-            return port;
-        }
-    }
-    throw new Error(`No available port found between ${startPort} and ${startPort + maxAttempts - 1}`);
-}