@angular-modernizer/api 0.1.0

package/src/analysis/service-pattern-recognizer.ts

@@ -0,0 +1,545 @@
+/**
+ * @angular-modernizer/api - Service Pattern Recognizer
+ *
+ * Centralized service for recognizing and classifying Angular service patterns.
+ * Uses ng-morph for Angular-specific detection and ts-morph for fallback analysis.
+ *
+ * MIGRATION NOTE: Created as part of ng-morph integration Phase 4.
+ * - Centralizes service pattern recognition across orchestrators
+ * - Uses ng-morph for Angular services (`` decorated classes)
+ * - Falls back to ts-morph for complex edge cases
+ * - Replaces scattered service suffix checks in multiple orchestrators
+ * - Expected code reduction: ~40% in orchestrators using this service
+ */
+
+import type { SourceFile, ClassDeclaration } from 'ts-morph';
+import type { NgMorphAdapter } from '../transformation/ng-morph-adapter.js';
+
+/**
+ * Service pattern types that can be recognized.
+ */
+export enum ServicePattern {
+  /** Angular service decorated with `` */
+  INJECTABLE = 'injectable',
+
+  /** Service class with 'Service' suffix */
+  SERVICE = 'service',
+
+  /** Repository pattern class with 'Repository' suffix */
+  REPOSITORY = 'repository',
+
+  /** Provider class with 'Provider' suffix */
+  PROVIDER = 'provider',
+
+  /** Facade pattern class with 'Facade' suffix */
+  FACADE = 'facade',
+
+  /** Store class (state management) with 'Store' suffix */
+  STORE = 'store',
+
+  /** Helper class with 'Helper' suffix */
+  HELPER = 'helper',
+
+  /** Utility class with 'Util' or 'Utils' suffix */
+  UTILITY = 'utility',
+
+  /** Unknown pattern - not recognized as service */
+  UNKNOWN = 'unknown',
+}
+
+/**
+ * Service classification result.
+ */
+export interface ServiceClassification {
+  /** The service pattern type */
+  pattern: ServicePattern;
+
+  /** Whether this is an Angular `` service */
+  isInjectable: boolean;
+
+  /** Class name */
+  className: string;
+
+  /** File path */
+  filePath: string;
+
+  /** Whether this is a state management service */
+  isStateful: boolean;
+
+  /** Confidence level (0-1) for the classification */
+  confidence: number;
+}
+
+/**
+ * Service detection result with confidence scoring.
+ */
+export interface ServiceDetectionResult {
+  /** Whether this is a service */
+  isService: boolean;
+
+  /** Confidence level (0-1) for the detection */
+  confidence: number;
+
+  /** Detection method used */
+  detectionMethod: 'decorator' | 'filename' | 'classname' | 'combined' | 'none';
+}
+
+/**
+ * Service Pattern Recognizer - centralized service pattern detection.
+ *
+ * HYBRID APPROACH:
+ * - Uses ng-morph to detect `` decorated classes
+ * - Falls back to ts-morph for suffix-based pattern matching
+ * - Provides confidence scores for classifications
+ *
+ * This replaces scattered service detection logic across orchestrators.
+ */
+export class ServicePatternRecognizer {
+  private readonly ngMorphAdapter?: NgMorphAdapter;
+
+  /**
+   * Constructor for ServicePatternRecognizer.
+   *
+   * @param ngMorphAdapter - Optional ng-morph adapter for Angular-specific operations
+   *
+   * BACKWARD COMPATIBILITY: Constructor is optional - if not provided, falls back to pure ts-morph.
+   */
+  constructor(ngMorphAdapter?: NgMorphAdapter) {
+    this.ngMorphAdapter = ngMorphAdapter;
+  }
+
+  /**
+   * Classify a source file as a service pattern.
+   *
+   * Uses ng-morph to detect ``, then analyzes class structure
+   * and naming to determine the specific service pattern.
+   *
+   * @param sourceFile - The source file to analyze
+   * @returns Service classification result
+   *
+   * @example
+   * ```typescript
+   * const classification = recognizer.classifyService(sourceFile);
+   * if (classification.pattern === ServicePattern.INJECTABLE) {
+   *   console.info('This is an Angular service');
+   * }
+   * ```
+   */
+  classifyService(sourceFile: SourceFile): ServiceClassification {
+    const filePath = sourceFile.getFilePath();
+
+    // Try ng-morph first for Angular services
+    if (this.ngMorphAdapter) {
+      const injectableClass = this.detectInjectableUsingNgMorph(filePath);
+      if (injectableClass) {
+        return this.classifyInjectableService(injectableClass, filePath);
+      }
+    }
+
+    // Fall back to ts-morph for suffix-based detection
+    return this.classifyUsingTsMorph(sourceFile);
+  }
+
+  /**
+   * Check if a source file contains a service class.
+   *
+   * Quick check without full classification.
+   *
+   * @param sourceFile - The source file to check
+   * @returns True if the file contains a service class
+   *
+   * @example
+   * ```typescript
+   * if (recognizer.isServiceFile(sourceFile)) {
+   *   // Perform service-specific analysis
+   * }
+   * ```
+   */
+  isServiceFile(sourceFile: SourceFile): boolean {
+    const classification = this.classifyService(sourceFile);
+    return classification.pattern !== ServicePattern.UNKNOWN;
+  }
+
+  /**
+   * Get all service patterns in the source file.
+   *
+   * Some files may contain multiple service classes.
+   *
+   * @param sourceFile - The source file to analyze
+   * @returns Array of service classifications
+   */
+  getAllServicePatterns(sourceFile: SourceFile): ServiceClassification[] {
+    const filePath = sourceFile.getFilePath();
+    const results: ServiceClassification[] = [];
+
+    // Try ng-morph for all @Injectable classes
+    if (this.ngMorphAdapter) {
+      const injectables = this.getAllInjectablesUsingNgMorph(filePath);
+      results.push(
+        ...injectables.map((cls) =>
+          this.classifyInjectableService(cls, filePath),
+        ),
+      );
+    }
+
+    // Also check for non-@Injectable service classes
+    const classes = sourceFile.getClasses();
+    for (const cls of classes) {
+      const className = cls.getName();
+      if (!className) {
+        continue;
+      }
+
+      // Skip if already classified as @Injectable
+      if (results.some((r) => r.className === className)) {
+        continue;
+      }
+
+      const pattern = this.detectPatternFromName(className);
+      if (pattern !== ServicePattern.UNKNOWN) {
+        results.push({
+          pattern,
+          isInjectable: false,
+          className,
+          filePath,
+          isStateful: this.isStatefulPattern(pattern),
+          confidence: 0.7, // Lower confidence for suffix-based detection
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Detect if a class is a service with confidence scoring.
+   *
+   * This method provides a more detailed analysis than isService(),
+   * including confidence levels and detection methodology.
+   *
+   * @param classDecl - The class declaration to analyze
+   * @returns Service detection result with confidence and method
+   *
+   * @example
+   * ```typescript
+   * const result = recognizer.detectService(classDecl);
+   * if (result.isService && result.confidence > 0.8) {
+   *   console.info(`Detected service via ${result.detectionMethod}`);
+   * }
+   * ```
+   */
+  detectService(classDecl: ClassDeclaration): ServiceDetectionResult {
+    // Priority 1: Check for @Injectable decorator (highest confidence)
+    if (this.hasInjectableDecorator(classDecl)) {
+      return {
+        isService: true,
+        confidence: 1.0,
+        detectionMethod: 'decorator',
+      };
+    }
+
+    // Priority 2: Check class name pattern
+    const className = classDecl.getName();
+    if (className) {
+      const pattern = this.detectPatternFromName(className);
+      if (pattern !== ServicePattern.UNKNOWN) {
+        return {
+          isService: true,
+          confidence: 0.7,
+          detectionMethod: 'classname',
+        };
+      }
+    }
+
+    // Priority 3: Check file name pattern
+    const sourceFile = classDecl.getSourceFile();
+    const filePath = sourceFile.getFilePath().toLowerCase();
+    if (filePath.includes('.service.') || filePath.endsWith('service.ts')) {
+      return {
+        isService: true,
+        confidence: 0.6,
+        detectionMethod: 'filename',
+      };
+    }
+
+    // Not detected as service
+    return {
+      isService: false,
+      confidence: 0.0,
+      detectionMethod: 'none',
+    };
+  }
+
+  /**
+   * Check if a class declaration has the `` decorator.
+   *
+   * Uses ng-morph adapter if available for enhanced detection,
+   * falls back to legacy ts-morph detection otherwise.
+   *
+   * @param classDecl - The class declaration to check
+   * @returns True if the class has `` decorator
+   *
+   * @example
+   * ```typescript
+   * if (recognizer.hasInjectableDecorator(classDecl)) {
+   *   console.info('This is an Angular service');
+   * }
+   * ```
+   */
+  hasInjectableDecorator(classDecl: ClassDeclaration): boolean {
+    // Try ng-morph approach if adapter is available
+    if (this.ngMorphAdapter) {
+      try {
+        const filePath = classDecl.getSourceFile().getFilePath();
+        const ngMorphClass = this.detectInjectableUsingNgMorph(filePath);
+        if (ngMorphClass && ngMorphClass.getName() === classDecl.getName()) {
+          return true;
+        }
+      } catch {
+        // Fall through to legacy detection
+      }
+    }
+
+    // Fall back to legacy ts-morph detection
+    return this.legacyHasInjectableDecorator(classDecl);
+  }
+
+  /**
+   * Legacy method to check for `` decorator using ts-morph.
+   *
+   * This is the original detection logic, kept for backward compatibility
+   * and as a fallback when ng-morph is not available.
+   *
+   * @param classDecl - The class declaration to check
+   * @returns True if the class has `` decorator
+   */
+  private legacyHasInjectableDecorator(classDecl: ClassDeclaration): boolean {
+    return classDecl.getDecorator('Injectable') !== undefined;
+  }
+
+  /**
+   * Simple check if a class is a service.
+   *
+   * This is a convenience method that wraps detectService()
+   * for backward compatibility with existing code.
+   *
+   * @param classDecl - The class declaration to check
+   * @returns True if the class is detected as a service
+   *
+   * @example
+   * ```typescript
+   * if (recognizer.isService(classDecl)) {
+   *   // Handle service class
+   * }
+   * ```
+   */
+  isService(classDecl: ClassDeclaration): boolean {
+    return this.detectService(classDecl).isService;
+  }
+
+  /**
+   * Detect `` service using ng-morph.
+   *
+   * IMPLEMENTATION NOTE: ng-morph doesn't have a dedicated API for finding
+   * `` services. We use ts-morph to search for the `` decorator
+   * directly, which provides HIGH CONFIDENCE (1.0) classification.
+   *
+   * @param filePath - File path to check
+   * @returns Class declaration if found, undefined otherwise
+   */
+  private detectInjectableUsingNgMorph(
+    filePath: string,
+  ): ClassDeclaration | undefined {
+    try {
+      // Get the source file from ts-morph project
+      const project = this.ngMorphAdapter?.getProject();
+      const sourceFile = project?.getSourceFile(filePath);
+
+      if (!sourceFile) {
+        return undefined;
+      }
+
+      // Find the first class with @Injectable decorator
+      // Note: ng-morph (as of v4.8.4) doesn't provide a specialized API
+      // for services, so we use ts-morph's decorator detection
+      for (const cls of sourceFile.getClasses()) {
+        const hasInjectableDecorator =
+          cls.getDecorator('Injectable') !== undefined;
+        if (hasInjectableDecorator) {
+          return cls;
+        }
+      }
+
+      return undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /**
+   * Get all `` classes using ng-morph.
+   *
+   * @param filePath - File path to check
+   * @returns Array of class declarations
+   */
+  private getAllInjectablesUsingNgMorph(filePath: string): ClassDeclaration[] {
+    try {
+      const classes: ClassDeclaration[] = [];
+      const project = this.ngMorphAdapter?.getProject();
+      const sourceFile = project?.getSourceFile(filePath);
+
+      if (!sourceFile) {
+        return [];
+      }
+
+      // Check all classes in the file
+      for (const cls of sourceFile.getClasses()) {
+        const hasInjectableDecorator =
+          cls.getDecorator('Injectable') !== undefined;
+        if (hasInjectableDecorator) {
+          classes.push(cls);
+        }
+      }
+
+      return classes;
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Classify an `` service.
+   *
+   * @param classDecl - The class declaration
+   * @param filePath - The file path
+   * @returns Service classification
+   */
+  private classifyInjectableService(
+    classDecl: ClassDeclaration,
+    filePath: string,
+  ): ServiceClassification {
+    const className = classDecl.getName() ?? 'Unknown';
+    const pattern = this.detectPatternFromName(className);
+
+    return {
+      pattern:
+        pattern === ServicePattern.UNKNOWN
+          ? ServicePattern.INJECTABLE
+          : pattern,
+      isInjectable: true,
+      className,
+      filePath,
+      isStateful: this.isStatefulClass(classDecl),
+      confidence: 1.0, // High confidence for @Injectable
+    };
+  }
+
+  /**
+   * Classify service using ts-morph (fallback).
+   *
+   * @param sourceFile - The source file
+   * @returns Service classification
+   */
+  private classifyUsingTsMorph(sourceFile: SourceFile): ServiceClassification {
+    const filePath = sourceFile.getFilePath();
+    const classes = sourceFile.getClasses();
+
+    for (const cls of classes) {
+      const className = cls.getName();
+      if (!className) {
+        continue;
+      }
+
+      const pattern = this.detectPatternFromName(className);
+      if (pattern !== ServicePattern.UNKNOWN) {
+        return {
+          pattern,
+          isInjectable: false,
+          className,
+          filePath,
+          isStateful: this.isStatefulClass(cls),
+          confidence: 0.7, // Lower confidence for suffix-based
+        };
+      }
+    }
+
+    return {
+      pattern: ServicePattern.UNKNOWN,
+      isInjectable: false,
+      className: 'Unknown',
+      filePath,
+      isStateful: false,
+      confidence: 0.0,
+    };
+  }
+
+  /**
+   * Detect service pattern from class name.
+   *
+   * @param className - The class name to analyze
+   * @returns Service pattern
+   */
+  private detectPatternFromName(className: string): ServicePattern {
+    const lowerName = className.toLowerCase();
+
+    if (lowerName.endsWith('service')) {
+      return ServicePattern.SERVICE;
+    }
+    if (lowerName.endsWith('repository')) {
+      return ServicePattern.REPOSITORY;
+    }
+    if (lowerName.endsWith('provider')) {
+      return ServicePattern.PROVIDER;
+    }
+    if (lowerName.endsWith('facade')) {
+      return ServicePattern.FACADE;
+    }
+    if (lowerName.endsWith('store')) {
+      return ServicePattern.STORE;
+    }
+    if (lowerName.endsWith('helper')) {
+      return ServicePattern.HELPER;
+    }
+    if (lowerName.endsWith('util') || lowerName.endsWith('utils')) {
+      return ServicePattern.UTILITY;
+    }
+
+    return ServicePattern.UNKNOWN;
+  }
+
+  /**
+   * Check if a pattern represents stateful services.
+   *
+   * @param pattern - The service pattern
+   * @returns True if stateful
+   */
+  private isStatefulPattern(pattern: ServicePattern): boolean {
+    return (
+      pattern === ServicePattern.STORE || pattern === ServicePattern.FACADE
+    );
+  }
+
+  /**
+   * Check if a class is stateful (has state properties).
+   *
+   * @param classDecl - The class declaration
+   * @returns True if stateful
+   */
+  private isStatefulClass(classDecl: ClassDeclaration): boolean {
+    const properties = classDecl.getProperties();
+
+    // Check for state-related property names
+    for (const prop of properties) {
+      const propName = prop.getName().toLowerCase();
+      if (
+        propName.includes('state') ||
+        propName.includes('store') ||
+        propName.includes('cache')
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

package/src/analysis/symbol-locator.ts

@@ -0,0 +1,170 @@
+/**
+ * @angular-modernizer/api - Symbol Locator
+ *
+ * Service for locating symbols (classes, functions, etc.) across the entire project.
+ * Builds a project-wide index of exported classes for fast lookups.
+ *
+ * This enables resolving project-local dependencies (components, directives, pipes)
+ * and calculating the correct import paths for them.
+ */
+
+import type { Project, SourceFile, ClassDeclaration } from 'ts-morph';
+
+/**
+ * Symbol information from the project-wide index.
+ */
+export interface SymbolInfo {
+  /**
+   * The class name
+   */
+  className: string;
+
+  /**
+   * The source file where this class is declared
+   */
+  sourceFile: SourceFile;
+
+  /**
+   * Whether this is an exported class
+   */
+  isExported: boolean;
+}
+
+/**
+ * Symbol Locator - builds and maintains a project-wide symbol index.
+ *
+ * This service scans the entire project to create a comprehensive map of all
+ * exported classes, enabling fast lookup of where any symbol is defined.
+ */
+export class SymbolLocator {
+  /**
+   * Build a project-wide symbol map.
+   *
+   * This method scans every source file in the project and indexes all exported
+   * classes by their name. The resulting map can be used to quickly find where
+   * any class is defined, which is essential for generating correct import paths.
+   *
+   * @param project - The ts-morph Project instance
+   * @returns Map from class name to SymbolInfo
+   *
+   * @example
+   * ```typescript
+   * const symbolMap = symbolLocator.buildProjectSymbolMap(project);
+   * const symbol = symbolMap.get('AdduserEntryComponent');
+   * if (symbol) {
+   *   console.info(`Found at: ${symbol.sourceFile.getFilePath()}`);
+   * }
+   * ```
+   */
+  buildProjectSymbolMap(project: Project): Map<string, SymbolInfo> {
+    const symbolMap = new Map<string, SymbolInfo>();
+
+    // Get all source files in the project
+    const sourceFiles = project.getSourceFiles();
+
+    for (const sourceFile of sourceFiles) {
+      // Skip declaration files and node_modules
+      const filePath = sourceFile.getFilePath();
+      if (filePath.includes('node_modules') || filePath.endsWith('.d.ts')) {
+        continue;
+      }
+
+      // Find all classes in this file
+      const classes = sourceFile.getClasses();
+
+      for (const classDecl of classes) {
+        const className = classDecl.getName();
+        if (!className) {
+          continue; // Skip anonymous classes
+        }
+
+        // Check if the class is exported
+        const isExported = this.isClassExported(classDecl);
+
+        // Only index exported classes (or all classes - configurable)
+        if (isExported) {
+          // If a class with this name already exists, keep the first occurrence
+          // (In real projects, same names in different modules are possible,
+          // but for standalone migration, we prioritize the first match)
+          if (!symbolMap.has(className)) {
+            symbolMap.set(className, {
+              className,
+              sourceFile,
+              isExported,
+            });
+          }
+        }
+      }
+    }
+
+    return symbolMap;
+  }
+
+  /**
+   * Check if a class declaration is exported.
+   *
+   * @param classDecl - The class declaration to check
+   * @returns true if the class is exported
+   */
+  private isClassExported(classDecl: ClassDeclaration): boolean {
+    return classDecl.isExported();
+  }
+
+  /**
+   * Calculate the relative import path from one file to another.
+   *
+   * Given a source file and a target file, this calculates the correct
+   * relative import path (e.g., '../dialogs/xyz.component').
+   *
+   * @param fromFile - The file that will contain the import statement
+   * @param toFile - The file to import from
+   * @returns The relative import path (without extension)
+   *
+   * @example
+   * ```typescript
+   * // From: /project/src/app/user/user.component.ts
+   * // To:   /project/src/app/dialogs/xyz.component.ts
+   * // Result: '../dialogs/xyz.component'
+   * ```
+   */
+  calculateRelativeImportPath(
+    fromFile: SourceFile,
+    toFile: SourceFile,
+  ): string {
+    const fromPath = fromFile.getFilePath();
+    const toPath = toFile.getFilePath();
+
+    // Get directory paths
+    const fromDir = fromPath.substring(0, fromPath.lastIndexOf('/'));
+    const toPathWithoutExt = toPath.replace(/\.ts$/, '');
+
+    // Calculate relative path
+    const fromParts = fromDir.split('/');
+    const toParts = toPathWithoutExt.split('/');
+
+    // Find common ancestor
+    let commonLength = 0;
+    while (
+      commonLength < fromParts.length &&
+      commonLength < toParts.length &&
+      fromParts[commonLength] === toParts[commonLength]
+    ) {
+      commonLength++;
+    }
+
+    // Build relative path
+    const upLevels = fromParts.length - commonLength;
+    const downPath = toParts.slice(commonLength).join('/');
+
+    let relativePath = '';
+    if (upLevels > 0) {
+      relativePath = '../'.repeat(upLevels);
+    } else {
+      relativePath = './';
+    }
+
+    relativePath += downPath;
+
+    return relativePath;
+  }
+}