activo 0.2.1 → 0.3.0

package/dist/core/tools/javaAst.js

@@ -0,0 +1,678 @@
+import fs from "fs";
+import path from "path";
+import { parse, createVisitor } from "java-ast";
+// Calculate cyclomatic complexity from method body text
+function calculateComplexity(methodText) {
+    let complexity = 1;
+    // Count decision points
+    const patterns = [
+        /\bif\s*\(/g,
+        /\belse\s+if\s*\(/g,
+        /\bfor\s*\(/g,
+        /\bwhile\s*\(/g,
+        /\bcase\s+/g,
+        /\bcatch\s*\(/g,
+        /\b\?\s*[^:]/g, // ternary operator
+        /\&\&/g,
+        /\|\|/g,
+    ];
+    for (const pattern of patterns) {
+        const matches = methodText.match(pattern);
+        if (matches) {
+            complexity += matches.length;
+        }
+    }
+    return complexity;
+}
+// Analyze Java file
+function analyzeJavaFile(content, filepath) {
+    const analysis = {
+        filepath,
+        package: "",
+        imports: [],
+        classes: [],
+        complexity: { total: 0, average: 0, highest: { name: "", value: 0 } },
+    };
+    try {
+        const tree = parse(content);
+        const lines = content.split("\n");
+        // Get line number from context
+        const getLine = (ctx) => {
+            if (ctx && ctx.start) {
+                return ctx.start.line;
+            }
+            return 0;
+        };
+        // Get text from context
+        const getText = (ctx) => {
+            if (ctx && ctx.start && ctx.stop) {
+                const startIdx = ctx.start.startIndex;
+                const stopIdx = ctx.stop.stopIndex;
+                return content.substring(startIdx, stopIdx + 1);
+            }
+            return ctx?.text || "";
+        };
+        // Get modifiers
+        const getModifiers = (modifierCtxs) => {
+            if (!modifierCtxs)
+                return [];
+            return modifierCtxs.map((m) => m.text).filter((m) => m);
+        };
+        // Get annotations
+        const getAnnotations = (modifierCtxs) => {
+            if (!modifierCtxs)
+                return [];
+            return modifierCtxs
+                .filter((m) => m.annotation)
+                .map((m) => m.annotation()?.qualifiedName()?.text || m.text)
+                .filter((a) => a);
+        };
+        // Parse using visitor pattern
+        const visitor = createVisitor({
+            defaultResult: () => null,
+            aggregateResult: (a, b) => b || a,
+            visitPackageDeclaration: (ctx) => {
+                analysis.package = ctx.qualifiedName()?.text || "";
+                return null;
+            },
+            visitImportDeclaration: (ctx) => {
+                const importText = ctx.qualifiedName()?.text || "";
+                if (importText) {
+                    const isStatic = ctx.STATIC() ? "static " : "";
+                    const isWildcard = ctx.MUL() ? ".*" : "";
+                    analysis.imports.push(isStatic + importText + isWildcard);
+                }
+                return null;
+            },
+            visitClassDeclaration: (ctx) => {
+                const classInfo = {
+                    name: ctx.identifier()?.text || "Unknown",
+                    type: "class",
+                    modifiers: [],
+                    line: getLine(ctx),
+                    implements: [],
+                    annotations: [],
+                    methods: [],
+                    fields: [],
+                    innerClasses: [],
+                };
+                // Get parent modifiers
+                const parent = ctx.parent;
+                if (parent && parent.classOrInterfaceModifier) {
+                    const mods = parent.classOrInterfaceModifier();
+                    classInfo.modifiers = getModifiers(mods);
+                    classInfo.annotations = getAnnotations(mods);
+                }
+                // Extends
+                const extendsType = ctx.typeType();
+                if (extendsType) {
+                    classInfo.extends = extendsType.text;
+                }
+                // Implements
+                const typeList = ctx.typeList();
+                if (typeList && typeList.length > 0) {
+                    for (const tl of typeList) {
+                        const types = tl.typeType();
+                        if (types) {
+                            classInfo.implements.push(...types.map((t) => t.text));
+                        }
+                    }
+                }
+                // Parse class body
+                const classBody = ctx.classBody();
+                if (classBody) {
+                    const bodyDecls = classBody.classBodyDeclaration();
+                    for (const bodyDecl of bodyDecls) {
+                        const memberDecl = bodyDecl.memberDeclaration?.();
+                        if (!memberDecl)
+                            continue;
+                        // Method
+                        const methodDecl = memberDecl.methodDeclaration?.();
+                        if (methodDecl) {
+                            const methodInfo = {
+                                name: methodDecl.identifier()?.text || "unknown",
+                                returnType: methodDecl.typeTypeOrVoid()?.text || "void",
+                                params: [],
+                                modifiers: [],
+                                line: getLine(methodDecl),
+                                annotations: [],
+                                throws: [],
+                                complexity: 1,
+                            };
+                            // Get modifiers from parent
+                            const modCtxs = bodyDecl.modifier?.();
+                            if (modCtxs) {
+                                methodInfo.modifiers = getModifiers(modCtxs);
+                                methodInfo.annotations = getAnnotations(modCtxs);
+                            }
+                            // Parameters
+                            const formalParams = methodDecl.formalParameters()?.formalParameterList?.();
+                            if (formalParams) {
+                                const params = formalParams.formalParameter?.();
+                                if (params) {
+                                    for (const param of params) {
+                                        methodInfo.params.push({
+                                            name: param.variableDeclaratorId()?.text || "",
+                                            type: param.typeType()?.text || "",
+                                        });
+                                    }
+                                }
+                            }
+                            // Throws
+                            const throwsClause = methodDecl.THROWS?.();
+                            if (throwsClause) {
+                                const qualNames = methodDecl.qualifiedNameList()?.qualifiedName?.();
+                                if (qualNames) {
+                                    methodInfo.throws = qualNames.map((q) => q.text);
+                                }
+                            }
+                            // Complexity
+                            const methodBody = methodDecl.methodBody();
+                            if (methodBody) {
+                                methodInfo.complexity = calculateComplexity(getText(methodBody));
+                            }
+                            classInfo.methods.push(methodInfo);
+                        }
+                        // Constructor
+                        const ctorDecl = memberDecl.constructorDeclaration?.();
+                        if (ctorDecl) {
+                            const ctorInfo = {
+                                name: ctorDecl.identifier()?.text || classInfo.name,
+                                returnType: classInfo.name,
+                                params: [],
+                                modifiers: [],
+                                line: getLine(ctorDecl),
+                                annotations: [],
+                                throws: [],
+                                complexity: 1,
+                            };
+                            const modCtxs = bodyDecl.modifier?.();
+                            if (modCtxs) {
+                                ctorInfo.modifiers = getModifiers(modCtxs);
+                                ctorInfo.annotations = getAnnotations(modCtxs);
+                            }
+                            const formalParams = ctorDecl.formalParameters()?.formalParameterList?.();
+                            if (formalParams) {
+                                const params = formalParams.formalParameter?.();
+                                if (params) {
+                                    for (const param of params) {
+                                        ctorInfo.params.push({
+                                            name: param.variableDeclaratorId()?.text || "",
+                                            type: param.typeType()?.text || "",
+                                        });
+                                    }
+                                }
+                            }
+                            const ctorBody = ctorDecl.block();
+                            if (ctorBody) {
+                                ctorInfo.complexity = calculateComplexity(getText(ctorBody));
+                            }
+                            classInfo.methods.push(ctorInfo);
+                        }
+                        // Field
+                        const fieldDecl = memberDecl.fieldDeclaration?.();
+                        if (fieldDecl) {
+                            const varDecls = fieldDecl.variableDeclarators()?.variableDeclarator?.();
+                            if (varDecls) {
+                                for (const varDecl of varDecls) {
+                                    const fieldInfo = {
+                                        name: varDecl.variableDeclaratorId()?.text || "",
+                                        type: fieldDecl.typeType()?.text || "",
+                                        modifiers: [],
+                                        line: getLine(fieldDecl),
+                                        annotations: [],
+                                    };
+                                    const modCtxs = bodyDecl.modifier?.();
+                                    if (modCtxs) {
+                                        fieldInfo.modifiers = getModifiers(modCtxs);
+                                        fieldInfo.annotations = getAnnotations(modCtxs);
+                                    }
+                                    classInfo.fields.push(fieldInfo);
+                                }
+                            }
+                        }
+                    }
+                }
+                analysis.classes.push(classInfo);
+                return null;
+            },
+            visitInterfaceDeclaration: (ctx) => {
+                const interfaceInfo = {
+                    name: ctx.identifier()?.text || "Unknown",
+                    type: "interface",
+                    modifiers: [],
+                    line: getLine(ctx),
+                    implements: [],
+                    annotations: [],
+                    methods: [],
+                    fields: [],
+                    innerClasses: [],
+                };
+                // Extends (interfaces extend other interfaces)
+                const typeList = ctx.typeList();
+                if (typeList && typeList.length > 0) {
+                    for (const tl of typeList) {
+                        const types = tl.typeType?.();
+                        if (types) {
+                            interfaceInfo.implements.push(...types.map((t) => t.text));
+                        }
+                    }
+                }
+                // Parse interface body
+                const interfaceBody = ctx.interfaceBody();
+                if (interfaceBody) {
+                    const bodyDecls = interfaceBody.interfaceBodyDeclaration();
+                    for (const bodyDecl of bodyDecls) {
+                        const memberDecl = bodyDecl.interfaceMemberDeclaration?.();
+                        if (!memberDecl)
+                            continue;
+                        const methodDecl = memberDecl.interfaceMethodDeclaration?.();
+                        if (methodDecl) {
+                            const commonBody = methodDecl.interfaceCommonBodyDeclaration?.();
+                            if (commonBody) {
+                                const methodInfo = {
+                                    name: commonBody.identifier()?.text || "unknown",
+                                    returnType: methodDecl.interfaceMethodModifier?.()?.map((m) => m.text).join(" ") || "void",
+                                    params: [],
+                                    modifiers: [],
+                                    line: getLine(methodDecl),
+                                    annotations: [],
+                                    throws: [],
+                                    complexity: 1,
+                                };
+                                interfaceInfo.methods.push(methodInfo);
+                            }
+                        }
+                    }
+                }
+                analysis.classes.push(interfaceInfo);
+                return null;
+            },
+            visitEnumDeclaration: (ctx) => {
+                const enumInfo = {
+                    name: ctx.identifier()?.text || "Unknown",
+                    type: "enum",
+                    modifiers: [],
+                    line: getLine(ctx),
+                    implements: [],
+                    annotations: [],
+                    methods: [],
+                    fields: [],
+                    innerClasses: [],
+                };
+                // Enum constants as fields
+                const enumConstants = ctx.enumConstants()?.enumConstant?.();
+                if (enumConstants) {
+                    for (const ec of enumConstants) {
+                        enumInfo.fields.push({
+                            name: ec.identifier()?.text || "",
+                            type: enumInfo.name,
+                            modifiers: ["public", "static", "final"],
+                            line: getLine(ec),
+                            annotations: [],
+                        });
+                    }
+                }
+                analysis.classes.push(enumInfo);
+                return null;
+            },
+        });
+        visitor.visit(tree);
+        // Calculate complexity stats
+        const allMethods = analysis.classes.flatMap((c) => c.methods);
+        if (allMethods.length > 0) {
+            analysis.complexity.total = allMethods.reduce((sum, m) => sum + m.complexity, 0);
+            analysis.complexity.average = Math.round(analysis.complexity.total / allMethods.length * 10) / 10;
+            analysis.complexity.highest = allMethods.reduce((max, m) => (m.complexity > max.value ? { name: m.name, value: m.complexity } : max), { name: "", value: 0 });
+        }
+    }
+    catch (error) {
+        // If parsing fails, try basic regex extraction
+        const classMatch = content.match(/(?:public\s+)?(?:abstract\s+)?(?:class|interface|enum)\s+(\w+)/);
+        if (classMatch) {
+            analysis.classes.push({
+                name: classMatch[1],
+                type: content.includes("interface ") ? "interface" : content.includes("enum ") ? "enum" : "class",
+                modifiers: [],
+                line: 1,
+                implements: [],
+                annotations: [],
+                methods: [],
+                fields: [],
+                innerClasses: [],
+            });
+        }
+    }
+    return analysis;
+}
+// Format analysis as text
+function formatJavaAnalysis(analysis) {
+    const lines = [];
+    lines.push(`=== ${path.basename(analysis.filepath)} ===`);
+    lines.push("");
+    if (analysis.package) {
+        lines.push(`📦 Package: ${analysis.package}`);
+        lines.push("");
+    }
+    if (analysis.imports.length > 0) {
+        lines.push("📥 Imports:");
+        // Group by prefix
+        const grouped = {};
+        for (const imp of analysis.imports) {
+            const prefix = imp.split(".").slice(0, 2).join(".");
+            if (!grouped[prefix])
+                grouped[prefix] = [];
+            grouped[prefix].push(imp);
+        }
+        for (const [prefix, imps] of Object.entries(grouped)) {
+            lines.push(`   ${prefix}.*  (${imps.length})`);
+        }
+        lines.push("");
+    }
+    for (const cls of analysis.classes) {
+        const icon = cls.type === "interface" ? "📋" : cls.type === "enum" ? "🔢" : "🏛️";
+        const mods = cls.modifiers.length > 0 ? cls.modifiers.join(" ") + " " : "";
+        const ext = cls.extends ? ` extends ${cls.extends}` : "";
+        const impl = cls.implements.length > 0 ? ` implements ${cls.implements.join(", ")}` : "";
+        const annots = cls.annotations.length > 0 ? cls.annotations.map((a) => `@${a}`).join(" ") + " " : "";
+        lines.push(`${icon} L${cls.line}: ${annots}${mods}${cls.type} ${cls.name}${ext}${impl}`);
+        // Fields
+        if (cls.fields.length > 0) {
+            lines.push("   필드:");
+            for (const field of cls.fields) {
+                const fMods = field.modifiers.join(" ");
+                const fAnnots = field.annotations.length > 0 ? field.annotations.map((a) => `@${a}`).join(" ") + " " : "";
+                lines.push(`      ${fAnnots}${fMods} ${field.type} ${field.name}`);
+            }
+        }
+        // Methods
+        if (cls.methods.length > 0) {
+            lines.push("   메서드:");
+            for (const method of cls.methods) {
+                const mMods = method.modifiers.join(" ");
+                const mAnnots = method.annotations.length > 0 ? method.annotations.map((a) => `@${a}`).join(" ") + " " : "";
+                const params = method.params.map((p) => `${p.type} ${p.name}`).join(", ");
+                const throws = method.throws.length > 0 ? ` throws ${method.throws.join(", ")}` : "";
+                lines.push(`      L${method.line}: ${mAnnots}${mMods} ${method.returnType} ${method.name}(${params})${throws}`);
+                lines.push(`              복잡도: ${method.complexity}`);
+            }
+        }
+        lines.push("");
+    }
+    lines.push("📊 복잡도:");
+    lines.push(`   총합: ${analysis.complexity.total} | 평균: ${analysis.complexity.average}`);
+    if (analysis.complexity.highest.name) {
+        lines.push(`   최고: ${analysis.complexity.highest.name} (${analysis.complexity.highest.value})`);
+    }
+    return lines.join("\n");
+}
+// Java Analyze Tool
+export const javaAnalyzeTool = {
+    name: "java_analyze",
+    description: "Analyze Java source file using AST parser (Java 분석). Returns classes, methods, fields, annotations, complexity. Use when user asks: 'analyze java', 'java 분석', 'Spring 분석'.",
+    parameters: {
+        type: "object",
+        required: ["filepath"],
+        properties: {
+            filepath: {
+                type: "string",
+                description: "Path to Java file (.java)",
+            },
+            format: {
+                type: "string",
+                description: "Output format: 'text' or 'json'",
+                enum: ["text", "json"],
+            },
+        },
+    },
+    handler: async (args) => {
+        try {
+            const filepath = path.resolve(args.filepath);
+            const format = args.format || "text";
+            if (!fs.existsSync(filepath)) {
+                return { success: false, content: "", error: `File not found: ${filepath}` };
+            }
+            if (!filepath.endsWith(".java")) {
+                return { success: false, content: "", error: "Not a Java file (.java required)" };
+            }
+            const content = fs.readFileSync(filepath, "utf-8");
+            const analysis = analyzeJavaFile(content, filepath);
+            if (format === "json") {
+                return { success: true, content: JSON.stringify(analysis, null, 2) };
+            }
+            return { success: true, content: formatJavaAnalysis(analysis) };
+        }
+        catch (error) {
+            return { success: false, content: "", error: String(error) };
+        }
+    },
+};
+// Java Complexity Report Tool
+export const javaComplexityTool = {
+    name: "java_complexity",
+    description: "Calculate complexity for Java files (Java 복잡도 리포트). Use when user asks: 'java complexity', 'java 복잡도'.",
+    parameters: {
+        type: "object",
+        required: ["pattern"],
+        properties: {
+            pattern: {
+                type: "string",
+                description: "Glob pattern (e.g., src/**/*.java)",
+            },
+            threshold: {
+                type: "number",
+                description: "Only show methods with complexity >= threshold (default: 5)",
+            },
+        },
+    },
+    handler: async (args) => {
+        try {
+            const { glob } = await import("glob");
+            const pattern = args.pattern;
+            const threshold = args.threshold || 5;
+            const files = await glob(pattern, {
+                ignore: ["**/node_modules/**", "**/target/**", "**/build/**"],
+            });
+            const allMethods = [];
+            for (const file of files) {
+                if (!file.endsWith(".java"))
+                    continue;
+                try {
+                    const content = fs.readFileSync(file, "utf-8");
+                    const analysis = analyzeJavaFile(content, file);
+                    for (const cls of analysis.classes) {
+                        for (const method of cls.methods) {
+                            allMethods.push({
+                                file: path.relative(process.cwd(), file),
+                                class: cls.name,
+                                method: method.name,
+                                complexity: method.complexity,
+                                line: method.line,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Skip unparseable files
+                }
+            }
+            // Sort by complexity
+            allMethods.sort((a, b) => b.complexity - a.complexity);
+            const high = allMethods.filter((m) => m.complexity >= threshold);
+            const total = allMethods.reduce((sum, m) => sum + m.complexity, 0);
+            const avg = allMethods.length > 0 ? Math.round(total / allMethods.length * 10) / 10 : 0;
+            const lines = [];
+            lines.push("=== Java 복잡도 리포트 ===");
+            lines.push("");
+            lines.push("📊 통계:");
+            lines.push(`   총 메서드: ${allMethods.length}개`);
+            lines.push(`   평균 복잡도: ${avg}`);
+            lines.push(`   높은 복잡도 (>= ${threshold}): ${high.length}개`);
+            lines.push("");
+            if (high.length > 0) {
+                lines.push(`⚠️ 복잡도 높은 메서드 (>= ${threshold}):`);
+                for (const m of high.slice(0, 20)) {
+                    const bar = "█".repeat(Math.min(m.complexity, 20));
+                    lines.push(`   ${m.complexity.toString().padStart(2)} ${bar} ${m.class}.${m.method}()`);
+                    lines.push(`      ${m.file}:${m.line}`);
+                }
+                if (high.length > 20) {
+                    lines.push(`   ... 외 ${high.length - 20}개`);
+                }
+            }
+            else {
+                lines.push(`✅ 복잡도 ${threshold} 이상인 메서드가 없습니다.`);
+            }
+            return { success: true, content: lines.join("\n") };
+        }
+        catch (error) {
+            return { success: false, content: "", error: String(error) };
+        }
+    },
+};
+// Spring Pattern Check Tool
+export const springCheckTool = {
+    name: "spring_check",
+    description: "Check Spring framework patterns (Spring 패턴 검사). Finds controllers, services, repositories, configuration. Use when user asks: 'spring check', 'spring 분석', 'Spring 패턴'.",
+    parameters: {
+        type: "object",
+        required: ["pattern"],
+        properties: {
+            pattern: {
+                type: "string",
+                description: "Glob pattern (e.g., src/**/*.java)",
+            },
+        },
+    },
+    handler: async (args) => {
+        try {
+            const { glob } = await import("glob");
+            const pattern = args.pattern;
+            const files = await glob(pattern, {
+                ignore: ["**/node_modules/**", "**/target/**", "**/build/**"],
+            });
+            const springComponents = {
+                controllers: [],
+                services: [],
+                repositories: [],
+                components: [],
+                configurations: [],
+                entities: [],
+            };
+            for (const file of files) {
+                if (!file.endsWith(".java"))
+                    continue;
+                try {
+                    const content = fs.readFileSync(file, "utf-8");
+                    const analysis = analyzeJavaFile(content, file);
+                    const relativePath = path.relative(process.cwd(), file);
+                    for (const cls of analysis.classes) {
+                        const annotations = cls.annotations.map((a) => a.toLowerCase());
+                        // Controller
+                        if (annotations.some((a) => a.includes("controller") || a.includes("restcontroller"))) {
+                            const mappings = [];
+                            // Find request mappings in methods
+                            for (const method of cls.methods) {
+                                const methodAnnots = method.annotations.join(" ").toLowerCase();
+                                if (methodAnnots.includes("mapping")) {
+                                    mappings.push(`${method.name}()`);
+                                }
+                            }
+                            springComponents.controllers.push({ file: relativePath, class: cls.name, mappings });
+                        }
+                        // Service
+                        if (annotations.some((a) => a.includes("service"))) {
+                            springComponents.services.push({ file: relativePath, class: cls.name });
+                        }
+                        // Repository
+                        if (annotations.some((a) => a.includes("repository"))) {
+                            springComponents.repositories.push({ file: relativePath, class: cls.name });
+                        }
+                        // Component
+                        if (annotations.some((a) => a === "component")) {
+                            springComponents.components.push({ file: relativePath, class: cls.name });
+                        }
+                        // Configuration
+                        if (annotations.some((a) => a.includes("configuration"))) {
+                            springComponents.configurations.push({ file: relativePath, class: cls.name });
+                        }
+                        // Entity
+                        if (annotations.some((a) => a.includes("entity") || a.includes("table"))) {
+                            springComponents.entities.push({ file: relativePath, class: cls.name });
+                        }
+                    }
+                }
+                catch {
+                    // Skip unparseable files
+                }
+            }
+            const lines = [];
+            lines.push("=== Spring 패턴 분석 ===");
+            lines.push("");
+            if (springComponents.controllers.length > 0) {
+                lines.push(`🎮 Controllers (${springComponents.controllers.length}):`);
+                for (const c of springComponents.controllers) {
+                    lines.push(`   ${c.class}`);
+                    lines.push(`      ${c.file}`);
+                    if (c.mappings.length > 0) {
+                        lines.push(`      엔드포인트: ${c.mappings.join(", ")}`);
+                    }
+                }
+                lines.push("");
+            }
+            if (springComponents.services.length > 0) {
+                lines.push(`⚙️ Services (${springComponents.services.length}):`);
+                for (const s of springComponents.services) {
+                    lines.push(`   ${s.class} - ${s.file}`);
+                }
+                lines.push("");
+            }
+            if (springComponents.repositories.length > 0) {
+                lines.push(`🗄️ Repositories (${springComponents.repositories.length}):`);
+                for (const r of springComponents.repositories) {
+                    lines.push(`   ${r.class} - ${r.file}`);
+                }
+                lines.push("");
+            }
+            if (springComponents.entities.length > 0) {
+                lines.push(`📋 Entities (${springComponents.entities.length}):`);
+                for (const e of springComponents.entities) {
+                    lines.push(`   ${e.class} - ${e.file}`);
+                }
+                lines.push("");
+            }
+            if (springComponents.configurations.length > 0) {
+                lines.push(`🔧 Configurations (${springComponents.configurations.length}):`);
+                for (const c of springComponents.configurations) {
+                    lines.push(`   ${c.class} - ${c.file}`);
+                }
+                lines.push("");
+            }
+            if (springComponents.components.length > 0) {
+                lines.push(`📦 Components (${springComponents.components.length}):`);
+                for (const c of springComponents.components) {
+                    lines.push(`   ${c.class} - ${c.file}`);
+                }
+                lines.push("");
+            }
+            const total = Object.values(springComponents).reduce((sum, arr) => sum + arr.length, 0);
+            if (total === 0) {
+                lines.push("Spring 컴포넌트를 찾지 못했습니다.");
+            }
+            else {
+                lines.push(`📊 총 ${total}개 Spring 컴포넌트 발견`);
+            }
+            return { success: true, content: lines.join("\n") };
+        }
+        catch (error) {
+            return { success: false, content: "", error: String(error) };
+        }
+    },
+};
+// Export all Java tools
+export const javaTools = [
+    javaAnalyzeTool,
+    javaComplexityTool,
+    springCheckTool,
+];
+//# sourceMappingURL=javaAst.js.map