@rigour-labs/core 2.22.0 → 3.0.0

package/dist/types/index.d.ts

@@ -293,6 +293,28 @@ export declare const GatesSchema: z.ZodObject<{
         degradation_threshold?: number | undefined;
         signals_required?: number | undefined;
     }>>>;
+    promise_safety: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        check_unhandled_then: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        check_unsafe_parse: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        check_async_without_await: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        check_unsafe_fetch: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        ignore_patterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        ignore_patterns: string[];
+        check_unhandled_then: boolean;
+        check_unsafe_parse: boolean;
+        check_async_without_await: boolean;
+        check_unsafe_fetch: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        ignore_patterns?: string[] | undefined;
+        check_unhandled_then?: boolean | undefined;
+        check_unsafe_parse?: boolean | undefined;
+        check_async_without_await?: boolean | undefined;
+        check_unsafe_fetch?: boolean | undefined;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     max_file_lines: number;
     forbid_todos: boolean;
@@ -403,6 +425,14 @@ export declare const GatesSchema: z.ZodObject<{
         degradation_threshold: number;
         signals_required: number;
     };
+    promise_safety: {
+        enabled: boolean;
+        ignore_patterns: string[];
+        check_unhandled_then: boolean;
+        check_unsafe_parse: boolean;
+        check_async_without_await: boolean;
+        check_unsafe_fetch: boolean;
+    };
 }, {
     max_file_lines?: number | undefined;
     forbid_todos?: boolean | undefined;
@@ -513,6 +543,14 @@ export declare const GatesSchema: z.ZodObject<{
         degradation_threshold?: number | undefined;
         signals_required?: number | undefined;
     } | undefined;
+    promise_safety?: {
+        enabled?: boolean | undefined;
+        ignore_patterns?: string[] | undefined;
+        check_unhandled_then?: boolean | undefined;
+        check_unsafe_parse?: boolean | undefined;
+        check_async_without_await?: boolean | undefined;
+        check_unsafe_fetch?: boolean | undefined;
+    } | undefined;
 }>;
 export declare const CommandsSchema: z.ZodObject<{
     format: z.ZodOptional<z.ZodString>;
@@ -844,6 +882,28 @@ export declare const ConfigSchema: z.ZodObject<{
             degradation_threshold?: number | undefined;
             signals_required?: number | undefined;
         }>>>;
+        promise_safety: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            check_unhandled_then: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            check_unsafe_parse: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            check_async_without_await: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            check_unsafe_fetch: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            ignore_patterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            ignore_patterns: string[];
+            check_unhandled_then: boolean;
+            check_unsafe_parse: boolean;
+            check_async_without_await: boolean;
+            check_unsafe_fetch: boolean;
+        }, {
+            enabled?: boolean | undefined;
+            ignore_patterns?: string[] | undefined;
+            check_unhandled_then?: boolean | undefined;
+            check_unsafe_parse?: boolean | undefined;
+            check_async_without_await?: boolean | undefined;
+            check_unsafe_fetch?: boolean | undefined;
+        }>>>;
     }, "strip", z.ZodTypeAny, {
         max_file_lines: number;
         forbid_todos: boolean;
@@ -954,6 +1014,14 @@ export declare const ConfigSchema: z.ZodObject<{
             degradation_threshold: number;
             signals_required: number;
         };
+        promise_safety: {
+            enabled: boolean;
+            ignore_patterns: string[];
+            check_unhandled_then: boolean;
+            check_unsafe_parse: boolean;
+            check_async_without_await: boolean;
+            check_unsafe_fetch: boolean;
+        };
     }, {
         max_file_lines?: number | undefined;
         forbid_todos?: boolean | undefined;
@@ -1064,6 +1132,14 @@ export declare const ConfigSchema: z.ZodObject<{
             degradation_threshold?: number | undefined;
             signals_required?: number | undefined;
         } | undefined;
+        promise_safety?: {
+            enabled?: boolean | undefined;
+            ignore_patterns?: string[] | undefined;
+            check_unhandled_then?: boolean | undefined;
+            check_unsafe_parse?: boolean | undefined;
+            check_async_without_await?: boolean | undefined;
+            check_unsafe_fetch?: boolean | undefined;
+        } | undefined;
     }>>>;
     output: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         report_path: z.ZodDefault<z.ZodString>;
@@ -1193,6 +1269,14 @@ export declare const ConfigSchema: z.ZodObject<{
             degradation_threshold: number;
             signals_required: number;
         };
+        promise_safety: {
+            enabled: boolean;
+            ignore_patterns: string[];
+            check_unhandled_then: boolean;
+            check_unsafe_parse: boolean;
+            check_async_without_await: boolean;
+            check_unsafe_fetch: boolean;
+        };
     };
     output: {
         report_path: string;
@@ -1321,6 +1405,14 @@ export declare const ConfigSchema: z.ZodObject<{
             degradation_threshold?: number | undefined;
             signals_required?: number | undefined;
         } | undefined;
+        promise_safety?: {
+            enabled?: boolean | undefined;
+            ignore_patterns?: string[] | undefined;
+            check_unhandled_then?: boolean | undefined;
+            check_unsafe_parse?: boolean | undefined;
+            check_async_without_await?: boolean | undefined;
+            check_unsafe_fetch?: boolean | undefined;
+        } | undefined;
     } | undefined;
     output?: {
         report_path?: string | undefined;
@@ -1337,6 +1429,9 @@ export declare const StatusSchema: z.ZodEnum<["PASS", "FAIL", "SKIP", "ERROR"]>;
 export type Status = z.infer<typeof StatusSchema>;
 export declare const SeveritySchema: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
 export type Severity = z.infer<typeof SeveritySchema>;
+/** Provenance tags — lets dashboards/agents filter by what matters */
+export declare const ProvenanceSchema: z.ZodEnum<["ai-drift", "traditional", "security", "governance"]>;
+export type Provenance = z.infer<typeof ProvenanceSchema>;
 /** Severity weights for score calculation */
 export declare const SEVERITY_WEIGHTS: Record<Severity, number>;
 export declare const FailureSchema: z.ZodObject<{
@@ -1344,6 +1439,7 @@ export declare const FailureSchema: z.ZodObject<{
     title: z.ZodString;
     details: z.ZodString;
     severity: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low", "info"]>>;
+    provenance: z.ZodOptional<z.ZodEnum<["ai-drift", "traditional", "security", "governance"]>>;
     files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     line: z.ZodOptional<z.ZodNumber>;
     endLine: z.ZodOptional<z.ZodNumber>;
@@ -1353,6 +1449,7 @@ export declare const FailureSchema: z.ZodObject<{
     title: string;
     details: string;
     severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+    provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
     files?: string[] | undefined;
     line?: number | undefined;
     endLine?: number | undefined;
@@ -1362,6 +1459,7 @@ export declare const FailureSchema: z.ZodObject<{
     title: string;
     details: string;
     severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+    provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
     files?: string[] | undefined;
     line?: number | undefined;
     endLine?: number | undefined;
@@ -1376,6 +1474,7 @@ export declare const ReportSchema: z.ZodObject<{
         title: z.ZodString;
         details: z.ZodString;
         severity: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low", "info"]>>;
+        provenance: z.ZodOptional<z.ZodEnum<["ai-drift", "traditional", "security", "governance"]>>;
         files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         line: z.ZodOptional<z.ZodNumber>;
         endLine: z.ZodOptional<z.ZodNumber>;
@@ -1385,6 +1484,7 @@ export declare const ReportSchema: z.ZodObject<{
         title: string;
         details: string;
         severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
         files?: string[] | undefined;
         line?: number | undefined;
         endLine?: number | undefined;
@@ -1394,6 +1494,7 @@ export declare const ReportSchema: z.ZodObject<{
         title: string;
         details: string;
         severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
         files?: string[] | undefined;
         line?: number | undefined;
         endLine?: number | undefined;
@@ -1402,21 +1503,63 @@ export declare const ReportSchema: z.ZodObject<{
     stats: z.ZodObject<{
         duration_ms: z.ZodNumber;
         score: z.ZodOptional<z.ZodNumber>;
+        ai_health_score: z.ZodOptional<z.ZodNumber>;
+        structural_score: z.ZodOptional<z.ZodNumber>;
         severity_breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        provenance_breakdown: z.ZodOptional<z.ZodObject<{
+            'ai-drift': z.ZodNumber;
+            traditional: z.ZodNumber;
+            security: z.ZodNumber;
+            governance: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        }, {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         duration_ms: number;
         score?: number | undefined;
+        ai_health_score?: number | undefined;
+        structural_score?: number | undefined;
         severity_breakdown?: Record<string, number> | undefined;
+        provenance_breakdown?: {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        } | undefined;
     }, {
         duration_ms: number;
         score?: number | undefined;
+        ai_health_score?: number | undefined;
+        structural_score?: number | undefined;
         severity_breakdown?: Record<string, number> | undefined;
+        provenance_breakdown?: {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        } | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     stats: {
         duration_ms: number;
         score?: number | undefined;
+        ai_health_score?: number | undefined;
+        structural_score?: number | undefined;
         severity_breakdown?: Record<string, number> | undefined;
+        provenance_breakdown?: {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        } | undefined;
     };
     status: "PASS" | "FAIL" | "SKIP" | "ERROR";
     summary: Record<string, "PASS" | "FAIL" | "SKIP" | "ERROR">;
@@ -1425,6 +1568,7 @@ export declare const ReportSchema: z.ZodObject<{
         title: string;
         details: string;
         severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
         files?: string[] | undefined;
         line?: number | undefined;
         endLine?: number | undefined;
@@ -1434,7 +1578,15 @@ export declare const ReportSchema: z.ZodObject<{
     stats: {
         duration_ms: number;
         score?: number | undefined;
+        ai_health_score?: number | undefined;
+        structural_score?: number | undefined;
         severity_breakdown?: Record<string, number> | undefined;
+        provenance_breakdown?: {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        } | undefined;
     };
     status: "PASS" | "FAIL" | "SKIP" | "ERROR";
     summary: Record<string, "PASS" | "FAIL" | "SKIP" | "ERROR">;
@@ -1443,6 +1595,7 @@ export declare const ReportSchema: z.ZodObject<{
         title: string;
         details: string;
         severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
         files?: string[] | undefined;
         line?: number | undefined;
         endLine?: number | undefined;

package/dist/types/index.js

@@ -129,6 +129,14 @@ export const GatesSchema = z.object({
         degradation_threshold: z.number().min(0).max(1).optional().default(0.4),
         signals_required: z.number().optional().default(2),
     }).optional().default({}),
+    promise_safety: z.object({
+        enabled: z.boolean().optional().default(true),
+        check_unhandled_then: z.boolean().optional().default(true),
+        check_unsafe_parse: z.boolean().optional().default(true),
+        check_async_without_await: z.boolean().optional().default(true),
+        check_unsafe_fetch: z.boolean().optional().default(true),
+        ignore_patterns: z.array(z.string()).optional().default([]),
+    }).optional().default({}),
 });
 export const CommandsSchema = z.object({
     format: z.string().optional(),
@@ -150,6 +158,8 @@ export const ConfigSchema = z.object({
 });
 export const StatusSchema = z.enum(['PASS', 'FAIL', 'SKIP', 'ERROR']);
 export const SeveritySchema = z.enum(['critical', 'high', 'medium', 'low', 'info']);
+/** Provenance tags — lets dashboards/agents filter by what matters */
+export const ProvenanceSchema = z.enum(['ai-drift', 'traditional', 'security', 'governance']);
 /** Severity weights for score calculation */
 export const SEVERITY_WEIGHTS = {
     critical: 20,
@@ -163,6 +173,7 @@ export const FailureSchema = z.object({
     title: z.string(),
     details: z.string(),
     severity: SeveritySchema.optional(),
+    provenance: ProvenanceSchema.optional(),
     files: z.array(z.string()).optional(),
     line: z.number().optional(),
     endLine: z.number().optional(),
@@ -175,6 +186,14 @@ export const ReportSchema = z.object({
     stats: z.object({
         duration_ms: z.number(),
         score: z.number().optional(),
+        ai_health_score: z.number().optional(),
+        structural_score: z.number().optional(),
         severity_breakdown: z.record(z.number()).optional(),
+        provenance_breakdown: z.object({
+            'ai-drift': z.number(),
+            traditional: z.number(),
+            security: z.number(),
+            governance: z.number(),
+        }).optional(),
     }),
 });

package/package.json

@@ -1,7 +1,27 @@
 {
   "name": "@rigour-labs/core",
-  "version": "2.22.0",
+  "version": "3.0.0",
+  "description": "Deterministic quality gate engine for AI-generated code. AST analysis, drift detection, and Fix Packet generation across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
+  "license": "MIT",
+  "homepage": "https://rigour.run",
+  "keywords": [
+    "quality-gates",
+    "ai-code-quality",
+    "static-analysis",
+    "ast",
+    "drift-detection",
+    "code-review",
+    "linter",
+    "typescript",
+    "python",
+    "golang",
+    "csharp"
+  ],
   "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {

package/src/context.test.ts

@@ -1,256 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { GateRunner } from '../src/gates/runner.js';
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const TEST_CWD = path.join(__dirname, '../temp-test-context');
-
-describe('Context Awareness Engine', () => {
-    beforeAll(async () => {
-        await fs.ensureDir(TEST_CWD);
-    });
-
-    afterAll(async () => {
-        await fs.remove(TEST_CWD);
-    });
-
-    it('should detect context drift for redundant env suffixes (Golden Example)', async () => {
-        // Setup: Define standard GCP_PROJECT_ID
-        await fs.writeFile(path.join(TEST_CWD, '.env.example'), 'GCP_PROJECT_ID=my-project\n');
-
-        // Setup: Use drifted GCP_PROJECT_ID_PRODUCTION
-        await fs.writeFile(path.join(TEST_CWD, 'feature.js'), `
-            const id = process.env.GCP_PROJECT_ID_PRODUCTION;
-            console.log(id);
-        `);
-
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-
-        const runner = new GateRunner(config as any);
-        const report = await runner.run(TEST_CWD);
-
-        const driftFailures = report.failures.filter(f => f.id === 'context-drift');
-        expect(driftFailures.length).toBeGreaterThan(0);
-        expect(driftFailures[0].details).toContain('GCP_PROJECT_ID_PRODUCTION');
-        expect(driftFailures[0].hint).toContain('GCP_PROJECT_ID');
-    });
-
-    it('should not flag valid environment variables', async () => {
-        await fs.writeFile(path.join(TEST_CWD, 'valid.js'), `
-            const id = process.env.GCP_PROJECT_ID;
-        `);
-
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 100,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-
-        const runner = new GateRunner(config as any);
-        const report = await runner.run(TEST_CWD);
-
-        const driftFailures = report.failures.filter(f => f.id === 'context-drift');
-        // Filter out failures from other files if they still exist in TEST_CWD
-        const specificFailures = driftFailures.filter(f => f.files?.includes('valid.js'));
-        expect(specificFailures.length).toBe(0);
-    });
-    it('should classify arrow function exports as camelCase, not unknown', async () => {
-        // Create files with arrow function patterns that previously returned 'unknown'
-        await fs.writeFile(path.join(TEST_CWD, 'api.ts'), `
-            export const fetchData = async () => { return []; };
-            export const getUserProfile = async (id: string) => { return {}; };
-            export const use = () => {};
-            export const get = async () => {};
-            const handleClick = (e: Event) => {};
-            let processItem = async (item: any) => {};
-        `);
-
-        // Create a second file with consistent arrow function naming
-        await fs.writeFile(path.join(TEST_CWD, 'service.ts'), `
-            export const createUser = async (data: any) => {};
-            export const deleteUser = async (id: string) => {};
-            export const updateUser = async (id: string, data: any) => {};
-        `);
-
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-
-        const runner = new GateRunner(config as any);
-        const report = await runner.run(TEST_CWD);
-
-        // Should NOT have any "unknown" naming convention failures
-        const namingFailures = report.failures.filter(f =>
-            f.id === 'context-drift' && f.details?.includes('unknown')
-        );
-        expect(namingFailures.length).toBe(0);
-    });
-
-    it('should not classify plain variable declarations as function patterns', async () => {
-        // Create file with non-function const declarations
-        await fs.writeFile(path.join(TEST_CWD, 'constants.ts'), `
-            export const API_URL = 'https://api.example.com';
-            export const MAX_RETRIES = 3;
-            const config = { timeout: 5000 };
-            let count = 0;
-        `);
-
-        // Create file with actual functions for a dominant pattern
-        await fs.writeFile(path.join(TEST_CWD, 'utils.ts'), `
-            function getData() { return []; }
-            function setData(d: any) { return d; }
-            function processRequest(req: any) { return req; }
-        `);
-
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-
-        const runner = new GateRunner(config as any);
-        const report = await runner.run(TEST_CWD);
-
-        // SCREAMING_SNAKE constants should NOT create naming drift failures
-        // because they should not be in the 'function' pattern bucket at all
-        const namingFailures = report.failures.filter(f =>
-            f.id === 'context-drift' && f.details?.includes('SCREAMING_SNAKE')
-        );
-        expect(namingFailures.length).toBe(0);
-    });
-});
-
-/**
- * Direct unit tests for detectCasing logic
- */
-describe('detectCasing classification', () => {
-    // We test the regex rules directly since detectCasing is private
-    function detectCasing(name: string): string {
-        if (/^[A-Z][a-z]/.test(name) && /[a-z][A-Z]/.test(name)) return 'PascalCase';
-        if (/^[a-z]/.test(name) && /[a-z][A-Z]/.test(name)) return 'camelCase';
-        if (/^[a-z][a-zA-Z0-9]*$/.test(name)) return 'camelCase';  // single-word lowercase
-        if (/^[a-z]+(_[a-z]+)+$/.test(name)) return 'snake_case';
-        if (/^[A-Z]+(_[A-Z]+)*$/.test(name)) return 'SCREAMING_SNAKE';
-        if (/^[A-Z][a-zA-Z]*$/.test(name)) return 'PascalCase';
-        return 'unknown';
-    }
-
-    // Multi-word camelCase
-    it('classifies multi-word camelCase', () => {
-        expect(detectCasing('fetchData')).toBe('camelCase');
-        expect(detectCasing('getUserProfile')).toBe('camelCase');
-        expect(detectCasing('handleClick')).toBe('camelCase');
-        expect(detectCasing('processItem')).toBe('camelCase');
-        expect(detectCasing('createNewUser')).toBe('camelCase');
-    });
-
-    // Single-word lowercase (the bug fix)
-    it('classifies single-word lowercase as camelCase', () => {
-        expect(detectCasing('fetch')).toBe('camelCase');
-        expect(detectCasing('use')).toBe('camelCase');
-        expect(detectCasing('get')).toBe('camelCase');
-        expect(detectCasing('set')).toBe('camelCase');
-        expect(detectCasing('run')).toBe('camelCase');
-        expect(detectCasing('a')).toBe('camelCase');
-        expect(detectCasing('x')).toBe('camelCase');
-        expect(detectCasing('id')).toBe('camelCase');
-    });
-
-    // Single-word lowercase with digits
-    it('classifies lowercase with digits as camelCase', () => {
-        expect(detectCasing('handler2')).toBe('camelCase');
-        expect(detectCasing('config3')).toBe('camelCase');
-        expect(detectCasing('v2')).toBe('camelCase');
-    });
-
-    // PascalCase
-    it('classifies PascalCase', () => {
-        expect(detectCasing('MyComponent')).toBe('PascalCase');
-        expect(detectCasing('UserService')).toBe('PascalCase');
-        expect(detectCasing('App')).toBe('PascalCase');
-        expect(detectCasing('A')).toBe('SCREAMING_SNAKE'); // single uppercase letter
-    });
-
-    // snake_case
-    it('classifies snake_case', () => {
-        expect(detectCasing('my_func')).toBe('snake_case');
-        expect(detectCasing('get_data')).toBe('snake_case');
-        expect(detectCasing('process_all_items')).toBe('snake_case');
-    });
-
-    // SCREAMING_SNAKE
-    it('classifies SCREAMING_SNAKE_CASE', () => {
-        expect(detectCasing('API_URL')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('MAX_RETRIES')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('A')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('DB')).toBe('SCREAMING_SNAKE');
-    });
-
-    // Edge cases that should NOT be unknown
-    it('does not return unknown for valid identifiers', () => {
-        const validIdentifiers = [
-            'fetch', 'getData', 'MyClass', 'my_func', 'API_KEY',
-            'use', 'run', 'a', 'x', 'id', 'App', 'handler2',
-            'processItem', 'UserProfile', 'get_all_data', 'MAX_SIZE',
-        ];
-        for (const name of validIdentifiers) {
-            expect(detectCasing(name)).not.toBe('unknown');
-        }
-    });
-});