@g1cloud/api-gen 1.0.0

package/src/parser/javaParser.ts

@@ -0,0 +1,901 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { parse, BaseJavaCstVisitorWithDefaults } from 'java-parser';
+import { JavaClass, JavaMethod, JavaField, JavaParameter, JavaAnnotation, JavadocInfo } from '../types';
+
+interface CstNode {
+  name: string;
+  children: Record<string, CstNode[]>;
+  image?: string;
+  location?: {
+    startLine: number;
+    startColumn: number;
+  };
+}
+
+interface ParsedJavadoc {
+  description: string;
+  info: JavadocInfo;
+}
+
+/**
+ * Extract Javadoc comments from source code
+ */
+function extractJavadocs(content: string): Map<number, ParsedJavadoc> {
+  const javadocs = new Map<number, ParsedJavadoc>();
+  const javadocRegex = /\/\*\*[\s\S]*?\*\//g;
+  let match;
+
+  while ((match = javadocRegex.exec(content)) !== null) {
+    const javadocText = match[0];
+    // Count newlines to find the end line of the javadoc
+    const beforeMatch = content.substring(0, match.index + javadocText.length);
+    const endLine = beforeMatch.split('\n').length;
+
+    // Parse the javadoc content
+    const parsedJavadoc = parseJavadocContent(javadocText);
+    if (parsedJavadoc.description || parsedJavadoc.info.returns || Object.keys(parsedJavadoc.info.params).length > 0) {
+      javadocs.set(endLine, parsedJavadoc);
+    }
+  }
+
+  return javadocs;
+}
+
+/**
+ * Parse Javadoc content and extract the description, @param, and @return
+ */
+function parseJavadocContent(javadoc: string): ParsedJavadoc {
+  // Remove /** and */
+  let content = javadoc.replace(/^\/\*\*/, '').replace(/\*\/$/, '');
+
+  // Split into lines and process each line
+  const lines = content.split('\n').map((line) => {
+    // Remove leading whitespace and asterisks
+    return line.replace(/^\s*\*?\s?/, '');
+  });
+
+  const descriptionLines: string[] = [];
+  const params: Record<string, string> = {};
+  let returns: string | undefined;
+
+  let currentTag: string | null = null;
+  let currentParamName: string | null = null;
+  let currentTagContent: string[] = [];
+
+  const flushCurrentTag = () => {
+    if (currentTag === 'param' && currentParamName) {
+      params[currentParamName] = currentTagContent.join(' ').trim();
+    } else if (currentTag === 'return' || currentTag === 'returns') {
+      returns = currentTagContent.join(' ').trim();
+    }
+    currentTag = null;
+    currentParamName = null;
+    currentTagContent = [];
+  };
+
+  for (const line of lines) {
+    if (line.startsWith('@param ')) {
+      flushCurrentTag();
+      currentTag = 'param';
+      // Extract param name and description
+      const paramMatch = line.match(/^@param\s+(\w+)\s*(.*)/);
+      if (paramMatch) {
+        currentParamName = paramMatch[1];
+        if (paramMatch[2]) {
+          currentTagContent.push(paramMatch[2]);
+        }
+      }
+    } else if (line.startsWith('@return ') || line.startsWith('@returns ')) {
+      flushCurrentTag();
+      currentTag = 'return';
+      const returnMatch = line.match(/^@returns?\s+(.*)/);
+      if (returnMatch && returnMatch[1]) {
+        currentTagContent.push(returnMatch[1]);
+      }
+    } else if (line.startsWith('@')) {
+      // Other tags like @throws, @see, etc. - flush current and ignore
+      flushCurrentTag();
+    } else if (currentTag) {
+      // Continuation of current tag
+      currentTagContent.push(line);
+    } else {
+      // Description line
+      descriptionLines.push(line);
+    }
+  }
+
+  // Flush any remaining tag
+  flushCurrentTag();
+
+  return {
+    description: descriptionLines.join('\n').trim(),
+    info: {
+      description: descriptionLines.join('\n').trim() || undefined,
+      params,
+      returns,
+    },
+  };
+}
+
+export class JavaFileParser {
+  private sourceDir: string;
+
+  constructor(sourceDir: string) {
+    this.sourceDir = sourceDir;
+  }
+
+  async parseAllJavaFiles(): Promise<Map<string, JavaClass>> {
+    const javaClasses = new Map<string, JavaClass>();
+    const javaFiles = this.findJavaFiles(this.sourceDir);
+
+    for (const filePath of javaFiles) {
+      try {
+        const classes = await this.parseJavaFile(filePath);
+        for (const javaClass of classes) {
+          javaClasses.set(javaClass.name, javaClass);
+        }
+      } catch (error) {
+        console.error(`Error parsing ${filePath}:`, error instanceof Error ? error.message : error);
+      }
+    }
+
+    return javaClasses;
+  }
+
+  private findJavaFiles(dir: string): string[] {
+    const files: string[] = [];
+
+    if (!fs.existsSync(dir)) {
+      return files;
+    }
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...this.findJavaFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith('.java')) {
+        files.push(fullPath);
+      }
+    }
+
+    return files;
+  }
+
+  async parseJavaFile(filePath: string): Promise<JavaClass[]> {
+    const content = fs.readFileSync(filePath, 'utf-8');
+
+    try {
+      const cst = parse(content);
+      const javadocs = extractJavadocs(content);
+      const extractor = new JavaClassExtractor(filePath, content, javadocs);
+      extractor.visit(cst);
+      return extractor.getAllClasses();
+    } catch (error) {
+      console.error(`Failed to parse ${filePath}:`, error instanceof Error ? error.message : error);
+      return [];
+    }
+  }
+}
+
+// Represents the context while parsing a class (supports nested classes)
+interface ClassContext {
+  className: string;
+  superClassName?: string;
+  classAnnotations: JavaAnnotation[];
+  classJavadoc?: string;
+  methods: JavaMethod[];
+  fields: JavaField[];
+  isEnum: boolean;
+  enumValues: string[];
+}
+
+class JavaClassExtractor extends BaseJavaCstVisitorWithDefaults {
+  private filePath: string;
+  private sourceContent: string;
+  private javadocs: Map<number, ParsedJavadoc>;
+  private _packageName: string = '';
+  private currentAnnotations: JavaAnnotation[] = [];
+
+  // Stack for handling nested classes
+  private classStack: ClassContext[] = [];
+  private allClasses: JavaClass[] = [];
+
+  constructor(filePath: string, sourceContent: string, javadocs: Map<number, ParsedJavadoc>) {
+    super();
+    this.filePath = filePath;
+    this.sourceContent = sourceContent;
+    this.javadocs = javadocs;
+    this.validateVisitor();
+  }
+
+  private get currentClass(): ClassContext | undefined {
+    return this.classStack[this.classStack.length - 1];
+  }
+
+  getJavaClass(): JavaClass | null {
+    // Return the first (top-level) class for backward compatibility
+    return this.allClasses.length > 0 ? this.allClasses[0] : null;
+  }
+
+  getAllClasses(): JavaClass[] {
+    return this.allClasses;
+  }
+
+  private finalizeClass(ctx: ClassContext): void {
+    this.allClasses.push({
+      name: ctx.className,
+      packageName: this._packageName,
+      annotations: ctx.classAnnotations,
+      methods: ctx.methods,
+      fields: ctx.fields,
+      filePath: this.filePath,
+      javadoc: ctx.classJavadoc,
+      superClass: ctx.superClassName,
+      isEnum: ctx.isEnum,
+      enumValues: ctx.isEnum ? ctx.enumValues : undefined,
+    });
+  }
+
+  packageDeclaration(ctx: any): void {
+    if (ctx.Identifier) {
+      this._packageName = ctx.Identifier.map((id: any) => id.image).join('.');
+    }
+  }
+
+  normalClassDeclaration(ctx: any): void {
+    // Create a new class context
+    const classContext: ClassContext = {
+      className: '',
+      classAnnotations: [...this.currentAnnotations],
+      methods: [],
+      fields: [],
+      isEnum: false,
+      enumValues: [],
+    };
+    this.currentAnnotations = [];
+
+    // Extract class name
+    if (ctx.typeIdentifier?.[0]?.children?.Identifier?.[0]) {
+      classContext.className = ctx.typeIdentifier[0].children.Identifier[0].image;
+
+      // Find javadoc for this class
+      const classToken = ctx.typeIdentifier[0].children.Identifier[0];
+      if (classToken.startLine) {
+        const parsedJavadoc = this.findJavadocForLine(classToken.startLine);
+        classContext.classJavadoc = parsedJavadoc?.description;
+      }
+    }
+
+    // Extract superclass name from classExtends
+    if (ctx.classExtends?.[0]) {
+      const classExtendsChildren = ctx.classExtends[0].children || ctx.classExtends[0];
+      if (classExtendsChildren.classType?.[0]) {
+        const classTypeChildren = classExtendsChildren.classType[0].children || classExtendsChildren.classType[0];
+        if (classTypeChildren.Identifier) {
+          // Join all identifiers for fully qualified names
+          classContext.superClassName = classTypeChildren.Identifier.map((id: any) => id.image).join('.');
+        }
+      }
+    }
+
+    // Push to stack and visit class body
+    this.classStack.push(classContext);
+
+    if (ctx.classBody) {
+      this.visit(ctx.classBody);
+    }
+
+    // Pop from stack and finalize the class
+    const completed = this.classStack.pop();
+    if (completed && completed.className) {
+      this.finalizeClass(completed);
+    }
+  }
+
+  enumDeclaration(ctx: any): void {
+    // Create a new enum context
+    const enumContext: ClassContext = {
+      className: '',
+      classAnnotations: [...this.currentAnnotations],
+      methods: [],
+      fields: [],
+      isEnum: true,
+      enumValues: [],
+    };
+    this.currentAnnotations = [];
+
+    // Get enum name
+    if (ctx.typeIdentifier?.[0]?.children?.Identifier?.[0]) {
+      enumContext.className = ctx.typeIdentifier[0].children.Identifier[0].image;
+
+      // Find javadoc for this enum
+      const enumToken = ctx.typeIdentifier[0].children.Identifier[0];
+      if (enumToken.startLine) {
+        const parsedJavadoc = this.findJavadocForLine(enumToken.startLine);
+        enumContext.classJavadoc = parsedJavadoc?.description;
+      }
+    }
+
+    // Extract enum constants
+    if (ctx.enumBody?.[0]) {
+      const enumBodyChildren = ctx.enumBody[0].children || ctx.enumBody[0];
+      if (enumBodyChildren.enumConstantList?.[0]) {
+        const constantListChildren = enumBodyChildren.enumConstantList[0].children || enumBodyChildren.enumConstantList[0];
+        if (constantListChildren.enumConstant) {
+          for (const enumConstant of constantListChildren.enumConstant) {
+            const constantChildren = enumConstant.children || enumConstant;
+            if (constantChildren.Identifier?.[0]) {
+              enumContext.enumValues.push(constantChildren.Identifier[0].image);
+            }
+          }
+        }
+      }
+    }
+
+    // Finalize the enum (enums don't have a body to visit for nested classes)
+    if (enumContext.className) {
+      this.finalizeClass(enumContext);
+    }
+  }
+
+  /**
+   * Find javadoc that ends near the given line (within a few lines before)
+   */
+  private findJavadocForLine(targetLine: number): ParsedJavadoc | undefined {
+    // Look for javadoc that ends 1-10 lines before the target line
+    // (allowing for annotations between javadoc and declaration)
+    for (let offset = 1; offset <= 10; offset++) {
+      const javadoc = this.javadocs.get(targetLine - offset);
+      if (javadoc) {
+        return javadoc;
+      }
+    }
+    return undefined;
+  }
+
+  classModifier(ctx: any): void {
+    if (ctx.annotation) {
+      for (const annotationCtx of ctx.annotation) {
+        const annotation = this.extractAnnotation(annotationCtx);
+        if (annotation) {
+          this.currentAnnotations.push(annotation);
+        }
+      }
+    }
+  }
+
+  methodDeclaration(ctx: any): void {
+    // Extract annotations directly from methodModifier nodes
+    const methodAnnotations: JavaAnnotation[] = [];
+    let methodStartLine: number | undefined;
+
+    if (ctx.methodModifier) {
+      for (const modifierCtx of ctx.methodModifier) {
+        const modChildren = modifierCtx.children || modifierCtx;
+        if (modChildren.annotation) {
+          for (const annotationCtx of modChildren.annotation) {
+            const annotation = this.extractAnnotation(annotationCtx);
+            if (annotation) {
+              methodAnnotations.push(annotation);
+            }
+            // Track the earliest line of the method declaration
+            const annChildren = annotationCtx.children || annotationCtx;
+            if (annChildren.At?.[0]?.startLine && (!methodStartLine || annChildren.At[0].startLine < methodStartLine)) {
+              methodStartLine = annChildren.At[0].startLine;
+            }
+          }
+        }
+      }
+    }
+
+    const methodHeader = ctx.methodHeader?.[0];
+    if (!methodHeader) return;
+
+    const methodName = this.extractMethodName(methodHeader);
+    const returnType = this.extractReturnType(methodHeader);
+    const parameters = this.extractParameters(methodHeader);
+
+    // Find javadoc for this method
+    let methodJavadoc: string | undefined;
+    let methodJavadocInfo: JavadocInfo | undefined;
+    if (methodStartLine) {
+      const parsedJavadoc = this.findJavadocForLine(methodStartLine);
+      methodJavadoc = parsedJavadoc?.description;
+      methodJavadocInfo = parsedJavadoc?.info;
+    }
+
+    if (methodName && this.currentClass) {
+      this.currentClass.methods.push({
+        name: methodName,
+        returnType: returnType.type,
+        returnGenericType: returnType.genericType,
+        parameters,
+        annotations: methodAnnotations,
+        javadoc: methodJavadoc,
+        javadocInfo: methodJavadocInfo,
+      });
+    }
+  }
+
+  fieldDeclaration(ctx: any): void {
+    // Extract annotations and check for static modifier from fieldModifier nodes
+    const fieldAnnotations: JavaAnnotation[] = [];
+    let isStatic = false;
+    let fieldStartLine: number | undefined;
+
+    if (ctx.fieldModifier) {
+      for (const modifier of ctx.fieldModifier) {
+        const modChildren = modifier.children || modifier;
+
+        // Check for static modifier
+        if (modChildren.Static) {
+          isStatic = true;
+        }
+
+        // Extract annotations and track start line
+        if (modChildren.annotation) {
+          for (const annotationCtx of modChildren.annotation) {
+            const annotation = this.extractAnnotation(annotationCtx);
+            if (annotation) {
+              fieldAnnotations.push(annotation);
+            }
+            // Track the earliest line of the field declaration
+            const annChildren = annotationCtx.children || annotationCtx;
+            if (annChildren.At?.[0]?.startLine && (!fieldStartLine || annChildren.At[0].startLine < fieldStartLine)) {
+              fieldStartLine = annChildren.At[0].startLine;
+            }
+          }
+        }
+      }
+    }
+
+    // Skip static fields
+    if (isStatic) return;
+
+    const unannType = ctx.unannType?.[0];
+    const variableDeclaratorList = ctx.variableDeclaratorList?.[0];
+
+    if (!unannType || !variableDeclaratorList) return;
+
+    // If no annotation found, try to get start line from type
+    if (!fieldStartLine && unannType) {
+      fieldStartLine = this.getStartLineFromNode(unannType);
+    }
+
+    const typeInfo = this.extractType(unannType);
+    const fieldNames = this.extractFieldNames(variableDeclaratorList);
+
+    // Find javadoc for this field
+    let fieldJavadoc: string | undefined;
+    if (fieldStartLine) {
+      const parsedJavadoc = this.findJavadocForLine(fieldStartLine);
+      fieldJavadoc = parsedJavadoc?.description;
+    }
+
+    if (this.currentClass) {
+      for (const fieldName of fieldNames) {
+        this.currentClass.fields.push({
+          name: fieldName,
+          type: typeInfo.type,
+          genericType: typeInfo.genericType,
+          annotations: fieldAnnotations,
+          accessModifier: 'private', // Default, could be extracted from modifiers
+          javadoc: fieldJavadoc,
+        });
+      }
+    }
+  }
+
+  /**
+   * Get the start line from a CST node by recursively searching for tokens
+   */
+  private getStartLineFromNode(node: any): number | undefined {
+    if (!node) return undefined;
+
+    const children = node.children || node;
+
+    // Check if this is a token with startLine
+    if (children.startLine) {
+      return children.startLine;
+    }
+
+    // Recursively search children
+    for (const key of Object.keys(children)) {
+      const child = children[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item?.startLine) {
+            return item.startLine;
+          }
+          const result = this.getStartLineFromNode(item);
+          if (result) return result;
+        }
+      } else if (child?.startLine) {
+        return child.startLine;
+      }
+    }
+
+    return undefined;
+  }
+
+  private extractAnnotation(ctx: any): JavaAnnotation | null {
+    const children = ctx.children || ctx;
+
+    // Get annotation name
+    let name = '';
+    if (children.typeName?.[0]) {
+      name = this.extractTypeName(children.typeName[0]);
+    } else if (children.Identifier) {
+      name = children.Identifier.map((id: any) => id.image).join('.');
+    }
+
+    if (!name) return null;
+
+    // Remove @ prefix if present
+    name = name.replace(/^@/, '');
+
+    // Extract annotation values
+    const values: Record<string, string | string[] | boolean> = {};
+
+    if (children.elementValuePairList?.[0]) {
+      this.extractElementValuePairs(children.elementValuePairList[0], values);
+    } else if (children.elementValue?.[0]) {
+      // Single value annotation like @GetMapping("/path")
+      values['value'] = this.extractElementValue(children.elementValue[0]);
+    }
+
+    return { name, values };
+  }
+
+  private extractElementValuePairs(ctx: any, values: Record<string, string | string[] | boolean>): void {
+    const children = ctx.children || ctx;
+    const pairs = children.elementValuePair || [];
+
+    for (const pair of pairs) {
+      const pairChildren = pair.children || pair;
+      const key = pairChildren.Identifier?.[0]?.image || 'value';
+      const value = this.extractElementValue(pairChildren.elementValue?.[0]);
+      values[key] = value;
+    }
+  }
+
+  private extractElementValue(ctx: any): string | string[] {
+    if (!ctx) return '';
+
+    const children = ctx.children || ctx;
+
+    // Array initializer
+    if (children.elementValueArrayInitializer?.[0]) {
+      const arrayInit = children.elementValueArrayInitializer[0];
+      const arrayChildren = arrayInit.children || arrayInit;
+      const elementValues = arrayChildren.elementValue || [];
+      return elementValues.map((ev: any) => this.extractElementValue(ev)).flat();
+    }
+
+    // Conditional expression (includes literals and identifiers)
+    if (children.conditionalExpression?.[0]) {
+      return this.extractExpressionValue(children.conditionalExpression[0]);
+    }
+
+    // Annotation
+    if (children.annotation?.[0]) {
+      return this.extractAnnotationAsString(children.annotation[0]);
+    }
+
+    return '';
+  }
+
+  private extractExpressionValue(ctx: any): string {
+    const children = ctx.children || ctx;
+
+    // Handle string literals
+    if (children.StringLiteral?.[0]) {
+      return children.StringLiteral[0].image.replace(/^"|"$/g, '');
+    }
+
+    // Handle boolean literals
+    if (children.True?.[0]) return 'true';
+    if (children.False?.[0]) return 'false';
+
+    // Handle numeric literals
+    if (children.IntegerLiteral?.[0]) return children.IntegerLiteral[0].image;
+    if (children.FloatingPointLiteral?.[0]) return children.FloatingPointLiteral[0].image;
+
+    // Handle identifiers (enum values, etc.)
+    if (children.Identifier?.[0]) return children.Identifier[0].image;
+
+    // Recursively search for values in nested structures
+    for (const key of Object.keys(children)) {
+      if (Array.isArray(children[key]) && children[key].length > 0) {
+        const result = this.extractExpressionValue(children[key][0]);
+        if (result) return result;
+      }
+    }
+
+    return '';
+  }
+
+  private extractAnnotationAsString(ctx: any): string {
+    const children = ctx.children || ctx;
+    let name = '';
+    if (children.typeName?.[0]) {
+      name = this.extractTypeName(children.typeName[0]);
+    }
+    return `@${name}`;
+  }
+
+  private extractTypeName(ctx: any): string {
+    const children = ctx.children || ctx;
+    if (children.Identifier) {
+      return children.Identifier.map((id: any) => id.image).join('.');
+    }
+    return '';
+  }
+
+  private extractMethodName(methodHeader: any): string {
+    const children = methodHeader.children || methodHeader;
+    const declarator = children.methodDeclarator?.[0];
+    if (declarator) {
+      const declChildren = declarator.children || declarator;
+      return declChildren.Identifier?.[0]?.image || '';
+    }
+    return '';
+  }
+
+  private extractReturnType(methodHeader: any): { type: string; genericType?: string } {
+    const children = methodHeader.children || methodHeader;
+    const result = children.result?.[0];
+
+    if (!result) return { type: 'void' };
+
+    const resultChildren = result.children || result;
+
+    if (resultChildren.Void) {
+      return { type: 'void' };
+    }
+
+    if (resultChildren.unannType?.[0]) {
+      return this.extractType(resultChildren.unannType[0]);
+    }
+
+    return { type: 'Object' };
+  }
+
+  private extractType(typeCtx: any): { type: string; genericType?: string } {
+    const children = typeCtx.children || typeCtx;
+
+    // Handle primitive types with optional dims suffix (e.g., boolean, int, etc.)
+    if (children.unannPrimitiveTypeWithOptionalDimsSuffix?.[0]) {
+      const primitiveWithDims = children.unannPrimitiveTypeWithOptionalDimsSuffix[0].children || children.unannPrimitiveTypeWithOptionalDimsSuffix[0];
+      if (primitiveWithDims.unannPrimitiveType?.[0]) {
+        const primitiveChildren = primitiveWithDims.unannPrimitiveType[0].children || primitiveWithDims.unannPrimitiveType[0];
+        return this.extractPrimitiveType(primitiveChildren);
+      }
+    }
+
+    // Handle primitive types directly (fallback for older parser versions)
+    if (children.unannPrimitiveType?.[0]) {
+      const primitiveChildren = children.unannPrimitiveType[0].children || children.unannPrimitiveType[0];
+      return this.extractPrimitiveType(primitiveChildren);
+    }
+
+    // Handle reference types
+    if (children.unannReferenceType?.[0]) {
+      return this.extractReferenceType(children.unannReferenceType[0]);
+    }
+
+    return { type: 'Object' };
+  }
+
+  private extractPrimitiveType(primitiveChildren: any): { type: string; genericType?: string } {
+    if (primitiveChildren.numericType?.[0]) {
+      const numericChildren = primitiveChildren.numericType[0].children || primitiveChildren.numericType[0];
+      if (numericChildren.integralType?.[0]) {
+        const integralChildren = numericChildren.integralType[0].children || numericChildren.integralType[0];
+        for (const key of ['Int', 'Long', 'Short', 'Byte', 'Char']) {
+          if (integralChildren[key]) return { type: key.toLowerCase() };
+        }
+      }
+      if (numericChildren.floatingPointType?.[0]) {
+        const floatChildren = numericChildren.floatingPointType[0].children || numericChildren.floatingPointType[0];
+        if (floatChildren.Float) return { type: 'float' };
+        if (floatChildren.Double) return { type: 'double' };
+      }
+    }
+    if (primitiveChildren.Boolean) return { type: 'boolean' };
+    return { type: 'Object' };
+  }
+
+  private extractReferenceType(refTypeCtx: any): { type: string; genericType?: string } {
+    const children = refTypeCtx.children || refTypeCtx;
+
+    // Handle class or interface type
+    if (children.unannClassOrInterfaceType?.[0]) {
+      return this.extractClassOrInterfaceType(children.unannClassOrInterfaceType[0]);
+    }
+
+    // Handle array type
+    if (children.unannArrayType?.[0]) {
+      const arrayChildren = children.unannArrayType[0].children || children.unannArrayType[0];
+      if (arrayChildren.unannClassOrInterfaceType?.[0]) {
+        const innerType = this.extractClassOrInterfaceType(arrayChildren.unannClassOrInterfaceType[0]);
+        return { type: `${innerType.type}[]`, genericType: innerType.genericType };
+      }
+    }
+
+    return { type: 'Object' };
+  }
+
+  private extractClassOrInterfaceType(ctx: any): { type: string; genericType?: string } {
+    const children = ctx.children || ctx;
+    let type = '';
+    let genericType: string | undefined;
+
+    // Handle the class type
+    if (children.unannClassType?.[0]) {
+      const classTypeChildren = children.unannClassType[0].children || children.unannClassType[0];
+
+      // Get the class name from annotation chain or directly
+      if (classTypeChildren.Identifier) {
+        type = classTypeChildren.Identifier.map((id: any) => id.image).join('.');
+      }
+
+      // Check for generic type arguments
+      if (classTypeChildren.typeArguments?.[0]) {
+        genericType = this.extractTypeArguments(classTypeChildren.typeArguments[0]);
+      }
+    }
+
+    return { type: type || 'Object', genericType };
+  }
+
+  private extractTypeArguments(ctx: any): string {
+    const children = ctx.children || ctx;
+    const typeArgumentList = children.typeArgumentList?.[0];
+
+    if (!typeArgumentList) return '';
+
+    const typeArgChildren = typeArgumentList.children || typeArgumentList;
+    const typeArguments = typeArgChildren.typeArgument || [];
+
+    const types = typeArguments.map((arg: any) => {
+      const argChildren = arg.children || arg;
+      if (argChildren.referenceType?.[0]) {
+        const refType = this.extractReferenceTypeFromGeneric(argChildren.referenceType[0]);
+        return refType;
+      }
+      if (argChildren.wildcard?.[0]) {
+        return '?';
+      }
+      return 'Object';
+    });
+
+    return types.join(', ');
+  }
+
+  private extractReferenceTypeFromGeneric(refTypeCtx: any): string {
+    const children = refTypeCtx.children || refTypeCtx;
+
+    if (children.classOrInterfaceType?.[0]) {
+      const classTypeChildren = children.classOrInterfaceType[0].children || children.classOrInterfaceType[0];
+      if (classTypeChildren.classType?.[0]) {
+        const innerClassChildren = classTypeChildren.classType[0].children || classTypeChildren.classType[0];
+        if (innerClassChildren.Identifier) {
+          let typeName = innerClassChildren.Identifier.map((id: any) => id.image).join('.');
+
+          // Handle nested generic types
+          if (innerClassChildren.typeArguments?.[0]) {
+            const nestedGenerics = this.extractTypeArguments(innerClassChildren.typeArguments[0]);
+            if (nestedGenerics) {
+              typeName += `<${nestedGenerics}>`;
+            }
+          }
+
+          return typeName;
+        }
+      }
+    }
+
+    return 'Object';
+  }
+
+  private extractParameters(methodHeader: any): JavaParameter[] {
+    const children = methodHeader.children || methodHeader;
+    const declarator = children.methodDeclarator?.[0];
+    if (!declarator) return [];
+
+    const declChildren = declarator.children || declarator;
+    const formalParameterList = declChildren.formalParameterList?.[0];
+    if (!formalParameterList) return [];
+
+    const formalChildren = formalParameterList.children || formalParameterList;
+    const parameters: JavaParameter[] = [];
+
+    // Handle regular formal parameters
+    if (formalChildren.formalParameter) {
+      for (const param of formalChildren.formalParameter) {
+        const parameter = this.extractFormalParameter(param);
+        if (parameter) {
+          parameters.push(parameter);
+        }
+      }
+    }
+
+    return parameters;
+  }
+
+  private extractFormalParameter(paramCtx: any): JavaParameter | null {
+    let children = paramCtx.children || paramCtx;
+
+    // Handle variableParaRegularParameter wrapper
+    if (children.variableParaRegularParameter?.[0]) {
+      children = children.variableParaRegularParameter[0].children || children.variableParaRegularParameter[0];
+    }
+
+    // Extract annotations from variableModifier
+    const annotations: JavaAnnotation[] = [];
+    if (children.variableModifier) {
+      for (const modifier of children.variableModifier) {
+        const modChildren = modifier.children || modifier;
+        if (modChildren.annotation?.[0]) {
+          const annotation = this.extractAnnotation(modChildren.annotation[0]);
+          if (annotation) {
+            annotations.push(annotation);
+          }
+        }
+      }
+    }
+
+    // Extract type
+    let type = 'Object';
+    let genericType: string | undefined;
+    if (children.unannType?.[0]) {
+      const typeInfo = this.extractType(children.unannType[0]);
+      type = typeInfo.type;
+      genericType = typeInfo.genericType;
+    }
+
+    // Extract parameter name
+    let name = '';
+    if (children.variableDeclaratorId?.[0]) {
+      const varIdChildren = children.variableDeclaratorId[0].children || children.variableDeclaratorId[0];
+      name = varIdChildren.Identifier?.[0]?.image || '';
+    }
+
+    if (!name) return null;
+
+    return {
+      name,
+      type,
+      genericType,
+      annotations,
+    };
+  }
+
+  private extractFieldNames(variableDeclaratorList: any): string[] {
+    const children = variableDeclaratorList.children || variableDeclaratorList;
+    const declarators = children.variableDeclarator || [];
+    const names: string[] = [];
+
+    for (const declarator of declarators) {
+      const declChildren = declarator.children || declarator;
+      if (declChildren.variableDeclaratorId?.[0]) {
+        const varIdChildren = declChildren.variableDeclaratorId[0].children || declChildren.variableDeclaratorId[0];
+        const name = varIdChildren.Identifier?.[0]?.image;
+        if (name) {
+          names.push(name);
+        }
+      }
+    }
+
+    return names;
+  }
+}
+
+export function parseJavaSource(sourceDir: string): Promise<Map<string, JavaClass>> {
+  const parser = new JavaFileParser(sourceDir);
+  return parser.parseAllJavaFiles();
+}