@wtdlee/repomap 0.2.0 → 0.3.1

package/dist/analyzers/rails/rails-grpc-analyzer.js

@@ -1,262 +0,0 @@
-/**
- * Rails gRPC Service Analyzer using tree-sitter
- * tree-sitterを使用してgRPCサービスを解析する
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-import { parseRubyFile, findNodes, getClassName, getSuperclass, getMethodName, getMethodParameters, } from './ruby-parser.js';
-export class RailsGrpcAnalyzer {
-    rootPath;
-    grpcDir;
-    services = [];
-    errors = [];
-    constructor(rootPath) {
-        this.rootPath = rootPath;
-        this.grpcDir = path.join(rootPath, 'app', 'grpc_services');
-    }
-    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 = path.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;
-        // Extract namespace from path
-        const pathParts = relativePath.replace(/_grpc_service\.rb$/, '').split('/');
-        const namespace = pathParts.length > 1 ? pathParts.slice(0, -1).join('/') : undefined;
-        const serviceName = pathParts[pathParts.length - 1];
-        // Find class definition
-        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,
-        };
-        // Extract proto service from parent class
-        if (parentClass) {
-            // e.g., Visit::ConversationPb::ConversationService::Service
-            const protoMatch = parentClass.match(/(\w+)::Service$/);
-            if (protoMatch) {
-                service.protoService = parentClass.replace('::Service', '');
-            }
-        }
-        // Find include statements (concerns)
-        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);
-                    }
-                }
-            }
-        }
-        // Find method definitions (RPC methods)
-        const _methods = 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) {
-                        // Extract policies and serializers from method body
-                        const methodCalls = findNodes(child, 'call');
-                        for (const mc of methodCalls) {
-                            const methodName = mc.childForFieldName('method')?.text;
-                            const receiver = mc.childForFieldName('receiver')?.text;
-                            // Policy patterns
-                            if (methodName === 'authorize!' || methodName === 'new') {
-                                if (receiver?.includes('Policy')) {
-                                    if (!service.policies.includes(receiver)) {
-                                        service.policies.push(receiver);
-                                    }
-                                    rpc.policyMethod = 'authorize!';
-                                }
-                            }
-                            // Serializer patterns
-                            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;
-        // Skip common non-RPC methods
-        const skipMethods = ['initialize', 'to_s', 'inspect', 'call', 'perform', 'execute'];
-        if (skipMethods.includes(name))
-            return null;
-        const _params = getMethodParameters(methodNode);
-        const methodBody = methodNode.text;
-        const rpc = {
-            name,
-            line: methodNode.startPosition.row + 1,
-            streaming: 'none',
-            modelsUsed: [],
-            servicesUsed: [],
-        };
-        // Try to extract request/response types from comments or code
-        // @param [Visit::ConversationPb::GetConversationRequest] req
-        const requestMatch = methodBody.match(/@param\s+\[([^\]]+)\]\s+req/);
-        if (requestMatch) {
-            rpc.requestType = requestMatch[1];
-        }
-        // @return [Visit::ConversationPb::Conversation]
-        const responseMatch = methodBody.match(/@return\s+\[([^\]]+)\]/);
-        if (responseMatch) {
-            rpc.responseType = responseMatch[1];
-        }
-        // Extract models used (ActiveRecord patterns)
-        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);
-            }
-        }
-        // Extract services used
-        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 results = [];
-            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')) {
-                        results.push(child);
-                    }
-                }
-            }
-            return results;
-        }
-        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;
-    }
-}
-// Standalone execution for testing
-async function main() {
-    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(`\n--- Errors (${result.errors.length}) ---`);
-        for (const error of result.errors.slice(0, 5)) {
-            console.log(`  ❌ ${error}`);
-        }
-    }
-    console.log('\n--- Sample Services (first 15) ---');
-    for (const service of result.services.slice(0, 15)) {
-        console.log(`\n  📡 ${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(', ')}`);
-        }
-    }
-    // RPC summary
-    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}`);
-}
-// Run if executed directly
-const isMainModule = import.meta.url === `file://${process.argv[1]}`;
-if (isMainModule) {
-    main().catch(console.error);
-}

package/dist/analyzers/rails/rails-model-analyzer.d.ts

@@ -1,88 +0,0 @@
-/**
- * Rails Model Analyzer using tree-sitter
- * tree-sitterを使用してモデルファイルを解析する
- */
-export interface ModelInfo {
-    name: string;
-    filePath: string;
-    className: string;
-    parentClass: string;
-    tableName?: string;
-    associations: AssociationInfo[];
-    validations: ValidationInfo[];
-    callbacks: CallbackInfo[];
-    scopes: ScopeInfo[];
-    concerns: string[];
-    enums: EnumInfo[];
-    attributes: AttributeInfo[];
-    classMethodsCount: number;
-    instanceMethodsCount: number;
-    line: number;
-}
-export interface AssociationInfo {
-    type: 'belongs_to' | 'has_one' | 'has_many' | 'has_and_belongs_to_many';
-    name: string;
-    className?: string;
-    foreignKey?: string;
-    through?: string;
-    polymorphic?: boolean;
-    dependent?: string;
-    optional?: boolean;
-    line: number;
-}
-export interface ValidationInfo {
-    type: string;
-    attributes: string[];
-    options?: Record<string, string>;
-    line: number;
-}
-export interface CallbackInfo {
-    type: string;
-    method: string;
-    conditions?: string;
-    line: number;
-}
-export interface ScopeInfo {
-    name: string;
-    lambda: boolean;
-    line: number;
-}
-export interface EnumInfo {
-    name: string;
-    values: string[];
-    line: number;
-}
-export interface AttributeInfo {
-    name: string;
-    type?: string;
-    default?: string;
-    line: number;
-}
-export interface RailsModelsResult {
-    models: ModelInfo[];
-    totalAssociations: number;
-    totalValidations: number;
-    concerns: string[];
-    namespaces: string[];
-    errors: string[];
-}
-export declare class RailsModelAnalyzer {
-    private rootPath;
-    private modelsDir;
-    private models;
-    private errors;
-    constructor(rootPath: string);
-    analyze(): Promise<RailsModelsResult>;
-    private parseModelFile;
-    private isActiveRecordModel;
-    private parseTableName;
-    private parseAssociation;
-    private parseValidation;
-    private isCallback;
-    private parseCallback;
-    private parseScope;
-    private parseInclude;
-    private parseEnum;
-    private parseAttribute;
-    private getCallArguments;
-}