@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.7

package/src/shared/parsers/typescript-parser.ts

@@ -1,841 +0,0 @@
-/**
- * Agentic QE v3 - TypeScript AST Parser
- * Wrapper around TypeScript Compiler API for code analysis
- */
-
-import * as ts from 'typescript';
-
-// ============================================================================
-// Type Definitions
-// ============================================================================
-
-/**
- * Information about a function parameter
- */
-export interface ParameterInfo {
-  name: string;
-  type: string | undefined;
-  isOptional: boolean;
-  isRest: boolean;
-  defaultValue: string | undefined;
-}
-
-/**
- * Information about a function (declaration or arrow function)
- */
-export interface FunctionInfo {
-  name: string;
-  parameters: ParameterInfo[];
-  returnType: string | undefined;
-  startLine: number;
-  endLine: number;
-  isAsync: boolean;
-  isExported: boolean;
-  isGenerator: boolean;
-  typeParameters: string[];
-}
-
-/**
- * Information about a class property
- */
-export interface PropertyInfo {
-  name: string;
-  type: string | undefined;
-  isStatic: boolean;
-  isReadonly: boolean;
-  visibility: 'public' | 'private' | 'protected';
-  hasInitializer: boolean;
-}
-
-/**
- * Information about a class method
- */
-export interface MethodInfo {
-  name: string;
-  parameters: ParameterInfo[];
-  returnType: string | undefined;
-  isAsync: boolean;
-  isStatic: boolean;
-  isAbstract: boolean;
-  visibility: 'public' | 'private' | 'protected';
-  startLine: number;
-  endLine: number;
-}
-
-/**
- * Information about a class
- */
-export interface ClassInfo {
-  name: string;
-  methods: MethodInfo[];
-  properties: PropertyInfo[];
-  extends: string | undefined;
-  implements: string[];
-  isAbstract: boolean;
-  isExported: boolean;
-  startLine: number;
-  endLine: number;
-  typeParameters: string[];
-}
-
-/**
- * Information about named imports
- */
-export interface NamedImportInfo {
-  name: string;
-  alias: string | undefined;
-}
-
-/**
- * Information about an import statement
- */
-export interface ImportInfo {
-  module: string;
-  namedImports: NamedImportInfo[];
-  defaultImport: string | undefined;
-  namespaceImport: string | undefined;
-  isTypeOnly: boolean;
-}
-
-/**
- * Information about an export
- */
-export interface ExportInfo {
-  name: string;
-  type: 'function' | 'class' | 'variable' | 'interface' | 'type' | 'enum' | 'namespace' | 'unknown';
-  isDefault: boolean;
-  isReexport: boolean;
-  sourceModule: string | undefined;
-}
-
-/**
- * Information about an interface property
- */
-export interface InterfacePropertyInfo {
-  name: string;
-  type: string | undefined;
-  isOptional: boolean;
-  isReadonly: boolean;
-}
-
-/**
- * Information about an interface method
- */
-export interface InterfaceMethodInfo {
-  name: string;
-  parameters: ParameterInfo[];
-  returnType: string | undefined;
-  isOptional: boolean;
-}
-
-/**
- * Information about an interface
- */
-export interface InterfaceInfo {
-  name: string;
-  properties: InterfacePropertyInfo[];
-  methods: InterfaceMethodInfo[];
-  extends: string[];
-  isExported: boolean;
-  startLine: number;
-  endLine: number;
-  typeParameters: string[];
-}
-
-/**
- * Visibility modifier type
- */
-export type Visibility = 'public' | 'private' | 'protected' | 'internal';
-
-/**
- * Entity type for parsed code elements
- */
-export type ParsedEntityType = 'function' | 'class' | 'interface' | 'type' | 'variable' | 'enum' | 'module';
-
-/**
- * Parsed entity representing a code element
- */
-export interface ParsedEntity {
-  name: string;
-  type: ParsedEntityType;
-  line: number;
-  endLine?: number;
-  visibility: Visibility;
-  isAsync: boolean;
-  isExported: boolean;
-  parameters?: ParameterInfo[];
-  returnType?: string;
-  extends?: string;
-  implements?: string[];
-}
-
-// ============================================================================
-// TypeScript Parser Implementation
-// ============================================================================
-
-/**
- * TypeScript AST Parser
- * Provides methods to parse TypeScript source code and extract structural information
- */
-export class TypeScriptParser {
-  /**
-   * Parse a TypeScript file and return the AST SourceFile
-   */
-  parseFile(filePath: string, content: string): ts.SourceFile {
-    return ts.createSourceFile(
-      filePath,
-      content,
-      ts.ScriptTarget.Latest,
-      true,
-      this.getScriptKind(filePath)
-    );
-  }
-
-  /**
-   * Extract all functions from the AST
-   */
-  extractFunctions(ast: ts.SourceFile): FunctionInfo[] {
-    const functions: FunctionInfo[] = [];
-
-    const visit = (node: ts.Node): void => {
-      if (ts.isFunctionDeclaration(node) && node.name) {
-        functions.push(this.extractFunctionDeclaration(node, ast));
-      } else if (ts.isVariableStatement(node)) {
-        this.extractArrowFunctions(node, ast, functions);
-      }
-
-      ts.forEachChild(node, visit);
-    };
-
-    ts.forEachChild(ast, visit);
-    return functions;
-  }
-
-  /**
-   * Extract all classes from the AST
-   */
-  extractClasses(ast: ts.SourceFile): ClassInfo[] {
-    const classes: ClassInfo[] = [];
-
-    const visit = (node: ts.Node): void => {
-      if (ts.isClassDeclaration(node) && node.name) {
-        classes.push(this.extractClassDeclaration(node, ast));
-      }
-
-      ts.forEachChild(node, visit);
-    };
-
-    ts.forEachChild(ast, visit);
-    return classes;
-  }
-
-  /**
-   * Extract all imports from the AST
-   */
-  extractImports(ast: ts.SourceFile): ImportInfo[] {
-    const imports: ImportInfo[] = [];
-
-    const visit = (node: ts.Node): void => {
-      if (ts.isImportDeclaration(node)) {
-        imports.push(this.extractImportDeclaration(node));
-      }
-
-      ts.forEachChild(node, visit);
-    };
-
-    ts.forEachChild(ast, visit);
-    return imports;
-  }
-
-  /**
-   * Extract all exports from the AST
-   */
-  extractExports(ast: ts.SourceFile): ExportInfo[] {
-    const exports: ExportInfo[] = [];
-
-    const visit = (node: ts.Node): void => {
-      // Export declarations (export { ... })
-      if (ts.isExportDeclaration(node)) {
-        this.extractExportDeclaration(node, exports);
-      }
-      // Export assignment (export default ...)
-      else if (ts.isExportAssignment(node)) {
-        exports.push({
-          name: this.getExportAssignmentName(node),
-          type: 'unknown',
-          isDefault: true,
-          isReexport: false,
-          sourceModule: undefined,
-        });
-      }
-      // Exported function declarations
-      else if (ts.isFunctionDeclaration(node) && node.name && this.hasExportModifier(node)) {
-        exports.push({
-          name: node.name.text,
-          type: 'function',
-          isDefault: this.hasDefaultModifier(node),
-          isReexport: false,
-          sourceModule: undefined,
-        });
-      }
-      // Exported class declarations
-      else if (ts.isClassDeclaration(node) && node.name && this.hasExportModifier(node)) {
-        exports.push({
-          name: node.name.text,
-          type: 'class',
-          isDefault: this.hasDefaultModifier(node),
-          isReexport: false,
-          sourceModule: undefined,
-        });
-      }
-      // Exported variable statements
-      else if (ts.isVariableStatement(node) && this.hasExportModifier(node)) {
-        for (const declaration of node.declarationList.declarations) {
-          if (ts.isIdentifier(declaration.name)) {
-            exports.push({
-              name: declaration.name.text,
-              type: 'variable',
-              isDefault: false,
-              isReexport: false,
-              sourceModule: undefined,
-            });
-          }
-        }
-      }
-      // Exported interface declarations
-      else if (ts.isInterfaceDeclaration(node) && this.hasExportModifier(node)) {
-        exports.push({
-          name: node.name.text,
-          type: 'interface',
-          isDefault: false,
-          isReexport: false,
-          sourceModule: undefined,
-        });
-      }
-      // Exported type aliases
-      else if (ts.isTypeAliasDeclaration(node) && this.hasExportModifier(node)) {
-        exports.push({
-          name: node.name.text,
-          type: 'type',
-          isDefault: false,
-          isReexport: false,
-          sourceModule: undefined,
-        });
-      }
-      // Exported enum declarations
-      else if (ts.isEnumDeclaration(node) && this.hasExportModifier(node)) {
-        exports.push({
-          name: node.name.text,
-          type: 'enum',
-          isDefault: false,
-          isReexport: false,
-          sourceModule: undefined,
-        });
-      }
-
-      ts.forEachChild(node, visit);
-    };
-
-    ts.forEachChild(ast, visit);
-    return exports;
-  }
-
-  /**
-   * Extract all interfaces from the AST
-   */
-  extractInterfaces(ast: ts.SourceFile): InterfaceInfo[] {
-    const interfaces: InterfaceInfo[] = [];
-
-    const visit = (node: ts.Node): void => {
-      if (ts.isInterfaceDeclaration(node)) {
-        interfaces.push(this.extractInterfaceDeclaration(node, ast));
-      }
-
-      ts.forEachChild(node, visit);
-    };
-
-    ts.forEachChild(ast, visit);
-    return interfaces;
-  }
-
-  /**
-   * Extract all entities (functions, classes, interfaces, etc.) from source code
-   * This is a convenience method that combines all extraction methods
-   */
-  extractEntities(content: string, filePath: string): ParsedEntity[] {
-    const ast = this.parseFile(filePath, content);
-    const entities: ParsedEntity[] = [];
-
-    // Extract functions
-    const functions = this.extractFunctions(ast);
-    for (const func of functions) {
-      entities.push({
-        name: func.name,
-        type: 'function',
-        line: func.startLine,
-        endLine: func.endLine,
-        visibility: func.isExported ? 'public' : 'internal',
-        isAsync: func.isAsync,
-        isExported: func.isExported,
-        parameters: func.parameters,
-        returnType: func.returnType,
-      });
-    }
-
-    // Extract classes
-    const classes = this.extractClasses(ast);
-    for (const cls of classes) {
-      entities.push({
-        name: cls.name,
-        type: 'class',
-        line: cls.startLine,
-        endLine: cls.endLine,
-        visibility: cls.isExported ? 'public' : 'internal',
-        isAsync: false,
-        isExported: cls.isExported,
-        extends: cls.extends,
-        implements: cls.implements,
-      });
-    }
-
-    // Extract interfaces
-    const interfaces = this.extractInterfaces(ast);
-    for (const iface of interfaces) {
-      entities.push({
-        name: iface.name,
-        type: 'interface',
-        line: iface.startLine,
-        endLine: iface.endLine,
-        visibility: iface.isExported ? 'public' : 'internal',
-        isAsync: false,
-        isExported: iface.isExported,
-      });
-    }
-
-    return entities;
-  }
-
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-
-  private getScriptKind(filePath: string): ts.ScriptKind {
-    if (filePath.endsWith('.tsx')) return ts.ScriptKind.TSX;
-    if (filePath.endsWith('.ts')) return ts.ScriptKind.TS;
-    if (filePath.endsWith('.jsx')) return ts.ScriptKind.JSX;
-    if (filePath.endsWith('.js')) return ts.ScriptKind.JS;
-    return ts.ScriptKind.TS;
-  }
-
-  private extractFunctionDeclaration(
-    node: ts.FunctionDeclaration,
-    sourceFile: ts.SourceFile
-  ): FunctionInfo {
-    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-
-    return {
-      name: node.name?.text ?? 'anonymous',
-      parameters: this.extractParameters(node.parameters),
-      returnType: node.type ? node.type.getText(sourceFile) : undefined,
-      startLine: startLine + 1,
-      endLine: endLine + 1,
-      isAsync: this.hasAsyncModifier(node),
-      isExported: this.hasExportModifier(node),
-      isGenerator: !!node.asteriskToken,
-      typeParameters: this.extractTypeParameters(node.typeParameters),
-    };
-  }
-
-  private extractArrowFunctions(
-    node: ts.VariableStatement,
-    sourceFile: ts.SourceFile,
-    functions: FunctionInfo[]
-  ): void {
-    for (const declaration of node.declarationList.declarations) {
-      if (
-        ts.isIdentifier(declaration.name) &&
-        declaration.initializer &&
-        ts.isArrowFunction(declaration.initializer)
-      ) {
-        const arrow = declaration.initializer;
-        const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-        const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-
-        functions.push({
-          name: declaration.name.text,
-          parameters: this.extractParameters(arrow.parameters),
-          returnType: arrow.type ? arrow.type.getText(sourceFile) : undefined,
-          startLine: startLine + 1,
-          endLine: endLine + 1,
-          isAsync: this.hasAsyncModifier(arrow),
-          isExported: this.hasExportModifier(node),
-          isGenerator: false,
-          typeParameters: this.extractTypeParameters(arrow.typeParameters),
-        });
-      }
-    }
-  }
-
-  private extractClassDeclaration(
-    node: ts.ClassDeclaration,
-    sourceFile: ts.SourceFile
-  ): ClassInfo {
-    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-
-    const methods: MethodInfo[] = [];
-    const properties: PropertyInfo[] = [];
-
-    for (const member of node.members) {
-      if (ts.isMethodDeclaration(member) && member.name) {
-        methods.push(this.extractMethodDeclaration(member, sourceFile));
-      } else if (ts.isPropertyDeclaration(member) && member.name) {
-        properties.push(this.extractPropertyDeclaration(member, sourceFile));
-      } else if (ts.isConstructorDeclaration(member)) {
-        // Extract constructor as a method
-        methods.push(this.extractConstructor(member, sourceFile));
-        // Also extract parameter properties
-        this.extractParameterProperties(member, properties, sourceFile);
-      }
-    }
-
-    let extendsClause: string | undefined;
-    const implementsClause: string[] = [];
-
-    if (node.heritageClauses) {
-      for (const clause of node.heritageClauses) {
-        if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
-          extendsClause = clause.types[0]?.expression.getText(sourceFile);
-        } else if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
-          for (const type of clause.types) {
-            implementsClause.push(type.expression.getText(sourceFile));
-          }
-        }
-      }
-    }
-
-    return {
-      name: node.name?.text ?? 'anonymous',
-      methods,
-      properties,
-      extends: extendsClause,
-      implements: implementsClause,
-      isAbstract: this.hasAbstractModifier(node),
-      isExported: this.hasExportModifier(node),
-      startLine: startLine + 1,
-      endLine: endLine + 1,
-      typeParameters: this.extractTypeParameters(node.typeParameters),
-    };
-  }
-
-  private extractMethodDeclaration(
-    node: ts.MethodDeclaration,
-    sourceFile: ts.SourceFile
-  ): MethodInfo {
-    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-
-    return {
-      name: this.getPropertyName(node.name, sourceFile),
-      parameters: this.extractParameters(node.parameters),
-      returnType: node.type ? node.type.getText(sourceFile) : undefined,
-      isAsync: this.hasAsyncModifier(node),
-      isStatic: this.hasStaticModifier(node),
-      isAbstract: this.hasAbstractModifier(node),
-      visibility: this.getVisibility(node),
-      startLine: startLine + 1,
-      endLine: endLine + 1,
-    };
-  }
-
-  private extractConstructor(
-    node: ts.ConstructorDeclaration,
-    sourceFile: ts.SourceFile
-  ): MethodInfo {
-    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-
-    return {
-      name: 'constructor',
-      parameters: this.extractParameters(node.parameters),
-      returnType: undefined,
-      isAsync: false,
-      isStatic: false,
-      isAbstract: false,
-      visibility: 'public',
-      startLine: startLine + 1,
-      endLine: endLine + 1,
-    };
-  }
-
-  private extractParameterProperties(
-    node: ts.ConstructorDeclaration,
-    properties: PropertyInfo[],
-    sourceFile: ts.SourceFile
-  ): void {
-    for (const param of node.parameters) {
-      if (this.isParameterProperty(param)) {
-        properties.push({
-          name: ts.isIdentifier(param.name) ? param.name.text : param.name.getText(sourceFile),
-          type: param.type ? param.type.getText(sourceFile) : undefined,
-          isStatic: false,
-          isReadonly: this.hasReadonlyModifier(param),
-          visibility: this.getVisibility(param),
-          hasInitializer: !!param.initializer,
-        });
-      }
-    }
-  }
-
-  private isParameterProperty(param: ts.ParameterDeclaration): boolean {
-    return !!(
-      param.modifiers?.some(
-        (m) =>
-          m.kind === ts.SyntaxKind.PublicKeyword ||
-          m.kind === ts.SyntaxKind.PrivateKeyword ||
-          m.kind === ts.SyntaxKind.ProtectedKeyword ||
-          m.kind === ts.SyntaxKind.ReadonlyKeyword
-      )
-    );
-  }
-
-  private extractPropertyDeclaration(
-    node: ts.PropertyDeclaration,
-    sourceFile: ts.SourceFile
-  ): PropertyInfo {
-    return {
-      name: this.getPropertyName(node.name, sourceFile),
-      type: node.type ? node.type.getText(sourceFile) : undefined,
-      isStatic: this.hasStaticModifier(node),
-      isReadonly: this.hasReadonlyModifier(node),
-      visibility: this.getVisibility(node),
-      hasInitializer: !!node.initializer,
-    };
-  }
-
-  private extractImportDeclaration(node: ts.ImportDeclaration): ImportInfo {
-    const module = (node.moduleSpecifier as ts.StringLiteral).text;
-    const namedImports: NamedImportInfo[] = [];
-    let defaultImport: string | undefined;
-    let namespaceImport: string | undefined;
-    const isTypeOnly = node.importClause?.isTypeOnly ?? false;
-
-    if (node.importClause) {
-      // Default import
-      if (node.importClause.name) {
-        defaultImport = node.importClause.name.text;
-      }
-
-      // Named bindings
-      if (node.importClause.namedBindings) {
-        if (ts.isNamespaceImport(node.importClause.namedBindings)) {
-          // Namespace import: import * as X from '...'
-          namespaceImport = node.importClause.namedBindings.name.text;
-        } else if (ts.isNamedImports(node.importClause.namedBindings)) {
-          // Named imports: import { A, B as C } from '...'
-          for (const element of node.importClause.namedBindings.elements) {
-            namedImports.push({
-              name: element.propertyName?.text ?? element.name.text,
-              alias: element.propertyName ? element.name.text : undefined,
-            });
-          }
-        }
-      }
-    }
-
-    return {
-      module,
-      namedImports,
-      defaultImport,
-      namespaceImport,
-      isTypeOnly,
-    };
-  }
-
-  private extractExportDeclaration(
-    node: ts.ExportDeclaration,
-    exports: ExportInfo[]
-  ): void {
-    const sourceModule = node.moduleSpecifier
-      ? (node.moduleSpecifier as ts.StringLiteral).text
-      : undefined;
-
-    if (node.exportClause && ts.isNamedExports(node.exportClause)) {
-      for (const element of node.exportClause.elements) {
-        exports.push({
-          name: element.name.text,
-          type: 'unknown',
-          isDefault: false,
-          isReexport: !!sourceModule,
-          sourceModule,
-        });
-      }
-    } else if (!node.exportClause && sourceModule) {
-      // export * from '...'
-      exports.push({
-        name: '*',
-        type: 'unknown',
-        isDefault: false,
-        isReexport: true,
-        sourceModule,
-      });
-    }
-  }
-
-  private extractInterfaceDeclaration(
-    node: ts.InterfaceDeclaration,
-    sourceFile: ts.SourceFile
-  ): InterfaceInfo {
-    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-
-    const properties: InterfacePropertyInfo[] = [];
-    const methods: InterfaceMethodInfo[] = [];
-
-    for (const member of node.members) {
-      if (ts.isPropertySignature(member) && member.name) {
-        properties.push({
-          name: this.getPropertyName(member.name, sourceFile),
-          type: member.type ? member.type.getText(sourceFile) : undefined,
-          isOptional: !!member.questionToken,
-          isReadonly: this.hasReadonlyModifier(member),
-        });
-      } else if (ts.isMethodSignature(member) && member.name) {
-        methods.push({
-          name: this.getPropertyName(member.name, sourceFile),
-          parameters: this.extractParameters(member.parameters),
-          returnType: member.type ? member.type.getText(sourceFile) : undefined,
-          isOptional: !!member.questionToken,
-        });
-      }
-    }
-
-    const extendsClause: string[] = [];
-    if (node.heritageClauses) {
-      for (const clause of node.heritageClauses) {
-        if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
-          for (const type of clause.types) {
-            extendsClause.push(type.expression.getText(sourceFile));
-          }
-        }
-      }
-    }
-
-    return {
-      name: node.name.text,
-      properties,
-      methods,
-      extends: extendsClause,
-      isExported: this.hasExportModifier(node),
-      startLine: startLine + 1,
-      endLine: endLine + 1,
-      typeParameters: this.extractTypeParameters(node.typeParameters),
-    };
-  }
-
-  private extractParameters(
-    parameters: ts.NodeArray<ts.ParameterDeclaration>
-  ): ParameterInfo[] {
-    return parameters.map((param) => {
-      const sourceFile = param.getSourceFile();
-      return {
-        name: ts.isIdentifier(param.name)
-          ? param.name.text
-          : param.name.getText(sourceFile),
-        type: param.type ? param.type.getText(sourceFile) : undefined,
-        isOptional: !!param.questionToken || !!param.initializer,
-        isRest: !!param.dotDotDotToken,
-        defaultValue: param.initializer ? param.initializer.getText(sourceFile) : undefined,
-      };
-    });
-  }
-
-  private extractTypeParameters(
-    typeParams: ts.NodeArray<ts.TypeParameterDeclaration> | undefined
-  ): string[] {
-    if (!typeParams) return [];
-    return typeParams.map((tp) => tp.name.text);
-  }
-
-  private getPropertyName(name: ts.PropertyName, sourceFile: ts.SourceFile): string {
-    if (ts.isIdentifier(name)) {
-      return name.text;
-    }
-    if (ts.isStringLiteral(name)) {
-      return name.text;
-    }
-    if (ts.isNumericLiteral(name)) {
-      return name.text;
-    }
-    return name.getText(sourceFile);
-  }
-
-  private getExportAssignmentName(node: ts.ExportAssignment): string {
-    if (ts.isIdentifier(node.expression)) {
-      return node.expression.text;
-    }
-    return 'default';
-  }
-
-  private hasExportModifier(node: ts.Node): boolean {
-    return (
-      ts.canHaveModifiers(node) &&
-      !!ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)
-    );
-  }
-
-  private hasDefaultModifier(node: ts.Node): boolean {
-    return (
-      ts.canHaveModifiers(node) &&
-      !!ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)
-    );
-  }
-
-  private hasAsyncModifier(node: ts.Node): boolean {
-    return (
-      ts.canHaveModifiers(node) &&
-      !!ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)
-    );
-  }
-
-  private hasStaticModifier(node: ts.Node): boolean {
-    return (
-      ts.canHaveModifiers(node) &&
-      !!ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)
-    );
-  }
-
-  private hasAbstractModifier(node: ts.Node): boolean {
-    return (
-      ts.canHaveModifiers(node) &&
-      !!ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword)
-    );
-  }
-
-  private hasReadonlyModifier(node: ts.Node): boolean {
-    return (
-      ts.canHaveModifiers(node) &&
-      !!ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword)
-    );
-  }
-
-  private getVisibility(
-    node: ts.Node
-  ): 'public' | 'private' | 'protected' {
-    if (!ts.canHaveModifiers(node)) return 'public';
-    const modifiers = ts.getModifiers(node);
-    if (!modifiers) return 'public';
-
-    if (modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword)) {
-      return 'private';
-    }
-    if (modifiers.some((m) => m.kind === ts.SyntaxKind.ProtectedKeyword)) {
-      return 'protected';
-    }
-    return 'public';
-  }
-}
-
-// Export a default instance for convenience
-export const typescriptParser = new TypeScriptParser();