@angular-modernizer/api 0.1.0

package/dist/analysis/service-pattern-recognizer.d.ts

@@ -0,0 +1,247 @@
+/**
+ * @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 declare 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 declare class ServicePatternRecognizer {
+    private readonly 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);
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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[];
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Get all `` classes using ng-morph.
+     *
+     * @param filePath - File path to check
+     * @returns Array of class declarations
+     */
+    private getAllInjectablesUsingNgMorph;
+    /**
+     * Classify an `` service.
+     *
+     * @param classDecl - The class declaration
+     * @param filePath - The file path
+     * @returns Service classification
+     */
+    private classifyInjectableService;
+    /**
+     * Classify service using ts-morph (fallback).
+     *
+     * @param sourceFile - The source file
+     * @returns Service classification
+     */
+    private classifyUsingTsMorph;
+    /**
+     * Detect service pattern from class name.
+     *
+     * @param className - The class name to analyze
+     * @returns Service pattern
+     */
+    private detectPatternFromName;
+    /**
+     * Check if a pattern represents stateful services.
+     *
+     * @param pattern - The service pattern
+     * @returns True if stateful
+     */
+    private isStatefulPattern;
+    /**
+     * Check if a class is stateful (has state properties).
+     *
+     * @param classDecl - The class declaration
+     * @returns True if stateful
+     */
+    private isStatefulClass;
+}
+//# sourceMappingURL=service-pattern-recognizer.d.ts.map

package/dist/analysis/service-pattern-recognizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-pattern-recognizer.d.ts","sourceRoot":"","sources":["../../src/analysis/service-pattern-recognizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAE5E;;GAEG;AACH,oBAAY,cAAc;IACxB,wCAAwC;IACxC,UAAU,eAAe;IAEzB,0CAA0C;IAC1C,OAAO,YAAY;IAEnB,wDAAwD;IACxD,UAAU,eAAe;IAEzB,4CAA4C;IAC5C,QAAQ,aAAa;IAErB,gDAAgD;IAChD,MAAM,WAAW;IAEjB,yDAAyD;IACzD,KAAK,UAAU;IAEf,wCAAwC;IACxC,MAAM,WAAW;IAEjB,kDAAkD;IAClD,OAAO,YAAY;IAEnB,kDAAkD;IAClD,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,+BAA+B;IAC/B,OAAO,EAAE,cAAc,CAAC;IAExB,4CAA4C;IAC5C,YAAY,EAAE,OAAO,CAAC;IAEtB,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAElB,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IAEjB,iDAAiD;IACjD,UAAU,EAAE,OAAO,CAAC;IAEpB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,gCAAgC;IAChC,SAAS,EAAE,OAAO,CAAC;IAEnB,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IAEnB,4BAA4B;IAC5B,eAAe,EAAE,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;CAC/E;AAED;;;;;;;;;GASG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAiB;IAEjD;;;;;;OAMG;gBACS,cAAc,CAAC,EAAE,cAAc;IAI3C;;;;;;;;;;;;;;;;OAgBG;IACH,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,qBAAqB;IAe9D;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO;IAK9C;;;;;;;OAOG;IACH,qBAAqB,CAAC,UAAU,EAAE,UAAU,GAAG,qBAAqB,EAAE;IA2CtE;;;;;;;;;;;;;;;;OAgBG;IACH,aAAa,CAAC,SAAS,EAAE,gBAAgB,GAAG,sBAAsB;IA0ClE;;;;;;;;;;;;;;;OAeG;IACH,sBAAsB,CAAC,SAAS,EAAE,gBAAgB,GAAG,OAAO;IAkB5D;;;;;;;;OAQG;IACH,OAAO,CAAC,4BAA4B;IAIpC;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,SAAS,EAAE,gBAAgB,GAAG,OAAO;IAI/C;;;;;;;;;OASG;IACH,OAAO,CAAC,4BAA4B;IA6BpC;;;;;OAKG;IACH,OAAO,CAAC,6BAA6B;IAyBrC;;;;;;OAMG;IACH,OAAO,CAAC,yBAAyB;IAoBjC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAiC5B;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IA4B7B;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;;;;OAKG;IACH,OAAO,CAAC,eAAe;CAiBxB"}

package/dist/analysis/service-pattern-recognizer.js

@@ -0,0 +1,444 @@
+/**
+ * @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
+ */
+/**
+ * Service pattern types that can be recognized.
+ */
+export var ServicePattern;
+(function (ServicePattern) {
+    /** Angular service decorated with `` */
+    ServicePattern["INJECTABLE"] = "injectable";
+    /** Service class with 'Service' suffix */
+    ServicePattern["SERVICE"] = "service";
+    /** Repository pattern class with 'Repository' suffix */
+    ServicePattern["REPOSITORY"] = "repository";
+    /** Provider class with 'Provider' suffix */
+    ServicePattern["PROVIDER"] = "provider";
+    /** Facade pattern class with 'Facade' suffix */
+    ServicePattern["FACADE"] = "facade";
+    /** Store class (state management) with 'Store' suffix */
+    ServicePattern["STORE"] = "store";
+    /** Helper class with 'Helper' suffix */
+    ServicePattern["HELPER"] = "helper";
+    /** Utility class with 'Util' or 'Utils' suffix */
+    ServicePattern["UTILITY"] = "utility";
+    /** Unknown pattern - not recognized as service */
+    ServicePattern["UNKNOWN"] = "unknown";
+})(ServicePattern || (ServicePattern = {}));
+/**
+ * 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 {
+    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) {
+        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) {
+        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) {
+        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) {
+        const filePath = sourceFile.getFilePath();
+        const results = [];
+        // 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) {
+        // 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) {
+        // 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
+     */
+    legacyHasInjectableDecorator(classDecl) {
+        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) {
+        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
+     */
+    detectInjectableUsingNgMorph(filePath) {
+        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
+     */
+    getAllInjectablesUsingNgMorph(filePath) {
+        try {
+            const classes = [];
+            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
+     */
+    classifyInjectableService(classDecl, filePath) {
+        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
+     */
+    classifyUsingTsMorph(sourceFile) {
+        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
+     */
+    detectPatternFromName(className) {
+        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
+     */
+    isStatefulPattern(pattern) {
+        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
+     */
+    isStatefulClass(classDecl) {
+        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;
+    }
+}
+//# sourceMappingURL=service-pattern-recognizer.js.map