@rigour-labs/core 5.0.0 → 5.1.0

package/dist/gates/style-drift-rules.js

@@ -0,0 +1,103 @@
+/**
+ * Style Drift Detection Gate — Naming Convention Rules and Regexes
+ *
+ * Contains per-language naming convention rules and naming pattern regexes.
+ */
+/**
+ * Casing classification rules
+ */
+export function classifyCasing(name) {
+    if (name.startsWith('_') || name.length <= 1)
+        return null;
+    if (/^[A-Z][A-Z0-9_]+$/.test(name)) {
+        return 'SCREAMING_SNAKE';
+    }
+    else if (/^[A-Z]/.test(name)) {
+        return 'PascalCase';
+    }
+    else if (name.includes('_')) {
+        return 'snake_case';
+    }
+    else {
+        return 'camelCase';
+    }
+}
+/**
+ * Function name pattern for JavaScript
+ */
+export const JS_FUNCTION_PATTERN = /(?:function|async\s+function)\s+(\w+)/;
+/**
+ * Method definition pattern for all languages
+ */
+export const METHOD_PATTERN = /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*[{:]/;
+/**
+ * Arrow function assignment pattern
+ */
+export const ARROW_FUNCTION_PATTERN = /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|(\w+))\s*=>/;
+/**
+ * Variable declaration pattern (non-function)
+ */
+export const VAR_DECLARATION_PATTERN = /(?:const|let|var)\s+(\w+)\s*=/;
+/**
+ * Python function pattern
+ */
+export const PYTHON_FUNCTION_PATTERN = /def\s+(\w+)/;
+/**
+ * Python variable pattern
+ */
+export const PYTHON_VAR_PATTERN = /^(\w+)\s*=/;
+/**
+ * Go function pattern
+ */
+export const GO_FUNCTION_PATTERN = /^func\s+(?:\([^)]+\)\s+)?(\w+)/;
+/**
+ * Go variable pattern
+ */
+export const GO_VAR_PATTERN = /^\s*(\w+)\s*:?=/;
+/**
+ * Rust function pattern
+ */
+export const RUST_FUNCTION_PATTERN = /fn\s+(\w+)/;
+/**
+ * Rust variable pattern
+ */
+export const RUST_VAR_PATTERN = /let\s+(?:mut\s+)?(\w+)/;
+/**
+ * Ruby method pattern
+ */
+export const RUBY_METHOD_PATTERN = /def\s+(?:self\.)?(\w+)/;
+/**
+ * Ruby variable pattern
+ */
+export const RUBY_VAR_PATTERN = /^\s*(\w+)\s*=/;
+/**
+ * Java/Kotlin/C# method pattern
+ */
+export const JAVA_METHOD_PATTERN = /(?:public|private|protected|internal|static|override|virtual|abstract)\s+(?:\w+\s+)*(\w+)\s*\(/;
+/**
+ * Java/Kotlin/C# variable pattern
+ */
+export const JAVA_VAR_PATTERN = /(?:var|val|final)?\s*\w+\s+(\w+)\s*[=;]/;
+/**
+ * Error handling patterns
+ */
+export const TRY_CATCH_PATTERN = /\btry\s*\{|\btry\s*:/;
+export const CATCH_PATTERN = /\.catch\s*\(|\bexcept\b|\brescue\b/;
+export const RESULT_TYPE_PATTERN = /Result<|Result\[|Err\(|Ok\(|Either<|\bif\s+err\s*!=\s*nil\b/;
+/**
+ * Import style patterns
+ */
+export const NAMED_IMPORT_PATTERN = /^import\s+\{/;
+export const WILDCARD_IMPORT_PATTERN = /^import\s+\*\s+as/;
+export const SIDE_EFFECT_IMPORT_PATTERN = /^import\s+['"]/;
+export const DEFAULT_IMPORT_PATTERN = /^import\s+\w/;
+/**
+ * Quote style detection
+ */
+export function countQuotes(line) {
+    return {
+        single: (line.match(/'/g) || []).length,
+        double: (line.match(/"/g) || []).length,
+        backtick: (line.match(/`/g) || []).length,
+    };
+}

package/dist/gates/style-drift.d.ts

@@ -7,19 +7,17 @@
  *
  * What it checks:
  * 1. Naming conventions — camelCase vs snake_case vs PascalCase consistency
- * 2. Error handling patterns — try-catch vs .catch() vs Result type consistency
+ * 2. Error handling patterns — try-catch vs .catch()/except/rescue consistency
  * 3. Import style — named vs default vs wildcard import consistency
  * 4. Quote style — single vs double quote consistency
  *
  * How it works:
- * 1. First scan: sample source files → compute a style fingerprint → store baseline
- * 2. Subsequent scans: compare new/changed files against baseline
+ * 1. First scan: sample source files → compute per-language style fingerprints → store baseline
+ * 2. Subsequent scans: compare new/changed files against their language's baseline
  * 3. If a file deviates >25% on any dimension → flag as style drift
  *
- * The baseline is stored in .rigour/style-baseline.json and evolves with
- * human-approved changes (not AI drift).
- *
- * @since v5.0.0
+ * Baselines are per-language to avoid cross-language contamination
+ * (e.g., Python snake_case shouldn't flag JS camelCase).
  */
 import { Gate, GateContext } from './base.js';
 import { Failure, Provenance } from '../types/index.js';
@@ -34,20 +32,13 @@ export declare class StyleDriftGate extends Gate {
     constructor(config?: StyleDriftConfig);
     protected get provenance(): Provenance;
     run(context: GateContext): Promise<Failure[]>;
+    private computePerLanguageBaseline;
     private computeFingerprint;
+    private emptyFingerprint;
     private analyzeFile;
-    private classifyCasing;
     private mergeIntoFingerprint;
     private compareToBaseline;
-    /**
-     * Compare two distributions and return a deviation score (0-1).
-     * 0 = perfect match, 1 = completely different predominant style.
-     *
-     * Method: find the predominant category in each distribution.
-     * If they differ, score = how far the file is from the baseline's predominant category.
-     */
     private distributionDeviation;
     private hasSignificantData;
-    /** Convert a typed distribution to a generic Record for comparison */
     private toRecord;
 }

package/dist/gates/style-drift.js

@@ -7,23 +7,23 @@
  *
  * What it checks:
  * 1. Naming conventions — camelCase vs snake_case vs PascalCase consistency
- * 2. Error handling patterns — try-catch vs .catch() vs Result type consistency
+ * 2. Error handling patterns — try-catch vs .catch()/except/rescue consistency
  * 3. Import style — named vs default vs wildcard import consistency
  * 4. Quote style — single vs double quote consistency
  *
  * How it works:
- * 1. First scan: sample source files → compute a style fingerprint → store baseline
- * 2. Subsequent scans: compare new/changed files against baseline
+ * 1. First scan: sample source files → compute per-language style fingerprints → store baseline
+ * 2. Subsequent scans: compare new/changed files against their language's baseline
  * 3. If a file deviates >25% on any dimension → flag as style drift
  *
- * The baseline is stored in .rigour/style-baseline.json and evolves with
- * human-approved changes (not AI drift).
- *
- * @since v5.0.0
+ * Baselines are per-language to avoid cross-language contamination
+ * (e.g., Python snake_case shouldn't flag JS camelCase).
  */
 import { Gate } from './base.js';
 import { FileScanner } from '../utils/scanner.js';
 import { Logger } from '../utils/logger.js';
+import { languageAdapters } from './language-adapters/index.js';
+import { TRY_CATCH_PATTERN, CATCH_PATTERN, RESULT_TYPE_PATTERN, NAMED_IMPORT_PATTERN, WILDCARD_IMPORT_PATTERN, SIDE_EFFECT_IMPORT_PATTERN, DEFAULT_IMPORT_PATTERN, countQuotes, } from './style-drift-rules.js';
 import fs from 'fs-extra';
 import path from 'path';
 export class StyleDriftGate extends Gate {
@@ -33,7 +33,7 @@ export class StyleDriftGate extends Gate {
         this.config = {
             enabled: config.enabled ?? true,
             deviation_threshold: config.deviation_threshold ?? 0.25,
-            sample_size: config.sample_size ?? 100,
+            sample_size: config.sample_size ?? 50,
             baseline_path: config.baseline_path ?? '.rigour/style-baseline.json',
         };
     }
@@ -46,43 +46,63 @@ export class StyleDriftGate extends Gate {
         // Find source files
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: context.patterns || ['**/*.{ts,tsx,js,jsx,py}'],
+            patterns: context.patterns || languageAdapters.getScanPatterns(),
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*', '**/*.d.ts'],
         });
         if (files.length === 0)
             return [];
+        // Group files by language
+        const filesByLang = new Map();
+        for (const file of files) {
+            const adapter = languageAdapters.getAdapter(file);
+            if (!adapter)
+                continue;
+            const langFiles = filesByLang.get(adapter.id) || [];
+            langFiles.push(file);
+            filesByLang.set(adapter.id, langFiles);
+        }
         // Load or create baseline
         let baseline = null;
         if (await fs.pathExists(baselinePath)) {
             try {
-                baseline = await fs.readJson(baselinePath);
+                const raw = await fs.readJson(baselinePath);
+                // Handle migration from old single-fingerprint format
+                if (raw.version === 2) {
+                    baseline = raw;
+                }
+                else {
+                    Logger.debug('Old style baseline format detected, creating new per-language baseline');
+                }
             }
             catch {
                 Logger.debug('Failed to load style baseline, will create new one');
             }
         }
         if (!baseline) {
-            // First scan: create baseline from sampled files
-            const sampled = files.slice(0, this.config.sample_size);
-            baseline = await this.computeFingerprint(context, sampled);
-            baseline.createdAt = new Date().toISOString();
-            // Ensure directory exists and save baseline
+            // First scan: create per-language baseline
+            baseline = await this.computePerLanguageBaseline(context, filesByLang);
             await fs.ensureDir(path.dirname(baselinePath));
             await fs.writeJson(baselinePath, baseline, { spaces: 2 });
-            Logger.info(`Style Drift: Created baseline from ${sampled.length} files → ${baselinePath}`);
+            const langSummary = Object.entries(baseline.languages)
+                .map(([lang, fp]) => `${lang}:${fp.totalFilesAnalyzed}`)
+                .join(', ');
+            Logger.info(`Style Drift: Created baseline (${langSummary}) → ${baselinePath}`);
             return []; // No failures on first scan
         }
-        // Subsequent scan: compare each file against baseline
+        // Subsequent scan: compare each file against its own language's baseline
         const contents = await FileScanner.readFiles(context.cwd, files, context.fileCache);
         for (const [file, content] of contents) {
-            const ext = path.extname(file);
-            if (!['.ts', '.tsx', '.js', '.jsx', '.py'].includes(ext))
+            const adapter = languageAdapters.getAdapter(file);
+            if (!adapter)
                 continue;
-            const fileFingerprint = this.analyzeFile(content, ext);
-            const deviations = this.compareToBaseline(fileFingerprint, baseline);
+            const langBaseline = baseline.languages[adapter.id];
+            if (!langBaseline)
+                continue; // No baseline for this language yet
+            const fileFingerprint = this.analyzeFile(content, file);
+            const deviations = this.compareToBaseline(fileFingerprint, langBaseline);
             for (const deviation of deviations) {
                 if (deviation.score > this.config.deviation_threshold) {
-                    failures.push(this.createFailure(`Style drift in ${file}: ${deviation.dimension} deviates ${(deviation.score * 100).toFixed(0)}% from project baseline (${deviation.detail}).`, [file], `This file's ${deviation.dimension} doesn't match the project's established convention. ${deviation.suggestion}`, 'Style Drift', undefined, undefined, 'low'));
+                    failures.push(this.createFailure(`Style drift in ${file}: ${deviation.dimension} deviates ${(deviation.score * 100).toFixed(0)}% from ${adapter.id} baseline (${deviation.detail}).`, [file], `This file's ${deviation.dimension} doesn't match the ${adapter.id} project convention. ${deviation.suggestion}`, 'Style Drift', undefined, undefined, 'low'));
                 }
             }
         }
@@ -91,130 +111,105 @@ export class StyleDriftGate extends Gate {
         }
         return failures;
     }
-    // ─── Fingerprint Computation ─────────────────────────────────────
-    async computeFingerprint(context, files) {
-        const fingerprint = {
-            naming: {
-                functions: { camelCase: 0, snake_case: 0, PascalCase: 0, SCREAMING_SNAKE: 0 },
-                variables: { camelCase: 0, snake_case: 0, PascalCase: 0, SCREAMING_SNAKE: 0 },
-            },
-            errorHandling: { tryCatch: 0, promiseCatch: 0, resultType: 0 },
-            importStyle: { named: 0, default: 0, wildcard: 0, sideEffect: 0 },
-            quoteStyle: { single: 0, double: 0, backtick: 0 },
-            totalFilesAnalyzed: 0,
-            createdAt: '',
+    // ─── Per-Language Baseline Computation ────────────────────────────
+    async computePerLanguageBaseline(context, filesByLang) {
+        const baseline = {
+            languages: {},
+            createdAt: new Date().toISOString(),
+            version: 2,
         };
+        for (const [langId, langFiles] of filesByLang) {
+            // Sample up to sample_size files per language
+            const sampled = langFiles.slice(0, this.config.sample_size);
+            const fingerprint = await this.computeFingerprint(context, sampled);
+            fingerprint.createdAt = baseline.createdAt;
+            baseline.languages[langId] = fingerprint;
+        }
+        return baseline;
+    }
+    async computeFingerprint(context, files) {
+        const fingerprint = this.emptyFingerprint();
         const contents = await FileScanner.readFiles(context.cwd, files, context.fileCache);
         for (const [file, content] of contents) {
-            const ext = path.extname(file);
-            const fileAnalysis = this.analyzeFile(content, ext);
+            const fileAnalysis = this.analyzeFile(content, file);
             this.mergeIntoFingerprint(fingerprint, fileAnalysis);
             fingerprint.totalFilesAnalyzed++;
         }
         return fingerprint;
     }
-    analyzeFile(content, ext) {
-        const fp = {
+    emptyFingerprint() {
+        return {
             naming: {
-                functions: { camelCase: 0, snake_case: 0, PascalCase: 0, SCREAMING_SNAKE: 0 },
-                variables: { camelCase: 0, snake_case: 0, PascalCase: 0, SCREAMING_SNAKE: 0 },
+                functions: { camelCase: 0, snake_case: 0, PascalCase: 0, SCREAMING_SNAKE: 0, 'kebab-case': 0, other: 0 },
+                variables: { camelCase: 0, snake_case: 0, PascalCase: 0, SCREAMING_SNAKE: 0, 'kebab-case': 0, other: 0 },
             },
             errorHandling: { tryCatch: 0, promiseCatch: 0, resultType: 0 },
             importStyle: { named: 0, default: 0, wildcard: 0, sideEffect: 0 },
             quoteStyle: { single: 0, double: 0, backtick: 0 },
-            totalFilesAnalyzed: 1,
+            totalFilesAnalyzed: 0,
             createdAt: '',
         };
+    }
+    analyzeFile(content, filePath) {
+        const fp = this.emptyFingerprint();
+        fp.totalFilesAnalyzed = 1;
         const lines = content.split('\n');
-        for (const line of lines) {
-            // ── Naming conventions ──
-            // Function declarations
-            const fnMatch = line.match(/(?:function|async\s+function)\s+(\w+)/);
-            if (fnMatch)
-                this.classifyCasing(fnMatch[1], fp.naming.functions);
-            // Method definitions
-            const methodMatch = line.match(/^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*[{:]/);
-            if (methodMatch && !['if', 'for', 'while', 'switch', 'catch', 'constructor'].includes(methodMatch[1])) {
-                this.classifyCasing(methodMatch[1], fp.naming.functions);
-            }
-            // Arrow function assignments
-            const arrowMatch = line.match(/(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|(\w+))\s*=>/);
-            if (arrowMatch)
-                this.classifyCasing(arrowMatch[1], fp.naming.functions);
-            // Variable declarations (non-function)
-            const varMatch = line.match(/(?:const|let|var)\s+(\w+)\s*=/);
-            if (varMatch && !arrowMatch)
-                this.classifyCasing(varMatch[1], fp.naming.variables);
-            // Python function/variable
-            if (ext === '.py') {
-                const pyFn = line.match(/def\s+(\w+)/);
-                if (pyFn)
-                    this.classifyCasing(pyFn[1], fp.naming.functions);
-                const pyVar = line.match(/^(\w+)\s*=/);
-                if (pyVar && !pyFn)
-                    this.classifyCasing(pyVar[1], fp.naming.variables);
+        const adapter = languageAdapters.getAdapter(filePath);
+        // ── Naming conventions (via adapter) ──
+        if (adapter) {
+            const namingPatterns = adapter.extractNamingPatterns(content);
+            for (const pattern of namingPatterns) {
+                if (pattern.kind === 'function' || pattern.kind === 'method') {
+                    fp.naming.functions[pattern.convention]++;
+                }
+                else if (pattern.kind === 'variable' || pattern.kind === 'constant') {
+                    fp.naming.variables[pattern.convention]++;
+                }
             }
+        }
+        for (const line of lines) {
             // ── Error handling ──
-            if (/\btry\s*\{/.test(line) || /\btry\s*:/.test(line))
+            if (TRY_CATCH_PATTERN.test(line))
                 fp.errorHandling.tryCatch++;
-            if (/\.catch\s*\(/.test(line))
+            if (CATCH_PATTERN.test(line))
                 fp.errorHandling.promiseCatch++;
-            if (/Result<|Result\[|Err\(|Ok\(|Either</.test(line))
+            if (RESULT_TYPE_PATTERN.test(line))
                 fp.errorHandling.resultType++;
             // ── Import style ──
-            if (/^import\s+\{/.test(line.trim()))
+            if (NAMED_IMPORT_PATTERN.test(line.trim()))
                 fp.importStyle.named++;
-            else if (/^import\s+\*\s+as/.test(line.trim()))
+            else if (WILDCARD_IMPORT_PATTERN.test(line.trim()))
                 fp.importStyle.wildcard++;
-            else if (/^import\s+['"]/.test(line.trim()))
+            else if (SIDE_EFFECT_IMPORT_PATTERN.test(line.trim()))
                 fp.importStyle.sideEffect++;
-            else if (/^import\s+\w/.test(line.trim()))
+            else if (DEFAULT_IMPORT_PATTERN.test(line.trim()))
                 fp.importStyle.default++;
             // ── Quote style ──
-            // Count quotes in non-import lines (imports are already counted above)
             if (!line.trim().startsWith('import')) {
-                const singles = (line.match(/'/g) || []).length;
-                const doubles = (line.match(/"/g) || []).length;
-                const backticks = (line.match(/`/g) || []).length;
-                fp.quoteStyle.single += singles;
-                fp.quoteStyle.double += doubles;
-                fp.quoteStyle.backtick += backticks;
+                const quotes = countQuotes(line);
+                fp.quoteStyle.single += quotes.single;
+                fp.quoteStyle.double += quotes.double;
+                fp.quoteStyle.backtick += quotes.backtick;
             }
         }
         return fp;
     }
-    classifyCasing(name, dist) {
-        if (name.startsWith('_') || name.length <= 1)
-            return; // Skip private/single char
-        if (/^[A-Z][A-Z0-9_]+$/.test(name)) {
-            dist.SCREAMING_SNAKE++;
-        }
-        else if (/^[A-Z]/.test(name)) {
-            dist.PascalCase++;
-        }
-        else if (name.includes('_')) {
-            dist.snake_case++;
-        }
-        else {
-            dist.camelCase++;
-        }
-    }
     mergeIntoFingerprint(target, source) {
-        // Naming
         for (const key of Object.keys(target.naming.functions)) {
-            target.naming.functions[key] += source.naming.functions[key];
-            target.naming.variables[key] += source.naming.variables[key];
+            const targetVal = target.naming.functions[key] ?? 0;
+            const sourceVal = source.naming.functions[key] ?? 0;
+            target.naming.functions[key] = targetVal + sourceVal;
+            const targetVarVal = target.naming.variables[key] ?? 0;
+            const sourceVarVal = source.naming.variables[key] ?? 0;
+            target.naming.variables[key] = targetVarVal + sourceVarVal;
         }
-        // Error handling
         target.errorHandling.tryCatch += source.errorHandling.tryCatch;
         target.errorHandling.promiseCatch += source.errorHandling.promiseCatch;
         target.errorHandling.resultType += source.errorHandling.resultType;
-        // Import style
         target.importStyle.named += source.importStyle.named;
         target.importStyle.default += source.importStyle.default;
         target.importStyle.wildcard += source.importStyle.wildcard;
         target.importStyle.sideEffect += source.importStyle.sideEffect;
-        // Quote style
         target.quoteStyle.single += source.quoteStyle.single;
         target.quoteStyle.double += source.quoteStyle.double;
         target.quoteStyle.backtick += source.quoteStyle.backtick;
@@ -222,7 +217,6 @@ export class StyleDriftGate extends Gate {
     // ─── Baseline Comparison ─────────────────────────────────────────
     compareToBaseline(file, baseline) {
         const deviations = [];
-        // Compare function naming
         const fnDev = this.distributionDeviation(this.toRecord(file.naming.functions), this.toRecord(baseline.naming.functions));
         if (fnDev.score > 0) {
             deviations.push({
@@ -232,7 +226,6 @@ export class StyleDriftGate extends Gate {
                 suggestion: `Use ${fnDev.baselinePredominant} for function names to match project conventions.`,
             });
         }
-        // Compare variable naming
         const varDev = this.distributionDeviation(this.toRecord(file.naming.variables), this.toRecord(baseline.naming.variables));
         if (varDev.score > 0) {
             deviations.push({
@@ -242,7 +235,6 @@ export class StyleDriftGate extends Gate {
                 suggestion: `Use ${varDev.baselinePredominant} for variable names to match project conventions.`,
             });
         }
-        // Compare error handling
         const errDev = this.distributionDeviation(file.errorHandling, baseline.errorHandling);
         if (errDev.score > 0 && this.hasSignificantData(file.errorHandling)) {
             deviations.push({
@@ -252,7 +244,6 @@ export class StyleDriftGate extends Gate {
                 suggestion: `Use ${errDev.baselinePredominant} error handling pattern to match project conventions.`,
             });
         }
-        // Compare import style
         const impDev = this.distributionDeviation(file.importStyle, baseline.importStyle);
         if (impDev.score > 0 && this.hasSignificantData(file.importStyle)) {
             deviations.push({
@@ -264,42 +255,33 @@ export class StyleDriftGate extends Gate {
         }
         return deviations;
     }
-    /**
-     * Compare two distributions and return a deviation score (0-1).
-     * 0 = perfect match, 1 = completely different predominant style.
-     *
-     * Method: find the predominant category in each distribution.
-     * If they differ, score = how far the file is from the baseline's predominant category.
-     */
     distributionDeviation(file, baseline) {
         const fileTotal = Object.values(file).reduce((a, b) => a + b, 0);
         const baselineTotal = Object.values(baseline).reduce((a, b) => a + b, 0);
         if (fileTotal < 3 || baselineTotal < 5) {
             return { score: 0, filePredominant: 'N/A', baselinePredominant: 'N/A' };
         }
-        // Find predominant category
         const filePredominant = Object.entries(file).sort((a, b) => b[1] - a[1])[0][0];
         const baselinePredominant = Object.entries(baseline).sort((a, b) => b[1] - a[1])[0][0];
         if (filePredominant === baselinePredominant) {
             return { score: 0, filePredominant, baselinePredominant };
         }
-        // Calculate how much the file uses the baseline's predominant style
         const fileUseOfBaseline = (file[baselinePredominant] || 0) / fileTotal;
         const baselineUseOfBaseline = (baseline[baselinePredominant] || 0) / baselineTotal;
-        // Score = how far the file deviates from baseline's predominant ratio
         const deviation = Math.max(0, baselineUseOfBaseline - fileUseOfBaseline);
         return { score: deviation, filePredominant, baselinePredominant };
     }
     hasSignificantData(obj) {
         return Object.values(obj).reduce((a, b) => a + b, 0) >= 3;
     }
-    /** Convert a typed distribution to a generic Record for comparison */
     toRecord(dist) {
         return {
             camelCase: dist.camelCase,
             snake_case: dist.snake_case,
             PascalCase: dist.PascalCase,
             SCREAMING_SNAKE: dist.SCREAMING_SNAKE,
+            'kebab-case': dist['kebab-case'] || 0,
+            other: dist.other || 0,
         };
     }
 }

package/dist/gates/test-quality-matchers.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Test Quality Gate — Assertion Pattern Matchers and Test Anti-Patterns
+ *
+ * Contains assertion pattern matchers and test anti-pattern regexes.
+ */
+/**
+ * Regex patterns for detecting assertions in JavaScript/TypeScript tests
+ */
+export declare const JS_ASSERTION_PATTERNS: RegExp[];
+/**
+ * Regex patterns for detecting mocks in JavaScript/TypeScript tests
+ */
+export declare const JS_MOCK_PATTERNS: RegExp[];
+/**
+ * Regex patterns for detecting assertions in Python tests
+ */
+export declare const PYTHON_ASSERTION_PATTERNS: RegExp[];
+/**
+ * Regex patterns for detecting mocks in Python tests
+ */
+export declare const PYTHON_MOCK_PATTERNS: RegExp[];
+/**
+ * Test block pattern for JavaScript/TypeScript
+ */
+export declare const JS_TEST_START_PATTERN: RegExp;
+/**
+ * Python test function pattern
+ */
+export declare const PYTHON_TEST_FUNC_PATTERN: RegExp;
+/**
+ * Tautological assertion patterns for JavaScript
+ */
+export declare const JS_TAUTOLOGICAL_PATTERNS: RegExp[];
+/**
+ * Variable tautology pattern for JavaScript
+ */
+export declare const JS_VAR_TAUTOLOGY_PATTERN: RegExp;
+/**
+ * Snapshot test patterns
+ */
+export declare const SNAPSHOT_PATTERNS: RegExp[];
+/**
+ * Python tautological patterns
+ */
+export declare const PYTHON_TAUTOLOGICAL_PATTERNS: RegExp[];
+/**
+ * Python fixture decorator pattern
+ */
+export declare const PYTHON_FIXTURE_PATTERN: RegExp;
+/**
+ * Python conftest file name
+ */
+export declare const PYTHON_CONFTEST_NAME = "conftest.py";

package/dist/gates/test-quality-matchers.js

@@ -0,0 +1,86 @@
+/**
+ * Test Quality Gate — Assertion Pattern Matchers and Test Anti-Patterns
+ *
+ * Contains assertion pattern matchers and test anti-pattern regexes.
+ */
+/**
+ * Regex patterns for detecting assertions in JavaScript/TypeScript tests
+ */
+export const JS_ASSERTION_PATTERNS = [
+    /expect\s*\(/,
+    /assert\s*[.(]/,
+    /\.toEqual|\.toBe|\.toContain|\.toMatch|\.toThrow|\.toHaveBeenCalled|\.toHaveLength|\.toBeTruthy|\.toBeFalsy|\.toBeDefined|\.toBeNull|\.toBeUndefined|\.toBeGreaterThan|\.toBeLessThan|\.toHaveProperty|\.toStrictEqual|\.rejects|\.resolves/,
+];
+/**
+ * Regex patterns for detecting mocks in JavaScript/TypeScript tests
+ */
+export const JS_MOCK_PATTERNS = [
+    /jest\.fn\(/,
+    /vi\.fn\(/,
+    /jest\.mock\(/,
+    /vi\.mock\(/,
+    /jest\.spyOn\(/,
+    /vi\.spyOn\(/,
+    /sinon\.(stub|mock|spy)\(/,
+];
+/**
+ * Regex patterns for detecting assertions in Python tests
+ */
+export const PYTHON_ASSERTION_PATTERNS = [
+    /\bassert\s+/,
+    /self\.assert\w+\s*\(/,
+    /pytest\.raises\s*\(/,
+    /\.assert_called|\.assert_any_call/,
+];
+/**
+ * Regex patterns for detecting mocks in Python tests
+ */
+export const PYTHON_MOCK_PATTERNS = [
+    /mock\./,
+    /Mock\(/,
+    /patch\(/,
+    /MagicMock\(/,
+];
+/**
+ * Test block pattern for JavaScript/TypeScript
+ */
+export const JS_TEST_START_PATTERN = /^(?:it|test)\s*\(\s*['"`].*['"`]\s*,\s*(async\s+)?(?:\(\s*\)|function\s*\(\s*\)|\(\s*\{[^}]*\}\s*\))\s*(?:=>)?\s*\{/;
+/**
+ * Python test function pattern
+ */
+export const PYTHON_TEST_FUNC_PATTERN = /^(\s*)(?:def|async\s+def)\s+(test_\w+)\s*\(/;
+/**
+ * Tautological assertion patterns for JavaScript
+ */
+export const JS_TAUTOLOGICAL_PATTERNS = [
+    /expect\s*\(\s*true\s*\)\s*\.toBe\s*\(\s*true\s*\)/,
+    /expect\s*\(\s*false\s*\)\s*\.toBe\s*\(\s*false\s*\)/,
+    /expect\s*\(\s*1\s*\)\s*\.toBe\s*\(\s*1\s*\)/,
+];
+/**
+ * Variable tautology pattern for JavaScript
+ */
+export const JS_VAR_TAUTOLOGY_PATTERN = /expect\s*\(\s*(\w+)\s*\)\s*\.(?:toBe|toEqual|toStrictEqual)\s*\(\s*(\w+)\s*\)/;
+/**
+ * Snapshot test patterns
+ */
+export const SNAPSHOT_PATTERNS = [
+    /\.toMatchSnapshot\s*\(/,
+    /\.toMatchInlineSnapshot\s*\(/,
+];
+/**
+ * Python tautological patterns
+ */
+export const PYTHON_TAUTOLOGICAL_PATTERNS = [
+    /\bassert\s+True\s*$/,
+    /\bassert\s+1\s*==\s*1/,
+    /self\.assertTrue\s*\(\s*True\s*\)/,
+];
+/**
+ * Python fixture decorator pattern
+ */
+export const PYTHON_FIXTURE_PATTERN = /^@pytest\.fixture/;
+/**
+ * Python conftest file name
+ */
+export const PYTHON_CONFTEST_NAME = 'conftest.py';