driftdetect-detectors 0.2.1 → 0.3.0

package/dist/api/laravel/api-semantic.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Laravel API Patterns Detector - SEMANTIC VERSION
+ *
+ * Learns API patterns from your Laravel codebase:
+ * - Controller patterns (resource, invokable, API)
+ * - Route patterns (RESTful, API versioning)
+ * - Response patterns (JSON, Resources, Collections)
+ * - Request handling patterns
+ */
+import type { Violation, Language } from 'driftdetect-core';
+import { SemanticDetector, type SemanticMatch, type UsagePattern } from '../../base/semantic-detector.js';
+export declare class LaravelAPISemanticDetector extends SemanticDetector {
+    readonly id = "api/laravel-api-semantic";
+    readonly name = "Laravel API Patterns Detector";
+    readonly description = "Learns API patterns from your Laravel codebase";
+    readonly category: "api";
+    readonly subcategory = "laravel";
+    readonly supportedLanguages: Language[];
+    constructor();
+    protected getSemanticKeywords(): string[];
+    protected getSemanticCategory(): string;
+    protected isRelevantMatch(match: SemanticMatch): boolean;
+    protected createPatternViolation(match: SemanticMatch, dominantPattern: UsagePattern): Violation;
+}
+export declare function createLaravelAPISemanticDetector(): LaravelAPISemanticDetector;
+//# sourceMappingURL=api-semantic.d.ts.map

package/dist/api/laravel/api-semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-semantic.d.ts","sourceRoot":"","sources":["../../../src/api/laravel/api-semantic.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EACL,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,iCAAiC,CAAC;AAezC,qBAAa,0BAA2B,SAAQ,gBAAgB;IAC9D,QAAQ,CAAC,EAAE,8BAA8B;IACzC,QAAQ,CAAC,IAAI,mCAAmC;IAChD,QAAQ,CAAC,WAAW,oDAAoD;IACxE,QAAQ,CAAC,QAAQ,EAAG,KAAK,CAAU;IACnC,QAAQ,CAAC,WAAW,aAAa;IAEjC,SAAkB,kBAAkB,EAAE,QAAQ,EAAE,CAAW;;IAY3D,SAAS,CAAC,mBAAmB,IAAI,MAAM,EAAE;IAkCzC,SAAS,CAAC,mBAAmB,IAAI,MAAM;cAKpB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO;IA6BjE,SAAS,CAAC,sBAAsB,CAC9B,KAAK,EAAE,aAAa,EACpB,eAAe,EAAE,YAAY,GAC5B,SAAS;CAoBb;AAED,wBAAgB,gCAAgC,IAAI,0BAA0B,CAE7E"}

package/dist/api/laravel/api-semantic.js

@@ -0,0 +1,115 @@
+/**
+ * Laravel API Patterns Detector - SEMANTIC VERSION
+ *
+ * Learns API patterns from your Laravel codebase:
+ * - Controller patterns (resource, invokable, API)
+ * - Route patterns (RESTful, API versioning)
+ * - Response patterns (JSON, Resources, Collections)
+ * - Request handling patterns
+ */
+import { SemanticDetector, } from '../../base/semantic-detector.js';
+const API_FILE_PATTERNS = [
+    /controllers\//i, /routes\//i, /resources\//i,
+    /api\.php$/i, /requests\//i,
+];
+const API_CONTEXT_KEYWORDS = [
+    'illuminate\\routing', 'illuminate\\http',
+    'route::', 'response()', 'request()',
+    'jsonresource', 'resourcecollection',
+    'apiresource', 'controller',
+];
+export class LaravelAPISemanticDetector extends SemanticDetector {
+    id = 'api/laravel-api-semantic';
+    name = 'Laravel API Patterns Detector';
+    description = 'Learns API patterns from your Laravel codebase';
+    category = 'api';
+    subcategory = 'laravel';
+    supportedLanguages = ['php'];
+    constructor() {
+        super({
+            minOccurrences: 2,
+            dominanceThreshold: 0.3,
+            minFiles: 1,
+            includeComments: false,
+            includeStrings: false,
+        });
+    }
+    getSemanticKeywords() {
+        return [
+            // Controllers
+            'Controller', 'ResourceController', 'ApiController',
+            'index', 'show', 'store', 'update', 'destroy',
+            '__invoke', 'callAction',
+            // Routes
+            'Route', 'get', 'post', 'put', 'patch', 'delete', 'options',
+            'resource', 'apiResource', 'singleton',
+            'prefix', 'middleware', 'name', 'group',
+            'where', 'whereNumber', 'whereAlpha', 'whereUuid',
+            // Responses
+            'response', 'json', 'jsonResponse', 'download', 'file', 'redirect',
+            'JsonResource', 'ResourceCollection', 'AnonymousResourceCollection',
+            'toArray', 'with', 'additional', 'wrap',
+            // Requests
+            'Request', 'FormRequest', 'input', 'query', 'all', 'only', 'except',
+            'validated', 'validate', 'rules', 'authorize',
+            'has', 'filled', 'missing', 'whenHas', 'whenFilled',
+            // API versioning
+            'v1', 'v2', 'api', 'version',
+            // Rate limiting
+            'throttle', 'RateLimiter',
+            // Sanctum/Passport
+            'sanctum', 'passport', 'token', 'abilities',
+        ];
+    }
+    getSemanticCategory() {
+        return 'api';
+    }
+    isRelevantMatch(match) {
+        const { file, lineContent, surroundingContext, keyword } = match;
+        const contextLower = surroundingContext.toLowerCase();
+        const highConfidenceKeywords = [
+            'Controller', 'Route', 'JsonResource', 'ResourceCollection',
+            'FormRequest', 'apiResource', 'sanctum', 'passport',
+        ];
+        if (highConfidenceKeywords.includes(keyword)) {
+            return true;
+        }
+        if (/^\s*\/\//.test(lineContent) || /^\s*\/\*/.test(lineContent)) {
+            return false;
+        }
+        const ambiguousKeywords = ['get', 'post', 'put', 'delete', 'index', 'show', 'store', 'update'];
+        if (ambiguousKeywords.includes(keyword.toLowerCase())) {
+            const hasContext = API_CONTEXT_KEYWORDS.some(k => contextLower.includes(k));
+            if (!hasContext) {
+                const inApiFile = API_FILE_PATTERNS.some(p => p.test(file));
+                if (!inApiFile)
+                    return false;
+            }
+        }
+        return true;
+    }
+    createPatternViolation(match, dominantPattern) {
+        return {
+            id: `${this.id}-${match.file}-${match.line}-${match.column}`,
+            patternId: this.id,
+            severity: 'warning',
+            file: match.file,
+            range: {
+                start: { line: match.line - 1, character: match.column - 1 },
+                end: { line: match.line - 1, character: match.column + match.matchedText.length - 1 },
+            },
+            message: `Inconsistent API pattern: using '${match.contextType}' but project primarily uses '${dominantPattern.contextType}'`,
+            expected: dominantPattern.contextType,
+            actual: match.contextType,
+            explanation: `Your Laravel project uses '${dominantPattern.contextType}' for API patterns in ${dominantPattern.percentage.toFixed(0)}% of cases.`,
+            aiExplainAvailable: true,
+            aiFixAvailable: true,
+            firstSeen: new Date(),
+            occurrences: 1,
+        };
+    }
+}
+export function createLaravelAPISemanticDetector() {
+    return new LaravelAPISemanticDetector();
+}
+//# sourceMappingURL=api-semantic.js.map

package/dist/api/laravel/api-semantic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-semantic.js","sourceRoot":"","sources":["../../../src/api/laravel/api-semantic.ts"],"names":[],"mappings":"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"}

package/dist/async/laravel/async-semantic.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Laravel Async Patterns Detector - SEMANTIC VERSION
+ *
+ * Learns async patterns from your Laravel codebase:
+ * - Job patterns (dispatch, queues)
+ * - Event patterns (listeners, subscribers)
+ * - Broadcasting patterns
+ * - Scheduled tasks
+ */
+import type { Violation, Language } from 'driftdetect-core';
+import { SemanticDetector, type SemanticMatch, type UsagePattern } from '../../base/semantic-detector.js';
+export declare class LaravelAsyncSemanticDetector extends SemanticDetector {
+    readonly id = "async/laravel-async-semantic";
+    readonly name = "Laravel Async Patterns Detector";
+    readonly description = "Learns async patterns (jobs, events, queues) from your Laravel codebase";
+    readonly category: "performance";
+    readonly subcategory = "laravel";
+    readonly supportedLanguages: Language[];
+    constructor();
+    protected getSemanticKeywords(): string[];
+    protected getSemanticCategory(): string;
+    protected isRelevantMatch(match: SemanticMatch): boolean;
+    protected createPatternViolation(match: SemanticMatch, dominantPattern: UsagePattern): Violation;
+}
+export declare function createLaravelAsyncSemanticDetector(): LaravelAsyncSemanticDetector;
+//# sourceMappingURL=async-semantic.d.ts.map

package/dist/async/laravel/async-semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-semantic.d.ts","sourceRoot":"","sources":["../../../src/async/laravel/async-semantic.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EACL,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,iCAAiC,CAAC;AAiBzC,qBAAa,4BAA6B,SAAQ,gBAAgB;IAChE,QAAQ,CAAC,EAAE,kCAAkC;IAC7C,QAAQ,CAAC,IAAI,qCAAqC;IAClD,QAAQ,CAAC,WAAW,6EAA6E;IACjG,QAAQ,CAAC,QAAQ,EAAG,aAAa,CAAU;IAC3C,QAAQ,CAAC,WAAW,aAAa;IAEjC,SAAkB,kBAAkB,EAAE,QAAQ,EAAE,CAAW;;IAY3D,SAAS,CAAC,mBAAmB,IAAI,MAAM,EAAE;IAiCzC,SAAS,CAAC,mBAAmB,IAAI,MAAM;cAKpB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO;IA8BjE,SAAS,CAAC,sBAAsB,CAC9B,KAAK,EAAE,aAAa,EACpB,eAAe,EAAE,YAAY,GAC5B,SAAS;CAoBb;AAED,wBAAgB,kCAAkC,IAAI,4BAA4B,CAEjF"}

package/dist/async/laravel/async-semantic.js

@@ -0,0 +1,118 @@
+/**
+ * Laravel Async Patterns Detector - SEMANTIC VERSION
+ *
+ * Learns async patterns from your Laravel codebase:
+ * - Job patterns (dispatch, queues)
+ * - Event patterns (listeners, subscribers)
+ * - Broadcasting patterns
+ * - Scheduled tasks
+ */
+import { SemanticDetector, } from '../../base/semantic-detector.js';
+const ASYNC_FILE_PATTERNS = [
+    /jobs\//i, /events\//i, /listeners\//i,
+    /subscribers\//i, /broadcasting\//i,
+    /console\/kernel/i,
+];
+const ASYNC_CONTEXT_KEYWORDS = [
+    'illuminate\\contracts\\queue',
+    'illuminate\\bus\\queueable',
+    'illuminate\\queue\\interactswithqueue',
+    'shouldqueue', 'dispatchable', 'queueable',
+    'dispatch(', 'event(', 'broadcast(',
+];
+export class LaravelAsyncSemanticDetector extends SemanticDetector {
+    id = 'async/laravel-async-semantic';
+    name = 'Laravel Async Patterns Detector';
+    description = 'Learns async patterns (jobs, events, queues) from your Laravel codebase';
+    category = 'performance';
+    subcategory = 'laravel';
+    supportedLanguages = ['php'];
+    constructor() {
+        super({
+            minOccurrences: 2,
+            dominanceThreshold: 0.3,
+            minFiles: 1,
+            includeComments: false,
+            includeStrings: false,
+        });
+    }
+    getSemanticKeywords() {
+        return [
+            // Jobs
+            'Job', 'ShouldQueue', 'Dispatchable', 'Queueable', 'InteractsWithQueue',
+            'SerializesModels', 'dispatch', 'dispatchSync', 'dispatchNow',
+            'dispatchAfterResponse', 'handle', 'failed', 'retryUntil',
+            'tries', 'timeout', 'backoff', 'maxExceptions',
+            'onQueue', 'onConnection', 'delay', 'afterCommit',
+            // Batches
+            'Bus', 'batch', 'chain', 'Batch', 'PendingBatch',
+            'allowFailures', 'then', 'catch', 'finally',
+            // Events
+            'Event', 'event', 'Listener', 'listen', 'subscribe',
+            'ShouldBroadcast', 'ShouldBroadcastNow', 'broadcastOn',
+            'broadcastAs', 'broadcastWith', 'broadcastWhen',
+            // Broadcasting
+            'broadcast', 'Channel', 'PrivateChannel', 'PresenceChannel',
+            'Pusher', 'Echo', 'whisper', 'here', 'joining', 'leaving',
+            // Scheduling
+            'schedule', 'command', 'call', 'job', 'exec',
+            'everyMinute', 'hourly', 'daily', 'weekly', 'monthly',
+            'cron', 'timezone', 'withoutOverlapping', 'runInBackground',
+            // Notifications
+            'Notification', 'notify', 'notifyNow', 'Notifiable',
+            'via', 'toMail', 'toDatabase', 'toArray', 'toBroadcast',
+        ];
+    }
+    getSemanticCategory() {
+        return 'async';
+    }
+    isRelevantMatch(match) {
+        const { file, lineContent, surroundingContext, keyword } = match;
+        const contextLower = surroundingContext.toLowerCase();
+        const highConfidenceKeywords = [
+            'Job', 'ShouldQueue', 'Dispatchable', 'dispatch',
+            'Event', 'Listener', 'ShouldBroadcast', 'broadcast',
+            'Notification', 'schedule', 'Bus', 'batch',
+        ];
+        if (highConfidenceKeywords.includes(keyword)) {
+            return true;
+        }
+        if (/^\s*\/\//.test(lineContent) || /^\s*\/\*/.test(lineContent)) {
+            return false;
+        }
+        const ambiguousKeywords = ['handle', 'event', 'listen', 'call', 'job'];
+        if (ambiguousKeywords.includes(keyword.toLowerCase())) {
+            const hasContext = ASYNC_CONTEXT_KEYWORDS.some(k => contextLower.includes(k));
+            if (!hasContext) {
+                const inAsyncFile = ASYNC_FILE_PATTERNS.some(p => p.test(file));
+                if (!inAsyncFile)
+                    return false;
+            }
+        }
+        return true;
+    }
+    createPatternViolation(match, dominantPattern) {
+        return {
+            id: `${this.id}-${match.file}-${match.line}-${match.column}`,
+            patternId: this.id,
+            severity: 'warning',
+            file: match.file,
+            range: {
+                start: { line: match.line - 1, character: match.column - 1 },
+                end: { line: match.line - 1, character: match.column + match.matchedText.length - 1 },
+            },
+            message: `Inconsistent async pattern: using '${match.contextType}' but project primarily uses '${dominantPattern.contextType}'`,
+            expected: dominantPattern.contextType,
+            actual: match.contextType,
+            explanation: `Your Laravel project uses '${dominantPattern.contextType}' for async patterns in ${dominantPattern.percentage.toFixed(0)}% of cases.`,
+            aiExplainAvailable: true,
+            aiFixAvailable: true,
+            firstSeen: new Date(),
+            occurrences: 1,
+        };
+    }
+}
+export function createLaravelAsyncSemanticDetector() {
+    return new LaravelAsyncSemanticDetector();
+}
+//# sourceMappingURL=async-semantic.js.map

package/dist/async/laravel/async-semantic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-semantic.js","sourceRoot":"","sources":["../../../src/async/laravel/async-semantic.ts"],"names":[],"mappings":"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"}

package/dist/auth/aspnet/authorize-attribute-detector.d.ts

@@ -0,0 +1,82 @@
+/**
+ * ASP.NET Core Authorize Attribute Detector
+ *
+ * Detects authorization patterns in ASP.NET Core applications:
+ * - [Authorize] attribute usage
+ * - [Authorize(Roles = "...")] role-based authorization
+ * - [Authorize(Policy = "...")] policy-based authorization
+ * - [AllowAnonymous] exceptions
+ * - Authorization at controller vs action level
+ */
+import type { Language } from 'driftdetect-core';
+import type { DetectionContext, DetectionResult } from '../../base/base-detector.js';
+import { BaseDetector } from '../../base/base-detector.js';
+export interface AuthorizeAttributeInfo {
+    /** Type of authorization */
+    type: 'authorize' | 'allow-anonymous' | 'authorize-roles' | 'authorize-policy';
+    /** Roles if specified */
+    roles: string[];
+    /** Policy name if specified */
+    policy: string | null;
+    /** Authentication schemes if specified */
+    authenticationSchemes: string[];
+    /** Whether this is at controller level */
+    isControllerLevel: boolean;
+    /** The target (controller name or action name) */
+    target: string;
+    /** Line number */
+    line: number;
+    /** File path */
+    file: string;
+}
+export interface AuthorizationAnalysis {
+    /** All authorization attributes found */
+    attributes: AuthorizeAttributeInfo[];
+    /** Controllers with authorization */
+    authorizedControllers: string[];
+    /** Actions with authorization */
+    authorizedActions: string[];
+    /** Actions with AllowAnonymous */
+    anonymousActions: string[];
+    /** Unique roles used */
+    roles: string[];
+    /** Unique policies used */
+    policies: string[];
+    /** Whether authorization is consistent */
+    isConsistent: boolean;
+    /** Confidence score */
+    confidence: number;
+}
+export declare class AuthorizeAttributeDetector extends BaseDetector {
+    readonly id = "auth/aspnet-authorize-attribute";
+    readonly category: "auth";
+    readonly subcategory = "authorization";
+    readonly name = "ASP.NET Authorize Attribute Detector";
+    readonly description = "Detects [Authorize] and [AllowAnonymous] attribute patterns in ASP.NET Core";
+    readonly supportedLanguages: Language[];
+    readonly detectionMethod: "regex";
+    detect(context: DetectionContext): Promise<DetectionResult>;
+    /**
+     * Check if file is relevant for authorization detection
+     */
+    private isRelevantFile;
+    /**
+     * Analyze authorization patterns in the file
+     */
+    analyzeAuthorization(content: string, file: string): AuthorizationAnalysis;
+    /**
+     * Parse [Authorize(...)] arguments
+     */
+    private parseAuthorizeArgs;
+    /**
+     * Check if authorization patterns are consistent
+     */
+    private checkConsistency;
+    /**
+     * Detect potential authorization violations
+     */
+    private detectViolations;
+    generateQuickFix(): null;
+}
+export declare function createAuthorizeAttributeDetector(): AuthorizeAttributeDetector;
+//# sourceMappingURL=authorize-attribute-detector.d.ts.map

package/dist/auth/aspnet/authorize-attribute-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorize-attribute-detector.d.ts","sourceRoot":"","sources":["../../../src/auth/aspnet/authorize-attribute-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAA2B,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACrF,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAM3D,MAAM,WAAW,sBAAsB;IACrC,4BAA4B;IAC5B,IAAI,EAAE,WAAW,GAAG,iBAAiB,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;IAC/E,yBAAyB;IACzB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,+BAA+B;IAC/B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,0CAA0C;IAC1C,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,0CAA0C;IAC1C,iBAAiB,EAAE,OAAO,CAAC;IAC3B,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,UAAU,EAAE,sBAAsB,EAAE,CAAC;IACrC,qCAAqC;IACrC,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,iCAAiC;IACjC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,kCAAkC;IAClC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,wBAAwB;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,2BAA2B;IAC3B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,0CAA0C;IAC1C,YAAY,EAAE,OAAO,CAAC;IACtB,uBAAuB;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AAMD,qBAAa,0BAA2B,SAAQ,YAAY;IAC1D,QAAQ,CAAC,EAAE,qCAAqC;IAChD,QAAQ,CAAC,QAAQ,EAAG,MAAM,CAAU;IACpC,QAAQ,CAAC,WAAW,mBAAmB;IACvC,QAAQ,CAAC,IAAI,0CAA0C;IACvD,QAAQ,CAAC,WAAW,iFAAiF;IACrG,QAAQ,CAAC,kBAAkB,EAAE,QAAQ,EAAE,CAAc;IACrD,QAAQ,CAAC,eAAe,EAAG,OAAO,CAAU;IAEtC,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAoCjE;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,qBAAqB;IAoH1E;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA4B1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAkBxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA4CxB,gBAAgB,IAAI,IAAI;CAGzB;AAED,wBAAgB,gCAAgC,IAAI,0BAA0B,CAE7E"}

package/dist/auth/aspnet/authorize-attribute-detector.js

@@ -0,0 +1,261 @@
+/**
+ * ASP.NET Core Authorize Attribute Detector
+ *
+ * Detects authorization patterns in ASP.NET Core applications:
+ * - [Authorize] attribute usage
+ * - [Authorize(Roles = "...")] role-based authorization
+ * - [Authorize(Policy = "...")] policy-based authorization
+ * - [AllowAnonymous] exceptions
+ * - Authorization at controller vs action level
+ */
+import { BaseDetector } from '../../base/base-detector.js';
+// ============================================================================
+// Detector Implementation
+// ============================================================================
+export class AuthorizeAttributeDetector extends BaseDetector {
+    id = 'auth/aspnet-authorize-attribute';
+    category = 'auth';
+    subcategory = 'authorization';
+    name = 'ASP.NET Authorize Attribute Detector';
+    description = 'Detects [Authorize] and [AllowAnonymous] attribute patterns in ASP.NET Core';
+    supportedLanguages = ['csharp'];
+    detectionMethod = 'regex';
+    async detect(context) {
+        const { content, file } = context;
+        // Only process C# files that look like controllers or have auth attributes
+        if (!this.isRelevantFile(content)) {
+            return this.createEmptyResult();
+        }
+        const analysis = this.analyzeAuthorization(content, file);
+        const patterns = [];
+        const violations = [];
+        // Create pattern matches for each authorization attribute
+        for (const attr of analysis.attributes) {
+            patterns.push({
+                patternId: `${this.id}/${attr.type}`,
+                location: {
+                    file: attr.file,
+                    line: attr.line,
+                    column: 1,
+                },
+                confidence: analysis.confidence,
+                isOutlier: false,
+            });
+        }
+        // Check for potential issues
+        violations.push(...this.detectViolations(analysis, file));
+        return this.createResult(patterns, violations, analysis.confidence, {
+            custom: {
+                authorizationAnalysis: analysis,
+            },
+        });
+    }
+    /**
+     * Check if file is relevant for authorization detection
+     */
+    isRelevantFile(content) {
+        return (content.includes('[Authorize') ||
+            content.includes('[AllowAnonymous]') ||
+            content.includes('ControllerBase') ||
+            content.includes(': Controller'));
+    }
+    /**
+     * Analyze authorization patterns in the file
+     */
+    analyzeAuthorization(content, file) {
+        const attributes = [];
+        const authorizedControllers = [];
+        const authorizedActions = [];
+        const anonymousActions = [];
+        const roles = new Set();
+        const policies = new Set();
+        const lines = content.split('\n');
+        let currentController = null;
+        let pendingAttributes = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i] || '';
+            const lineNum = i + 1;
+            // Detect [Authorize] attributes
+            const authorizeMatch = line.match(/\[Authorize(?:\s*\(([^)]*)\))?\]/);
+            if (authorizeMatch) {
+                const args = authorizeMatch[1] || '';
+                const attrInfo = this.parseAuthorizeArgs(args);
+                // Add roles and policies to sets
+                attrInfo.roles.forEach(r => roles.add(r));
+                if (attrInfo.policy)
+                    policies.add(attrInfo.policy);
+                pendingAttributes.push({
+                    type: attrInfo.roles.length > 0 ? 'authorize-roles' :
+                        attrInfo.policy ? 'authorize-policy' : 'authorize',
+                    roles: attrInfo.roles,
+                    policy: attrInfo.policy,
+                    schemes: attrInfo.schemes,
+                    line: lineNum,
+                });
+            }
+            // Detect [AllowAnonymous]
+            if (line.includes('[AllowAnonymous]')) {
+                pendingAttributes.push({
+                    type: 'allow-anonymous',
+                    roles: [],
+                    policy: null,
+                    schemes: [],
+                    line: lineNum,
+                });
+            }
+            // Detect controller class
+            const controllerMatch = line.match(/public\s+class\s+(\w+Controller)\s*:/);
+            if (controllerMatch && controllerMatch[1]) {
+                currentController = controllerMatch[1];
+                // Apply pending attributes to controller
+                for (const attr of pendingAttributes) {
+                    attributes.push({
+                        type: attr.type,
+                        roles: attr.roles,
+                        policy: attr.policy,
+                        authenticationSchemes: attr.schemes,
+                        isControllerLevel: true,
+                        target: currentController,
+                        line: attr.line,
+                        file,
+                    });
+                    if (attr.type !== 'allow-anonymous') {
+                        authorizedControllers.push(currentController);
+                    }
+                }
+                pendingAttributes = [];
+            }
+            // Detect action methods
+            const actionMatch = line.match(/public\s+(?:async\s+)?(?:Task<)?(?:ActionResult|IActionResult|[\w<>]+)\s+(\w+)\s*\(/);
+            if (actionMatch && actionMatch[1] && currentController) {
+                const actionName = actionMatch[1];
+                // Apply pending attributes to action
+                for (const attr of pendingAttributes) {
+                    attributes.push({
+                        type: attr.type,
+                        roles: attr.roles,
+                        policy: attr.policy,
+                        authenticationSchemes: attr.schemes,
+                        isControllerLevel: false,
+                        target: actionName,
+                        line: attr.line,
+                        file,
+                    });
+                    if (attr.type === 'allow-anonymous') {
+                        anonymousActions.push(`${currentController}.${actionName}`);
+                    }
+                    else {
+                        authorizedActions.push(`${currentController}.${actionName}`);
+                    }
+                }
+                pendingAttributes = [];
+            }
+        }
+        // Calculate consistency
+        const isConsistent = this.checkConsistency(attributes);
+        const confidence = attributes.length > 0 ? 0.9 : 0;
+        return {
+            attributes,
+            authorizedControllers: [...new Set(authorizedControllers)],
+            authorizedActions: [...new Set(authorizedActions)],
+            anonymousActions: [...new Set(anonymousActions)],
+            roles: Array.from(roles),
+            policies: Array.from(policies),
+            isConsistent,
+            confidence,
+        };
+    }
+    /**
+     * Parse [Authorize(...)] arguments
+     */
+    parseAuthorizeArgs(args) {
+        const roles = [];
+        let policy = null;
+        const schemes = [];
+        if (!args)
+            return { roles, policy, schemes };
+        // Extract Roles
+        const rolesMatch = args.match(/Roles\s*=\s*["']([^"']+)["']/);
+        if (rolesMatch && rolesMatch[1]) {
+            roles.push(...rolesMatch[1].split(',').map(r => r.trim()));
+        }
+        // Extract Policy
+        const policyMatch = args.match(/Policy\s*=\s*["']([^"']+)["']/);
+        if (policyMatch && policyMatch[1]) {
+            policy = policyMatch[1];
+        }
+        // Extract AuthenticationSchemes
+        const schemesMatch = args.match(/AuthenticationSchemes\s*=\s*["']([^"']+)["']/);
+        if (schemesMatch && schemesMatch[1]) {
+            schemes.push(...schemesMatch[1].split(',').map(s => s.trim()));
+        }
+        return { roles, policy, schemes };
+    }
+    /**
+     * Check if authorization patterns are consistent
+     */
+    checkConsistency(attributes) {
+        if (attributes.length < 2)
+            return true;
+        // Check if mixing roles and policies inconsistently
+        const hasRoles = attributes.some(a => a.roles.length > 0);
+        const hasPolicies = attributes.some(a => a.policy !== null);
+        // Mixing roles and policies is fine in ASP.NET Core
+        // Consider inconsistent only if there's a clear anti-pattern
+        // For now, having both is acceptable
+        if (hasRoles && hasPolicies) {
+            // Both approaches used - this is actually fine in ASP.NET Core
+            return true;
+        }
+        return true;
+    }
+    /**
+     * Detect potential authorization violations
+     */
+    detectViolations(analysis, file) {
+        const violations = [];
+        // Check for controllers without any authorization
+        const controllerAttrs = analysis.attributes.filter(a => a.isControllerLevel);
+        const actionAttrs = analysis.attributes.filter(a => !a.isControllerLevel);
+        // If some actions have auth but controller doesn't, might be inconsistent
+        if (controllerAttrs.length === 0 && actionAttrs.length > 0) {
+            // Check if all actions have auth or if some are missing
+            // This is informational, not necessarily a violation
+        }
+        // Check for [AllowAnonymous] on sensitive-looking endpoints
+        for (const attr of analysis.attributes) {
+            if (attr.type === 'allow-anonymous') {
+                const target = attr.target.toLowerCase();
+                if (target.includes('admin') || target.includes('delete') || target.includes('update')) {
+                    violations.push({
+                        id: `${this.id}-${file}-${attr.line}-sensitive-anonymous`,
+                        patternId: this.id,
+                        severity: 'warning',
+                        file,
+                        range: {
+                            start: { line: attr.line - 1, character: 0 },
+                            end: { line: attr.line - 1, character: 100 },
+                        },
+                        message: `[AllowAnonymous] on potentially sensitive endpoint: ${attr.target}`,
+                        expected: '[Authorize]',
+                        actual: '[AllowAnonymous]',
+                        explanation: `The endpoint '${attr.target}' appears to be sensitive based on its name, ` +
+                            `but is marked as [AllowAnonymous]. Consider if this is intentional.`,
+                        aiExplainAvailable: true,
+                        aiFixAvailable: false,
+                        firstSeen: new Date(),
+                        occurrences: 1,
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    generateQuickFix() {
+        return null;
+    }
+}
+export function createAuthorizeAttributeDetector() {
+    return new AuthorizeAttributeDetector();
+}
+//# sourceMappingURL=authorize-attribute-detector.js.map