dartmind 17.0.0

package/dist/gates/ArchitectureGate.d.ts

@@ -0,0 +1,148 @@
+/**
+ * FlutterAI v10 - ArchitectureGate
+ *
+ * Validates Flutter/Dart code for architectural best practices.
+ * Enforces clean architecture, SOLID principles, and separation of concerns.
+ *
+ * @module gates/ArchitectureGate
+ */
+import { EventEmitter } from 'events';
+export type ArchIssueType = 'ui_business_mix' | 'data_in_ui' | 'missing_abstraction' | 'circular_dependency' | 'god_class' | 'feature_envy' | 'improper_layer' | 'hardcoded_dependency' | 'missing_interface' | 'coupling_violation' | 'cohesion_issue' | 'naming_violation' | 'file_structure';
+export type ArchSeverity = 'error' | 'warning' | 'info';
+export type ArchitecturePattern = 'clean_architecture' | 'mvvm' | 'mvc' | 'bloc_pattern' | 'repository_pattern' | 'unknown';
+export type ArchLayerType = 'presentation' | 'domain' | 'data' | 'infrastructure' | 'shared' | 'unknown';
+export interface ArchIssue {
+    /** Type of issue */
+    type: ArchIssueType;
+    /** Severity level */
+    severity: ArchSeverity;
+    /** Line number */
+    line: number;
+    /** Column number */
+    column: number;
+    /** Code snippet */
+    code: string;
+    /** Issue message */
+    message: string;
+    /** SOLID principle violated */
+    solidPrinciple?: 'S' | 'O' | 'L' | 'I' | 'D';
+    /** Suggested fix */
+    suggestion: string;
+}
+export interface ArchGateConfig {
+    /** Expected architecture pattern */
+    expectedPattern: ArchitecturePattern;
+    /** Check for layer violations */
+    checkLayerViolations: boolean;
+    /** Check for SOLID principles */
+    checkSOLID: boolean;
+    /** Check naming conventions */
+    checkNaming: boolean;
+    /** Check for god classes */
+    checkGodClasses: boolean;
+    /** Maximum lines per class */
+    maxClassLines: number;
+    /** Maximum methods per class */
+    maxClassMethods: number;
+    /** Maximum parameters per method */
+    maxMethodParams: number;
+    /** Strict mode - treat warnings as errors */
+    strictMode: boolean;
+}
+export interface ArchGateResult {
+    /** Whether validation passed */
+    passed: boolean;
+    /** Issues found */
+    issues: ArchIssue[];
+    /** Detected architecture pattern */
+    detectedPattern: ArchitecturePattern;
+    /** Detected layer */
+    detectedLayer: ArchLayerType;
+    /** Error count */
+    errorCount: number;
+    /** Warning count */
+    warningCount: number;
+    /** Score (0-100) */
+    score: number;
+}
+export interface ArchGateStats {
+    /** Total validations */
+    totalValidations: number;
+    /** Passed validations */
+    passedCount: number;
+    /** Failed validations */
+    failedCount: number;
+    /** Issues by type */
+    issuesByType: Map<ArchIssueType, number>;
+    /** Files by layer */
+    filesByLayer: Map<ArchLayerType, number>;
+    /** Average score */
+    averageScore: number;
+}
+export declare class ArchitectureGate extends EventEmitter {
+    private config;
+    private stats;
+    private totalScoreSum;
+    constructor(config?: Partial<ArchGateConfig>);
+    /**
+     * Validate Dart/Flutter code for architecture
+     */
+    validate(code: string, filePath?: string): ArchGateResult;
+    /**
+     * Detect architectural layer
+     */
+    private detectLayer;
+    /**
+     * Detect architecture pattern
+     */
+    private detectPattern;
+    /**
+     * Check for layer violations
+     */
+    private checkLayerViolations;
+    /**
+     * Check SOLID principles
+     */
+    private checkSOLIDPrinciples;
+    /**
+     * Check naming conventions
+     */
+    private checkNamingConventions;
+    /**
+     * Check for god classes
+     */
+    private checkGodClasses;
+    /**
+     * Check for architecture anti-patterns
+     */
+    private checkAntiPatterns;
+    /**
+     * Extract class body
+     */
+    private extractClassBody;
+    /**
+     * Get line number from position
+     */
+    private getLineNumber;
+    /**
+     * Calculate score
+     */
+    private calculateScore;
+    /**
+     * Get statistics
+     */
+    getStats(): ArchGateStats;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Get health status
+     */
+    getHealth(): {
+        healthy: boolean;
+        message: string;
+    };
+}
+export default ArchitectureGate;
+//# sourceMappingURL=ArchitectureGate.d.ts.map

package/dist/gates/ArchitectureGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArchitectureGate.d.ts","sourceRoot":"","sources":["../../src/gates/ArchitectureGate.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAMtC,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB,YAAY,GACZ,qBAAqB,GACrB,qBAAqB,GACrB,WAAW,GACX,cAAc,GACd,gBAAgB,GAChB,sBAAsB,GACtB,mBAAmB,GACnB,oBAAoB,GACpB,gBAAgB,GAChB,kBAAkB,GAClB,gBAAgB,CAAC;AAErB,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAExD,MAAM,MAAM,mBAAmB,GAC3B,oBAAoB,GACpB,MAAM,GACN,KAAK,GACL,cAAc,GACd,oBAAoB,GACpB,SAAS,CAAC;AAEd,MAAM,MAAM,aAAa,GACrB,cAAc,GACd,QAAQ,GACR,MAAM,GACN,gBAAgB,GAChB,QAAQ,GACR,SAAS,CAAC;AAEd,MAAM,WAAW,SAAS;IACxB,oBAAoB;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,qBAAqB;IACrB,QAAQ,EAAE,YAAY,CAAC;IACvB,kBAAkB;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,cAAc,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAC7C,oBAAoB;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,oCAAoC;IACpC,eAAe,EAAE,mBAAmB,CAAC;IACrC,iCAAiC;IACjC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,iCAAiC;IACjC,UAAU,EAAE,OAAO,CAAC;IACpB,+BAA+B;IAC/B,WAAW,EAAE,OAAO,CAAC;IACrB,4BAA4B;IAC5B,eAAe,EAAE,OAAO,CAAC;IACzB,8BAA8B;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,oCAAoC;IACpC,eAAe,EAAE,MAAM,CAAC;IACxB,6CAA6C;IAC7C,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,mBAAmB;IACnB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,oCAAoC;IACpC,eAAe,EAAE,mBAAmB,CAAC;IACrC,qBAAqB;IACrB,aAAa,EAAE,aAAa,CAAC;IAC7B,kBAAkB;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,wBAAwB;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,yBAAyB;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,yBAAyB;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB;IACrB,YAAY,EAAE,GAAG,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IACzC,qBAAqB;IACrB,YAAY,EAAE,GAAG,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IACzC,oBAAoB;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAqDD,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,KAAK,CAOX;IACF,OAAO,CAAC,aAAa,CAAK;gBAEd,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC;IAK5C;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,cAAc;IAsEzD;;OAEG;IACH,OAAO,CAAC,WAAW;IAcnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAwBrB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAuE5B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA6E5B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA2C9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAyDvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAyCzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAqBxB;;OAEG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACH,OAAO,CAAC,cAAc;IA0BtB;;OAEG;IACH,QAAQ,IAAI,aAAa;IAQzB;;OAEG;IACH,UAAU,IAAI,IAAI;IAYlB;;OAEG;IACH,SAAS,IAAI;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAUnD;AAED,eAAe,gBAAgB,CAAC"}

package/dist/gates/ArchitectureGate.js

@@ -0,0 +1,538 @@
+/**
+ * FlutterAI v10 - ArchitectureGate
+ *
+ * Validates Flutter/Dart code for architectural best practices.
+ * Enforces clean architecture, SOLID principles, and separation of concerns.
+ *
+ * @module gates/ArchitectureGate
+ */
+import { EventEmitter } from 'events';
+// ============================================================================
+// Default Configuration
+// ============================================================================
+const DEFAULT_CONFIG = {
+    expectedPattern: 'clean_architecture',
+    checkLayerViolations: true,
+    checkSOLID: true,
+    checkNaming: true,
+    checkGodClasses: true,
+    maxClassLines: 300,
+    maxClassMethods: 20,
+    maxMethodParams: 5,
+    strictMode: false
+};
+// ============================================================================
+// Layer Detection Patterns
+// ============================================================================
+const LAYER_PATTERNS = {
+    presentation: [
+        /\/(?:screens?|pages?|views?|widgets?|ui)\//i,
+        /(?:Screen|Page|View|Widget)\.dart$/i,
+        /extends\s+(?:Stateless|Stateful)Widget/
+    ],
+    domain: [
+        /\/(?:domain|entities|usecases?|models?)\//i,
+        /(?:Entity|UseCase|Model)\.dart$/i,
+        /abstract\s+class\s+\w+Repository/
+    ],
+    data: [
+        /\/(?:data|repositories|datasources?|api)\//i,
+        /(?:Repository|DataSource|Api)Impl\.dart$/i,
+        /implements\s+\w+Repository/
+    ],
+    infrastructure: [
+        /\/(?:infrastructure|services?|providers?)\//i,
+        /(?:Service|Provider|Client)\.dart$/i
+    ],
+    shared: [
+        /\/(?:shared|common|utils?|helpers?|core)\//i,
+        /(?:Utils?|Helper|Constants?)\.dart$/i
+    ],
+    unknown: []
+};
+// ============================================================================
+// ArchitectureGate Implementation
+// ============================================================================
+export class ArchitectureGate extends EventEmitter {
+    config;
+    stats = {
+        totalValidations: 0,
+        passedCount: 0,
+        failedCount: 0,
+        issuesByType: new Map(),
+        filesByLayer: new Map(),
+        averageScore: 100
+    };
+    totalScoreSum = 0;
+    constructor(config) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Validate Dart/Flutter code for architecture
+     */
+    validate(code, filePath) {
+        this.stats.totalValidations++;
+        const issues = [];
+        // Detect layer and pattern
+        const detectedLayer = this.detectLayer(code, filePath);
+        const detectedPattern = this.detectPattern(code);
+        // Update layer stats
+        const layerCount = this.stats.filesByLayer.get(detectedLayer) ?? 0;
+        this.stats.filesByLayer.set(detectedLayer, layerCount + 1);
+        // Run checks
+        if (this.config.checkLayerViolations) {
+            this.checkLayerViolations(code, detectedLayer, issues, filePath);
+        }
+        if (this.config.checkSOLID) {
+            this.checkSOLIDPrinciples(code, issues);
+        }
+        if (this.config.checkNaming) {
+            this.checkNamingConventions(code, detectedLayer, issues);
+        }
+        if (this.config.checkGodClasses) {
+            this.checkGodClasses(code, issues);
+        }
+        // Check for common architecture anti-patterns
+        this.checkAntiPatterns(code, issues);
+        // Calculate result
+        const errorCount = issues.filter(i => i.severity === 'error').length;
+        const warningCount = issues.filter(i => i.severity === 'warning').length;
+        const score = this.calculateScore(issues, code);
+        const passed = this.config.strictMode
+            ? errorCount === 0 && warningCount === 0
+            : errorCount === 0;
+        // Update stats
+        if (passed) {
+            this.stats.passedCount++;
+        }
+        else {
+            this.stats.failedCount++;
+        }
+        for (const issue of issues) {
+            const count = this.stats.issuesByType.get(issue.type) ?? 0;
+            this.stats.issuesByType.set(issue.type, count + 1);
+        }
+        this.totalScoreSum += score;
+        this.stats.averageScore = this.totalScoreSum / this.stats.totalValidations;
+        this.emit('validated', { passed, issues, score, filePath });
+        return {
+            passed,
+            issues,
+            detectedPattern,
+            detectedLayer,
+            errorCount,
+            warningCount,
+            score
+        };
+    }
+    /**
+     * Detect architectural layer
+     */
+    detectLayer(code, filePath) {
+        for (const [layer, patterns] of Object.entries(LAYER_PATTERNS)) {
+            for (const pattern of patterns) {
+                if (filePath && pattern.test(filePath)) {
+                    return layer;
+                }
+                if (pattern.test(code)) {
+                    return layer;
+                }
+            }
+        }
+        return 'unknown';
+    }
+    /**
+     * Detect architecture pattern
+     */
+    detectPattern(code) {
+        // BLoC Pattern
+        if (code.includes('extends Bloc<') || code.includes('extends Cubit<')) {
+            return 'bloc_pattern';
+        }
+        // Clean Architecture
+        if (code.includes('UseCase') || code.includes('Repository') && code.includes('Entity')) {
+            return 'clean_architecture';
+        }
+        // MVVM
+        if (code.includes('ViewModel') || code.includes('extends ChangeNotifier')) {
+            return 'mvvm';
+        }
+        // Repository Pattern
+        if (code.includes('Repository') && code.includes('DataSource')) {
+            return 'repository_pattern';
+        }
+        return 'unknown';
+    }
+    /**
+     * Check for layer violations
+     */
+    checkLayerViolations(code, layer, issues, filePath) {
+        // Presentation layer should not import data layer directly
+        if (layer === 'presentation') {
+            if (code.includes("import '") && (code.includes('/data/') ||
+                code.includes('/datasources/') ||
+                code.includes('/api/'))) {
+                issues.push({
+                    type: 'improper_layer',
+                    severity: 'error',
+                    line: 1,
+                    column: 1,
+                    code: 'import from data layer',
+                    message: 'Presentation layer should not directly import data layer',
+                    solidPrinciple: 'D',
+                    suggestion: 'Use dependency injection and abstract interfaces'
+                });
+            }
+            // UI should not contain business logic
+            if (code.includes('http.') || code.includes('HttpClient') || code.includes('Dio(')) {
+                issues.push({
+                    type: 'ui_business_mix',
+                    severity: 'error',
+                    line: 1,
+                    column: 1,
+                    code: 'HTTP in UI',
+                    message: 'UI layer should not make HTTP requests directly',
+                    solidPrinciple: 'S',
+                    suggestion: 'Move HTTP logic to data/repository layer'
+                });
+            }
+            // UI should not contain SQL
+            if (code.includes('rawQuery') || code.includes('execute(') && code.includes('INSERT')) {
+                issues.push({
+                    type: 'data_in_ui',
+                    severity: 'error',
+                    line: 1,
+                    column: 1,
+                    code: 'SQL in UI',
+                    message: 'UI layer should not contain database operations',
+                    solidPrinciple: 'S',
+                    suggestion: 'Move database logic to data layer'
+                });
+            }
+        }
+        // Domain layer should not depend on frameworks
+        if (layer === 'domain') {
+            if (code.includes("import 'package:flutter/")) {
+                issues.push({
+                    type: 'improper_layer',
+                    severity: 'warning',
+                    line: 1,
+                    column: 1,
+                    code: 'Flutter import in domain',
+                    message: 'Domain layer should be framework-independent',
+                    solidPrinciple: 'D',
+                    suggestion: 'Keep domain layer pure Dart, no Flutter imports'
+                });
+            }
+        }
+    }
+    /**
+     * Check SOLID principles
+     */
+    checkSOLIDPrinciples(code, issues) {
+        // Single Responsibility - check for classes doing too much
+        const classMatches = code.matchAll(/class\s+(\w+)[^{]*\{/g);
+        for (const match of classMatches) {
+            const className = match[1];
+            const classStart = match.index;
+            const classBody = this.extractClassBody(code, classStart);
+            // Check for mixed concerns
+            const hasUI = /Widget|build\(|setState/g.test(classBody);
+            const hasNetwork = /http\.|HttpClient|Dio|fetch/gi.test(classBody);
+            const hasDatabase = /Database|rawQuery|insert|update|delete/gi.test(classBody);
+            const concernCount = [hasUI, hasNetwork, hasDatabase].filter(Boolean).length;
+            if (concernCount > 1) {
+                issues.push({
+                    type: 'ui_business_mix',
+                    severity: 'warning',
+                    line: this.getLineNumber(code, classStart),
+                    column: 1,
+                    code: className,
+                    message: `Class ${className} has multiple responsibilities`,
+                    solidPrinciple: 'S',
+                    suggestion: 'Split into separate classes for UI, network, and database'
+                });
+            }
+        }
+        // Open/Closed - check for missing abstractions
+        if (code.includes('switch') && code.match(/case\s+['"]?\w+['"]?\s*:/g)?.length > 5) {
+            issues.push({
+                type: 'missing_abstraction',
+                severity: 'info',
+                line: 1,
+                column: 1,
+                code: 'switch with many cases',
+                message: 'Large switch statement may indicate missing abstraction',
+                solidPrinciple: 'O',
+                suggestion: 'Consider using polymorphism or strategy pattern'
+            });
+        }
+        // Dependency Inversion - check for concrete dependencies
+        const concreteDepPattern = /final\s+(?!.*(?:Repository|Service|UseCase|Provider))\w+Impl\s+\w+/g;
+        const concreteMatch = code.match(concreteDepPattern);
+        if (concreteMatch) {
+            issues.push({
+                type: 'hardcoded_dependency',
+                severity: 'warning',
+                line: 1,
+                column: 1,
+                code: concreteMatch[0],
+                message: 'Depending on concrete implementation instead of abstraction',
+                solidPrinciple: 'D',
+                suggestion: 'Depend on abstract interface, inject concrete implementation'
+            });
+        }
+        // Interface Segregation - check for fat interfaces
+        const interfaceMatches = code.matchAll(/abstract\s+class\s+(\w+)\s*\{([^}]+)\}/g);
+        for (const match of interfaceMatches) {
+            const methodCount = (match[2].match(/(?:Future|void|String|int|bool|dynamic)\s+\w+\s*\(/g) || []).length;
+            if (methodCount > 10) {
+                issues.push({
+                    type: 'missing_interface',
+                    severity: 'info',
+                    line: this.getLineNumber(code, match.index),
+                    column: 1,
+                    code: match[1],
+                    message: `Interface ${match[1]} has too many methods (${methodCount})`,
+                    solidPrinciple: 'I',
+                    suggestion: 'Consider splitting into smaller, focused interfaces'
+                });
+            }
+        }
+    }
+    /**
+     * Check naming conventions
+     */
+    checkNamingConventions(code, layer, issues) {
+        // Check class naming
+        const classMatches = code.matchAll(/class\s+(\w+)/g);
+        for (const match of classMatches) {
+            const className = match[1];
+            // Presentation layer naming
+            if (layer === 'presentation') {
+                if (!className.match(/(?:Screen|Page|View|Widget|Controller|Bloc|Cubit)$/)) {
+                    // Check if it extends Widget
+                    if (code.includes(`class ${className} extends`) && code.includes('Widget')) {
+                        issues.push({
+                            type: 'naming_violation',
+                            severity: 'info',
+                            line: this.getLineNumber(code, match.index),
+                            column: 1,
+                            code: className,
+                            message: `Widget class ${className} should have descriptive suffix`,
+                            suggestion: 'Use suffixes like Screen, Page, View, or Widget'
+                        });
+                    }
+                }
+            }
+            // Data layer naming
+            if (layer === 'data') {
+                if (className.includes('Repository') && !className.endsWith('Impl') && !className.startsWith('I')) {
+                    if (!code.includes(`abstract class ${className}`)) {
+                        issues.push({
+                            type: 'naming_violation',
+                            severity: 'info',
+                            line: this.getLineNumber(code, match.index),
+                            column: 1,
+                            code: className,
+                            message: 'Concrete repository should have Impl suffix',
+                            suggestion: `Rename to ${className}Impl or create abstract ${className}`
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Check for god classes
+     */
+    checkGodClasses(code, issues) {
+        const classMatches = code.matchAll(/class\s+(\w+)[^{]*\{/g);
+        for (const match of classMatches) {
+            const className = match[1];
+            const classStart = match.index;
+            const classBody = this.extractClassBody(code, classStart);
+            // Count lines
+            const lines = classBody.split('\n').length;
+            if (lines > this.config.maxClassLines) {
+                issues.push({
+                    type: 'god_class',
+                    severity: 'warning',
+                    line: this.getLineNumber(code, classStart),
+                    column: 1,
+                    code: className,
+                    message: `Class ${className} has ${lines} lines (max: ${this.config.maxClassLines})`,
+                    suggestion: 'Split into smaller, focused classes'
+                });
+            }
+            // Count methods
+            const methodMatches = classBody.match(/(?:void|Future|String|int|bool|dynamic|Widget|\w+)\s+\w+\s*\([^)]*\)\s*(?:async)?\s*\{/g);
+            const methodCount = methodMatches?.length ?? 0;
+            if (methodCount > this.config.maxClassMethods) {
+                issues.push({
+                    type: 'god_class',
+                    severity: 'warning',
+                    line: this.getLineNumber(code, classStart),
+                    column: 1,
+                    code: className,
+                    message: `Class ${className} has ${methodCount} methods (max: ${this.config.maxClassMethods})`,
+                    suggestion: 'Extract related methods into separate classes'
+                });
+            }
+        }
+        // Check method parameters
+        const methodParamMatches = code.matchAll(/(?:void|Future|String|int|bool|dynamic|Widget|\w+)\s+(\w+)\s*\(([^)]+)\)/g);
+        for (const match of methodParamMatches) {
+            const methodName = match[1];
+            const params = match[2].split(',').filter(p => p.trim().length > 0);
+            if (params.length > this.config.maxMethodParams) {
+                issues.push({
+                    type: 'cohesion_issue',
+                    severity: 'info',
+                    line: this.getLineNumber(code, match.index),
+                    column: 1,
+                    code: methodName,
+                    message: `Method ${methodName} has ${params.length} parameters (max: ${this.config.maxMethodParams})`,
+                    suggestion: 'Consider using a parameter object or builder pattern'
+                });
+            }
+        }
+    }
+    /**
+     * Check for architecture anti-patterns
+     */
+    checkAntiPatterns(code, issues) {
+        // Check for hardcoded URLs/endpoints
+        if (code.match(/['"]https?:\/\/[^'"]+['"]/g)) {
+            issues.push({
+                type: 'hardcoded_dependency',
+                severity: 'info',
+                line: 1,
+                column: 1,
+                code: 'hardcoded URL',
+                message: 'Hardcoded URLs should be in configuration',
+                suggestion: 'Move URLs to environment config or constants file'
+            });
+        }
+        // Check for direct SharedPreferences usage in business logic
+        if (code.includes('SharedPreferences') && !code.includes('Repository') && !code.includes('DataSource')) {
+            issues.push({
+                type: 'data_in_ui',
+                severity: 'warning',
+                line: 1,
+                column: 1,
+                code: 'SharedPreferences',
+                message: 'Direct storage access should be in data layer',
+                suggestion: 'Wrap SharedPreferences in a repository/service'
+            });
+        }
+        // Check for service locator anti-pattern (GetIt direct usage in widgets)
+        if (code.includes('GetIt.instance') && code.includes('extends') && code.includes('Widget')) {
+            issues.push({
+                type: 'hardcoded_dependency',
+                severity: 'info',
+                line: 1,
+                column: 1,
+                code: 'GetIt in Widget',
+                message: 'Direct service locator usage in widgets reduces testability',
+                suggestion: 'Inject dependencies through constructor or use Provider'
+            });
+        }
+    }
+    /**
+     * Extract class body
+     */
+    extractClassBody(code, startIndex) {
+        let depth = 0;
+        let started = false;
+        let end = startIndex;
+        for (let i = startIndex; i < code.length; i++) {
+            if (code[i] === '{') {
+                depth++;
+                started = true;
+            }
+            else if (code[i] === '}') {
+                depth--;
+                if (started && depth === 0) {
+                    end = i;
+                    break;
+                }
+            }
+        }
+        return code.substring(startIndex, end + 1);
+    }
+    /**
+     * Get line number from position
+     */
+    getLineNumber(code, index) {
+        return code.substring(0, index).split('\n').length;
+    }
+    /**
+     * Calculate score
+     */
+    calculateScore(issues, code) {
+        let score = 100;
+        for (const issue of issues) {
+            switch (issue.severity) {
+                case 'error':
+                    score -= 15;
+                    break;
+                case 'warning':
+                    score -= 7;
+                    break;
+                case 'info':
+                    score -= 2;
+                    break;
+            }
+        }
+        // Bonus for good practices
+        if (code.includes('abstract class'))
+            score += 3;
+        if (code.includes('implements'))
+            score += 2;
+        if (code.includes('@override'))
+            score += 1;
+        if (code.includes('factory'))
+            score += 2;
+        return Math.max(0, Math.min(100, score));
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            issuesByType: new Map(this.stats.issuesByType),
+            filesByLayer: new Map(this.stats.filesByLayer)
+        };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalValidations: 0,
+            passedCount: 0,
+            failedCount: 0,
+            issuesByType: new Map(),
+            filesByLayer: new Map(),
+            averageScore: 100
+        };
+        this.totalScoreSum = 0;
+    }
+    /**
+     * Get health status
+     */
+    getHealth() {
+        const passRate = this.stats.totalValidations > 0
+            ? this.stats.passedCount / this.stats.totalValidations
+            : 1;
+        return {
+            healthy: passRate >= 0.5,
+            message: `Pass rate: ${(passRate * 100).toFixed(1)}%, Avg score: ${this.stats.averageScore.toFixed(1)}`
+        };
+    }
+}
+export default ArchitectureGate;
+//# sourceMappingURL=ArchitectureGate.js.map