activo 0.2.2 → 0.3.1

package/src/core/tools/javaAst.ts

@@ -0,0 +1,812 @@
+import fs from "fs";
+import path from "path";
+import { parse, createVisitor } from "java-ast";
+import { Tool, ToolResult } from "./types.js";
+
+// Java method info
+interface JavaMethodInfo {
+  name: string;
+  returnType: string;
+  params: Array<{ name: string; type: string }>;
+  modifiers: string[];
+  line: number;
+  annotations: string[];
+  throws: string[];
+  complexity: number;
+}
+
+// Java field info
+interface JavaFieldInfo {
+  name: string;
+  type: string;
+  modifiers: string[];
+  line: number;
+  annotations: string[];
+}
+
+// Java class info
+interface JavaClassInfo {
+  name: string;
+  type: "class" | "interface" | "enum" | "record";
+  modifiers: string[];
+  line: number;
+  extends?: string;
+  implements: string[];
+  annotations: string[];
+  methods: JavaMethodInfo[];
+  fields: JavaFieldInfo[];
+  innerClasses: JavaClassInfo[];
+}
+
+// Java file analysis result
+interface JavaFileAnalysis {
+  filepath: string;
+  package: string;
+  imports: string[];
+  classes: JavaClassInfo[];
+  complexity: {
+    total: number;
+    average: number;
+    highest: { name: string; value: number };
+  };
+}
+
+// Calculate cyclomatic complexity from method body text
+function calculateComplexity(methodText: string): number {
+  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: string, filepath: string): JavaFileAnalysis {
+  const analysis: JavaFileAnalysis = {
+    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: any): number => {
+      if (ctx && ctx.start) {
+        return ctx.start.line;
+      }
+      return 0;
+    };
+
+    // Get text from context
+    const getText = (ctx: any): string => {
+      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: any[]): string[] => {
+      if (!modifierCtxs) return [];
+      return modifierCtxs.map((m) => m.text).filter((m) => m);
+    };
+
+    // Get annotations
+    const getAnnotations = (modifierCtxs: any[]): string[] => {
+      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: JavaClassInfo = {
+          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 as any).classOrInterfaceModifier) {
+          const mods = (parent as any).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: JavaMethodInfo = {
+                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: JavaMethodInfo = {
+                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: JavaFieldInfo = {
+                    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: JavaClassInfo = {
+          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: any) => 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: JavaMethodInfo = {
+                  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: JavaClassInfo = {
+          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: JavaFileAnalysis): string {
+  const lines: string[] = [];
+
+  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: Record<string, string[]> = {};
+    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: Tool = {
+  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): Promise<ToolResult> => {
+    try {
+      const filepath = path.resolve(args.filepath as string);
+      const format = (args.format as string) || "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: Tool = {
+  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): Promise<ToolResult> => {
+    try {
+      const { glob } = await import("glob");
+      const pattern = args.pattern as string;
+      const threshold = (args.threshold as number) || 5;
+
+      const files = await glob(pattern, {
+        ignore: ["**/node_modules/**", "**/target/**", "**/build/**"],
+      });
+
+      const allMethods: Array<{
+        file: string;
+        class: string;
+        method: string;
+        complexity: number;
+        line: number;
+      }> = [];
+
+      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: string[] = [];
+      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: Tool = {
+  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): Promise<ToolResult> => {
+    try {
+      const { glob } = await import("glob");
+      const pattern = args.pattern as string;
+
+      const files = await glob(pattern, {
+        ignore: ["**/node_modules/**", "**/target/**", "**/build/**"],
+      });
+
+      const springComponents = {
+        controllers: [] as Array<{ file: string; class: string; mappings: string[] }>,
+        services: [] as Array<{ file: string; class: string }>,
+        repositories: [] as Array<{ file: string; class: string }>,
+        components: [] as Array<{ file: string; class: string }>,
+        configurations: [] as Array<{ file: string; class: string }>,
+        entities: [] as Array<{ file: string; class: string }>,
+      };
+
+      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: string[] = [];
+              // 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: string[] = [];
+      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: Tool[] = [
+  javaAnalyzeTool,
+  javaComplexityTool,
+  springCheckTool,
+];