@opencodereview/core 1.9.1

package/dist/detectors/v4/index.js

@@ -0,0 +1,40 @@
+/**
+ * V4 Detector Module — AI-unique detectors operating on CodeUnit IR.
+ *
+ * V4 keeps only detectors that target AI-specific code quality issues:
+ * - HallucinatedImportDetector: Detects imports of non-existent packages
+ * - StaleAPIDetector: Detects deprecated/outdated API usage
+ * - ContextCoherenceDetector: Detects AI context window inconsistencies
+ * - OverEngineeringDetector: Detects over-engineered code patterns
+ * - SecurityPatternDetector: Detects security anti-patterns common in AI code
+ *
+ * Traditional lint concerns (duplication, type safety) are excluded.
+ *
+ * @since 0.4.0
+ */
+// Detectors
+export { HallucinatedImportDetector } from './hallucinated-import.js';
+export { StaleAPIDetector } from './stale-api.js';
+export { ContextCoherenceDetector } from './context-coherence.js';
+export { OverEngineeringDetector } from './over-engineering.js';
+export { SecurityPatternDetector } from './security-pattern.js';
+import { HallucinatedImportDetector } from './hallucinated-import.js';
+import { StaleAPIDetector } from './stale-api.js';
+import { ContextCoherenceDetector } from './context-coherence.js';
+import { OverEngineeringDetector } from './over-engineering.js';
+import { SecurityPatternDetector } from './security-pattern.js';
+/**
+ * Create all V4 detectors with default configuration.
+ *
+ * @returns Array of all V4 detector instances
+ */
+export function createV4Detectors() {
+    return [
+        new HallucinatedImportDetector(),
+        new StaleAPIDetector(),
+        new ContextCoherenceDetector(),
+        new OverEngineeringDetector(),
+        new SecurityPatternDetector(),
+    ];
+}
+//# sourceMappingURL=index.js.map

package/dist/detectors/v4/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/detectors/v4/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,YAAY;AACZ,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAKhE,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE;;;;GAIG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO;QACL,IAAI,0BAA0B,EAAE;QAChC,IAAI,gBAAgB,EAAE;QACtB,IAAI,wBAAwB,EAAE;QAC9B,IAAI,uBAAuB,EAAE;QAC7B,IAAI,uBAAuB,EAAE;KAC9B,CAAC;AACJ,CAAC"}

package/dist/detectors/v4/over-engineering.d.ts

@@ -0,0 +1,69 @@
+/**
+ * OverEngineeringDetector — V4 detector for over-engineered AI-generated code.
+ *
+ * AI models love generating unnecessarily complex code: excessive abstraction,
+ * design pattern abuse, deep nesting, and bloated function signatures.
+ * This detector catches these patterns using CodeUnit complexity metrics.
+ *
+ * V4 improvements over V3:
+ * - Uses pre-computed ComplexityMetrics from CodeUnit IR
+ * - Configurable thresholds via DetectorContext
+ * - Structural analysis using definitions instead of regex
+ *
+ * @since 0.4.0
+ */
+import type { CodeUnit, SupportedLanguage } from '../../ir/types.js';
+import type { V4Detector, DetectorResult, DetectorCategory, DetectorContext } from './types.js';
+/** Configurable thresholds for over-engineering detection. */
+export interface OverEngineeringThresholds {
+    maxParams: number;
+    maxNesting: number;
+    maxFunctionLOC: number;
+    maxCyclomaticComplexity: number;
+}
+export declare class OverEngineeringDetector implements V4Detector {
+    readonly id = "over-engineering";
+    readonly name = "Over-engineering Detector";
+    readonly category: DetectorCategory;
+    readonly supportedLanguages: SupportedLanguage[];
+    private readonly thresholds;
+    constructor(thresholds?: Partial<OverEngineeringThresholds>);
+    detect(units: CodeUnit[], context: DetectorContext): Promise<DetectorResult[]>;
+    /**
+     * Detect functions with too many parameters.
+     * AI models often generate functions with excessive parameters
+     * instead of using option objects or builders.
+     */
+    private detectExcessiveParams;
+    /**
+     * Detect deeply nested code structures.
+     * AI-generated code often has excessive nesting from
+     * nested conditionals and callbacks.
+     */
+    private detectDeepNesting;
+    /**
+     * Detect functions that are excessively long.
+     * AI models often generate monolithic functions instead of
+     * properly decomposed code.
+     */
+    private detectLongFunctions;
+    /**
+     * Detect high cyclomatic complexity.
+     * AI models produce code with many branching paths that
+     * is difficult to understand and test.
+     */
+    private detectHighComplexity;
+    /**
+     * Detect excessive abstraction patterns.
+     *
+     * AI models tend to over-architect solutions by creating:
+     * - Multiple single-method interfaces (unnecessary abstraction)
+     * - Abstract classes with single concrete implementations
+     */
+    private detectExcessiveAbstraction;
+    /**
+     * Get effective thresholds, considering config overrides.
+     */
+    private getEffectiveThresholds;
+}
+//# sourceMappingURL=over-engineering.d.ts.map

package/dist/detectors/v4/over-engineering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"over-engineering.d.ts","sourceRoot":"","sources":["../../../src/detectors/v4/over-engineering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIhG,8DAA8D;AAC9D,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAWD,qBAAa,uBAAwB,YAAW,UAAU;IACxD,QAAQ,CAAC,EAAE,sBAAsB;IACjC,QAAQ,CAAC,IAAI,+BAA+B;IAC5C,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAoB;IACvD,QAAQ,CAAC,kBAAkB,EAAE,iBAAiB,EAAE,CAAM;IAEtD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4B;gBAE3C,UAAU,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC;IAIrD,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAwBpF;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA+B7B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA8BzB;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IA8B3B;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IA8B5B;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B;IAoDlC;;OAEG;IACH,OAAO,CAAC,sBAAsB;CAW/B"}

package/dist/detectors/v4/over-engineering.js

@@ -0,0 +1,234 @@
+/**
+ * OverEngineeringDetector — V4 detector for over-engineered AI-generated code.
+ *
+ * AI models love generating unnecessarily complex code: excessive abstraction,
+ * design pattern abuse, deep nesting, and bloated function signatures.
+ * This detector catches these patterns using CodeUnit complexity metrics.
+ *
+ * V4 improvements over V3:
+ * - Uses pre-computed ComplexityMetrics from CodeUnit IR
+ * - Configurable thresholds via DetectorContext
+ * - Structural analysis using definitions instead of regex
+ *
+ * @since 0.4.0
+ */
+const DEFAULT_THRESHOLDS = {
+    maxParams: 5,
+    maxNesting: 4,
+    maxFunctionLOC: 100,
+    maxCyclomaticComplexity: 15,
+};
+// ─── Detector ──────────────────────────────────────────────────────
+export class OverEngineeringDetector {
+    id = 'over-engineering';
+    name = 'Over-engineering Detector';
+    category = 'implementation';
+    supportedLanguages = [];
+    thresholds;
+    constructor(thresholds) {
+        this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+    }
+    async detect(units, context) {
+        const results = [];
+        // Apply config overrides if present
+        const thresholds = this.getEffectiveThresholds(context);
+        // Analysis 1: Excessive function parameters
+        this.detectExcessiveParams(units, thresholds, results);
+        // Analysis 2: Deep nesting
+        this.detectDeepNesting(units, thresholds, results);
+        // Analysis 3: Long functions
+        this.detectLongFunctions(units, thresholds, results);
+        // Analysis 4: High cyclomatic complexity
+        this.detectHighComplexity(units, thresholds, results);
+        // Analysis 5: Excessive abstraction (many single-method interfaces/classes)
+        this.detectExcessiveAbstraction(units, results);
+        return results;
+    }
+    /**
+     * Detect functions with too many parameters.
+     * AI models often generate functions with excessive parameters
+     * instead of using option objects or builders.
+     */
+    detectExcessiveParams(units, thresholds, results) {
+        for (const unit of units) {
+            if (unit.kind !== 'function' && unit.kind !== 'method')
+                continue;
+            const paramCount = unit.complexity.parameterCount;
+            if (paramCount !== undefined && paramCount > thresholds.maxParams) {
+                results.push({
+                    detectorId: this.id,
+                    severity: 'warning',
+                    category: this.category,
+                    messageKey: 'over-engineering.excessive-params',
+                    message: `Function has ${paramCount} parameters (max: ${thresholds.maxParams}). Consider using an options object or builder pattern.`,
+                    file: unit.file,
+                    line: unit.location.startLine + 1,
+                    endLine: unit.location.endLine + 1,
+                    confidence: 0.8,
+                    metadata: {
+                        paramCount,
+                        threshold: thresholds.maxParams,
+                        functionId: unit.id,
+                        analysisType: 'excessive-params',
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * Detect deeply nested code structures.
+     * AI-generated code often has excessive nesting from
+     * nested conditionals and callbacks.
+     */
+    detectDeepNesting(units, thresholds, results) {
+        for (const unit of units) {
+            if (unit.kind !== 'function' && unit.kind !== 'method')
+                continue;
+            if (unit.complexity.maxNestingDepth > thresholds.maxNesting) {
+                results.push({
+                    detectorId: this.id,
+                    severity: 'warning',
+                    category: this.category,
+                    messageKey: 'over-engineering.deep-nesting',
+                    message: `Function has nesting depth of ${unit.complexity.maxNestingDepth} (max: ${thresholds.maxNesting}). Consider early returns or extracting helper functions.`,
+                    file: unit.file,
+                    line: unit.location.startLine + 1,
+                    endLine: unit.location.endLine + 1,
+                    confidence: 0.75,
+                    metadata: {
+                        nestingDepth: unit.complexity.maxNestingDepth,
+                        threshold: thresholds.maxNesting,
+                        functionId: unit.id,
+                        analysisType: 'deep-nesting',
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * Detect functions that are excessively long.
+     * AI models often generate monolithic functions instead of
+     * properly decomposed code.
+     */
+    detectLongFunctions(units, thresholds, results) {
+        for (const unit of units) {
+            if (unit.kind !== 'function' && unit.kind !== 'method')
+                continue;
+            if (unit.complexity.linesOfCode > thresholds.maxFunctionLOC) {
+                results.push({
+                    detectorId: this.id,
+                    severity: 'warning',
+                    category: this.category,
+                    messageKey: 'over-engineering.long-function',
+                    message: `Function has ${unit.complexity.linesOfCode} lines of code (max: ${thresholds.maxFunctionLOC}). Consider breaking it into smaller functions.`,
+                    file: unit.file,
+                    line: unit.location.startLine + 1,
+                    endLine: unit.location.endLine + 1,
+                    confidence: 0.7,
+                    metadata: {
+                        linesOfCode: unit.complexity.linesOfCode,
+                        threshold: thresholds.maxFunctionLOC,
+                        functionId: unit.id,
+                        analysisType: 'long-function',
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * Detect high cyclomatic complexity.
+     * AI models produce code with many branching paths that
+     * is difficult to understand and test.
+     */
+    detectHighComplexity(units, thresholds, results) {
+        for (const unit of units) {
+            if (unit.kind !== 'function' && unit.kind !== 'method')
+                continue;
+            if (unit.complexity.cyclomaticComplexity > thresholds.maxCyclomaticComplexity) {
+                results.push({
+                    detectorId: this.id,
+                    severity: 'warning',
+                    category: this.category,
+                    messageKey: 'over-engineering.high-complexity',
+                    message: `Function has cyclomatic complexity of ${unit.complexity.cyclomaticComplexity} (max: ${thresholds.maxCyclomaticComplexity}). Consider simplifying the logic.`,
+                    file: unit.file,
+                    line: unit.location.startLine + 1,
+                    endLine: unit.location.endLine + 1,
+                    confidence: 0.85,
+                    metadata: {
+                        cyclomaticComplexity: unit.complexity.cyclomaticComplexity,
+                        threshold: thresholds.maxCyclomaticComplexity,
+                        functionId: unit.id,
+                        analysisType: 'high-complexity',
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * Detect excessive abstraction patterns.
+     *
+     * AI models tend to over-architect solutions by creating:
+     * - Multiple single-method interfaces (unnecessary abstraction)
+     * - Abstract classes with single concrete implementations
+     */
+    detectExcessiveAbstraction(units, results) {
+        // Group by file to detect per-file patterns
+        const fileUnits = new Map();
+        for (const unit of units) {
+            if (!fileUnits.has(unit.file)) {
+                fileUnits.set(unit.file, []);
+            }
+            fileUnits.get(unit.file).push(unit);
+        }
+        for (const [file, fileUnitList] of fileUnits) {
+            // Count interfaces with single method definitions
+            let singleMethodInterfaces = 0;
+            const interfaceUnits = [];
+            for (const unit of fileUnitList) {
+                if (unit.kind !== 'class')
+                    continue;
+                // Detect interfaces/types with only a single method
+                const methodDefs = unit.definitions.filter(d => d.kind === 'method');
+                const interfaceDefs = unit.definitions.filter(d => d.kind === 'interface');
+                // If this is an interface-like unit (has interface definitions) with very few methods
+                if (interfaceDefs.length > 0 && methodDefs.length === 1) {
+                    singleMethodInterfaces++;
+                    interfaceUnits.push(unit);
+                }
+            }
+            // Flag if there are many single-method interfaces in one file
+            if (singleMethodInterfaces >= 3) {
+                results.push({
+                    detectorId: this.id,
+                    severity: 'info',
+                    category: this.category,
+                    messageKey: 'over-engineering.excessive-abstraction',
+                    message: `File contains ${singleMethodInterfaces} single-method interfaces. This may be over-engineered — consider consolidating or using function types.`,
+                    file,
+                    line: interfaceUnits[0]?.location.startLine + 1 || 1,
+                    confidence: 0.6,
+                    metadata: {
+                        singleMethodInterfaces,
+                        analysisType: 'excessive-abstraction',
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * Get effective thresholds, considering config overrides.
+     */
+    getEffectiveThresholds(context) {
+        const config = context.config?.['over-engineering'];
+        if (!config)
+            return this.thresholds;
+        return {
+            maxParams: config.maxParams ?? this.thresholds.maxParams,
+            maxNesting: config.maxNesting ?? this.thresholds.maxNesting,
+            maxFunctionLOC: config.maxFunctionLOC ?? this.thresholds.maxFunctionLOC,
+            maxCyclomaticComplexity: config.maxCyclomaticComplexity ?? this.thresholds.maxCyclomaticComplexity,
+        };
+    }
+}
+//# sourceMappingURL=over-engineering.js.map

package/dist/detectors/v4/over-engineering.js.map

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

package/dist/detectors/v4/security-pattern.d.ts

@@ -0,0 +1,46 @@
+/**
+ * SecurityPatternDetector — V4 detector for security anti-patterns in AI-generated code.
+ *
+ * NOT a replacement for dedicated security scanners (Snyk, Semgrep).
+ * Focuses specifically on patterns AI commonly produces from training data:
+ * - Hardcoded secrets/tokens (example values from docs left in code)
+ * - Insecure defaults (HTTP instead of HTTPS, no TLS verification)
+ * - SQL injection from string concatenation
+ * - eval()/exec() usage
+ * - Weak cryptography (MD5, SHA1 for security purposes)
+ * - Hardcoded credentials
+ *
+ * V4 improvements over V3:
+ * - Operates on CodeUnit IR with language-aware patterns
+ * - Better context analysis (knows which calls are security-relevant)
+ * - Reduced false positives through source context analysis
+ *
+ * @since 0.4.0
+ */
+import type { CodeUnit, SupportedLanguage } from '../../ir/types.js';
+import type { V4Detector, DetectorResult, DetectorCategory, DetectorContext } from './types.js';
+/** Security pattern definition for detecting vulnerabilities in code. */
+export interface SecurityPattern {
+    /** Unique ID for the pattern */
+    id: string;
+    /** Regex to match in source code */
+    pattern: RegExp;
+    /** Severity of the finding */
+    severity: 'error' | 'warning' | 'info';
+    /** Confidence level */
+    confidence: number;
+    /** Human-readable message */
+    message: string;
+    /** Languages this pattern applies to (empty = all) */
+    languages: SupportedLanguage[];
+    /** Additional context patterns that should NOT be present to trigger this finding */
+    excludeContextPatterns?: RegExp[];
+}
+export declare class SecurityPatternDetector implements V4Detector {
+    readonly id = "security-pattern";
+    readonly name = "Security Pattern Detector";
+    readonly category: DetectorCategory;
+    readonly supportedLanguages: SupportedLanguage[];
+    detect(units: CodeUnit[], context: DetectorContext): Promise<DetectorResult[]>;
+}
+//# sourceMappingURL=security-pattern.d.ts.map

package/dist/detectors/v4/security-pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-pattern.d.ts","sourceRoot":"","sources":["../../../src/detectors/v4/security-pattern.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIhG,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,oCAAoC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACvC,uBAAuB;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,qFAAqF;IACrF,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;CACnC;AA0KD,qBAAa,uBAAwB,YAAW,UAAU;IACxD,QAAQ,CAAC,EAAE,sBAAsB;IACjC,QAAQ,CAAC,IAAI,+BAA+B;IAC5C,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAoB;IACvD,QAAQ,CAAC,kBAAkB,EAAE,iBAAiB,EAAE,CAAM;IAEhD,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;CA4DrF"}

package/dist/detectors/v4/security-pattern.js

@@ -0,0 +1,233 @@
+/**
+ * SecurityPatternDetector — V4 detector for security anti-patterns in AI-generated code.
+ *
+ * NOT a replacement for dedicated security scanners (Snyk, Semgrep).
+ * Focuses specifically on patterns AI commonly produces from training data:
+ * - Hardcoded secrets/tokens (example values from docs left in code)
+ * - Insecure defaults (HTTP instead of HTTPS, no TLS verification)
+ * - SQL injection from string concatenation
+ * - eval()/exec() usage
+ * - Weak cryptography (MD5, SHA1 for security purposes)
+ * - Hardcoded credentials
+ *
+ * V4 improvements over V3:
+ * - Operates on CodeUnit IR with language-aware patterns
+ * - Better context analysis (knows which calls are security-relevant)
+ * - Reduced false positives through source context analysis
+ *
+ * @since 0.4.0
+ */
+// ─── Security Patterns ─────────────────────────────────────────────
+const SECURITY_PATTERNS = [
+    // ── Hardcoded Secrets ──────────────────────────────────────────
+    {
+        id: 'hardcoded-api-key',
+        pattern: /(?:api[_-]?key|apikey|api[_-]?secret|api[_-]?token)\s*[:=]\s*['"][A-Za-z0-9_\-]{16,}['"]/i,
+        severity: 'error',
+        confidence: 0.85,
+        message: 'Possible hardcoded API key detected. Use environment variables or a secrets manager instead.',
+        languages: [],
+    },
+    {
+        id: 'hardcoded-password',
+        pattern: /(?:password|passwd|pwd|secret)\s*[:=]\s*['"][^'"]{4,}['"]/i,
+        severity: 'error',
+        confidence: 0.8,
+        message: 'Possible hardcoded password detected. Use environment variables or a secrets manager instead.',
+        languages: [],
+        excludeContextPatterns: [
+            /(?:example|sample|test|mock|dummy|placeholder|todo|fixme|xxx)/i,
+        ],
+    },
+    {
+        id: 'hardcoded-token',
+        pattern: /(?:auth[_-]?token|access[_-]?token|bearer[_-]?token|jwt[_-]?secret)\s*[:=]\s*['"][A-Za-z0-9_.\-]{16,}['"]/i,
+        severity: 'error',
+        confidence: 0.85,
+        message: 'Possible hardcoded authentication token detected. Use environment variables instead.',
+        languages: [],
+    },
+    {
+        id: 'aws-access-key',
+        pattern: /(?:AKIA|ABIA|ACCA|ASIA)[A-Z0-9]{16}/,
+        severity: 'error',
+        confidence: 0.95,
+        message: 'Possible AWS access key ID detected. Rotate immediately and use IAM roles or environment variables.',
+        languages: [],
+    },
+    {
+        id: 'private-key',
+        pattern: /-----BEGIN\s+(?:RSA\s+)?PRIVATE\s+KEY-----/,
+        severity: 'error',
+        confidence: 0.95,
+        message: 'Private key embedded in source code. Store in a secure vault or secrets manager.',
+        languages: [],
+    },
+    // ── Dangerous Functions ────────────────────────────────────────
+    {
+        id: 'eval-usage-js',
+        pattern: /\beval\s*\(/,
+        severity: 'error',
+        confidence: 0.9,
+        message: 'eval() usage detected. This enables code injection attacks. Use safer alternatives like JSON.parse() or a sandboxed evaluator.',
+        languages: ['typescript', 'javascript'],
+    },
+    {
+        id: 'eval-usage-python',
+        pattern: /\beval\s*\(/,
+        severity: 'error',
+        confidence: 0.9,
+        message: 'eval() usage detected. This enables code injection attacks. Use ast.literal_eval() or safer alternatives.',
+        languages: ['python'],
+    },
+    {
+        id: 'exec-usage-python',
+        pattern: /\bexec\s*\(/,
+        severity: 'error',
+        confidence: 0.85,
+        message: 'exec() usage detected. This enables arbitrary code execution. Consider safer alternatives.',
+        languages: ['python'],
+    },
+    {
+        id: 'new-function-js',
+        pattern: /\bnew\s+Function\s*\(/,
+        severity: 'warning',
+        confidence: 0.85,
+        message: 'new Function() is similar to eval() and can enable code injection. Use safer alternatives.',
+        languages: ['typescript', 'javascript'],
+    },
+    // ── SQL Injection ──────────────────────────────────────────────
+    {
+        id: 'sql-string-concat',
+        pattern: /(?:SELECT|INSERT|UPDATE|DELETE|DROP)\s+.*?\+\s*(?:req\.|request\.|params\.|query\.|body\.|input|user)/i,
+        severity: 'error',
+        confidence: 0.8,
+        message: 'SQL query with string concatenation from user input detected. Use parameterized queries to prevent SQL injection.',
+        languages: ['typescript', 'javascript', 'java', 'kotlin', 'python'],
+    },
+    {
+        id: 'sql-template-literal',
+        pattern: /(?:SELECT|INSERT|UPDATE|DELETE|DROP)\s+.*?\$\{.*?(?:req|request|params|query|body|input|user)/i,
+        severity: 'error',
+        confidence: 0.85,
+        message: 'SQL query using template literals with user input detected. Use parameterized queries to prevent SQL injection.',
+        languages: ['typescript', 'javascript'],
+    },
+    {
+        id: 'sql-f-string-python',
+        pattern: /f['"](?:SELECT|INSERT|UPDATE|DELETE|DROP)\s+.*?\{.*?(?:request|params|query|body|input|user)/i,
+        severity: 'error',
+        confidence: 0.85,
+        message: 'SQL query using f-string with user input detected. Use parameterized queries to prevent SQL injection.',
+        languages: ['python'],
+    },
+    // ── Weak Cryptography ──────────────────────────────────────────
+    {
+        id: 'weak-hash-md5',
+        pattern: /\b(?:md5|MD5|createHash\s*\(\s*['"]md5['"]|hashlib\.md5|MessageDigest\.getInstance\s*\(\s*['"]MD5['"])\b/,
+        severity: 'warning',
+        confidence: 0.75,
+        message: 'MD5 is cryptographically broken. Use SHA-256 or better for security purposes. (OK for checksums/non-security uses.)',
+        languages: [],
+    },
+    {
+        id: 'weak-hash-sha1',
+        pattern: /\b(?:sha1|SHA1|createHash\s*\(\s*['"]sha1['"]|hashlib\.sha1|MessageDigest\.getInstance\s*\(\s*['"]SHA-?1['"])\b/,
+        severity: 'warning',
+        confidence: 0.7,
+        message: 'SHA-1 is cryptographically weak. Use SHA-256 or better for security purposes. (OK for checksums/non-security uses.)',
+        languages: [],
+    },
+    {
+        id: 'weak-random',
+        pattern: /\bMath\.random\s*\(\)/,
+        severity: 'warning',
+        confidence: 0.7,
+        message: 'Math.random() is not cryptographically secure. Use crypto.randomUUID() or crypto.getRandomValues() for security-sensitive operations.',
+        languages: ['typescript', 'javascript'],
+    },
+    // ── Insecure Defaults ──────────────────────────────────────────
+    {
+        id: 'tls-verify-disabled',
+        pattern: /(?:rejectUnauthorized\s*:\s*false|NODE_TLS_REJECT_UNAUTHORIZED\s*=\s*['"]?0|verify\s*=\s*False|InsecureSkipVerify\s*:\s*true)/i,
+        severity: 'error',
+        confidence: 0.9,
+        message: 'TLS certificate verification is disabled. This enables man-in-the-middle attacks.',
+        languages: [],
+    },
+    {
+        id: 'cors-wildcard',
+        pattern: /(?:Access-Control-Allow-Origin['"]\s*[:=]\s*['"]\*|cors\(\s*\)|allowedOrigins\s*\(\s*['"]\*['"])/i,
+        severity: 'warning',
+        confidence: 0.7,
+        message: 'CORS is configured with wildcard origin. Restrict to specific trusted domains.',
+        languages: [],
+    },
+    {
+        id: 'http-no-tls',
+        pattern: /['"]http:\/\/(?!localhost|127\.0\.0\.1|0\.0\.0\.0)/,
+        severity: 'info',
+        confidence: 0.5,
+        message: 'HTTP URL detected (not HTTPS). Consider using HTTPS for production endpoints.',
+        languages: [],
+    },
+];
+// ─── Detector ──────────────────────────────────────────────────────
+export class SecurityPatternDetector {
+    id = 'security-pattern';
+    name = 'Security Pattern Detector';
+    category = 'implementation';
+    supportedLanguages = [];
+    async detect(units, context) {
+        const results = [];
+        for (const unit of units) {
+            // Skip non-source units (module-level containers without source)
+            if (!unit.source || unit.source.trim().length === 0)
+                continue;
+            // Get applicable patterns for this language
+            const applicablePatterns = SECURITY_PATTERNS.filter(p => p.languages.length === 0 || p.languages.includes(unit.language));
+            const lines = unit.source.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Skip comments (simple heuristic)
+                const trimmed = line.trim();
+                if (trimmed.startsWith('//') || trimmed.startsWith('#') || trimmed.startsWith('*')) {
+                    continue;
+                }
+                for (const pattern of applicablePatterns) {
+                    // Reset regex lastIndex (patterns might be reused)
+                    pattern.pattern.lastIndex = 0;
+                    if (pattern.pattern.test(line)) {
+                        // Check exclude context patterns
+                        if (pattern.excludeContextPatterns) {
+                            const excluded = pattern.excludeContextPatterns.some(ep => {
+                                ep.lastIndex = 0;
+                                return ep.test(line);
+                            });
+                            if (excluded)
+                                continue;
+                        }
+                        const absoluteLine = unit.location.startLine + i;
+                        results.push({
+                            detectorId: this.id,
+                            severity: pattern.severity,
+                            category: this.category,
+                            messageKey: `security-pattern.${pattern.id}`,
+                            message: pattern.message,
+                            file: unit.file,
+                            line: absoluteLine + 1, // 0-based to 1-based
+                            confidence: pattern.confidence,
+                            metadata: {
+                                patternId: pattern.id,
+                                language: unit.language,
+                                matchedLine: line.trim().substring(0, 100), // Truncate for safety
+                            },
+                        });
+                    }
+                }
+            }
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=security-pattern.js.map

package/dist/detectors/v4/security-pattern.js.map

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