@rigour-labs/core 2.19.1 → 2.20.0

package/dist/context.test.js

@@ -72,4 +72,158 @@ describe('Context Awareness Engine', () => {
         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);
+        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);
+        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) {
+        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');
+        }
+    });
 });

package/dist/gates/ast-handlers/typescript.js

@@ -57,9 +57,10 @@ export class TypeScriptHandler extends ASTHandler {
                     const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                     addFailure({
                         id: 'STALENESS_NO_VAR',
-                        title: `Stale 'var' keyword at line ${line}`,
+                        title: `Stale 'var' keyword`,
                         details: `Use 'const' or 'let' instead of 'var' in ${relativePath}:${line}`,
                         files: [relativePath],
+                        line,
                         hint: `Replace 'var' with 'const' (preferred) or 'let' for modern JavaScript.`
                     });
                 }
@@ -70,9 +71,10 @@ export class TypeScriptHandler extends ASTHandler {
                     const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                     addFailure({
                         id: 'STALENESS_NO_COMMONJS',
-                        title: `CommonJS require() at line ${line}`,
+                        title: `CommonJS require()`,
                         details: `Use ES6 'import' instead of 'require()' in ${relativePath}:${line}`,
                         files: [relativePath],
+                        line,
                         hint: `Replace require('module') with import module from 'module'.`
                     });
                 }
@@ -85,9 +87,10 @@ export class TypeScriptHandler extends ASTHandler {
                     const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                     addFailure({
                         id: 'STALENESS_NO_ARGUMENTS',
-                        title: `Legacy 'arguments' object at line ${line}`,
+                        title: `Legacy 'arguments' object`,
                         details: `Use rest parameters (...args) instead of 'arguments' in ${relativePath}:${line}`,
                         files: [relativePath],
+                        line,
                         hint: `Replace 'arguments' with rest parameters: function(...args) { }`
                     });
                 }
@@ -98,9 +101,10 @@ export class TypeScriptHandler extends ASTHandler {
                 const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                 addFailure({
                     id: 'SECURITY_PROTOTYPE_POLLUTION',
-                    title: `Direct __proto__ access at line ${line}`,
+                    title: `Direct __proto__ access`,
                     details: `Prototype pollution vulnerability in ${relativePath}:${line}`,
                     files: [relativePath],
+                    line,
                     hint: `Use Object.getPrototypeOf() or Object.setPrototypeOf() instead of __proto__.`
                 });
             }
@@ -111,9 +115,10 @@ export class TypeScriptHandler extends ASTHandler {
                     const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                     addFailure({
                         id: 'SECURITY_PROTOTYPE_POLLUTION',
-                        title: `Unsafe bracket notation access to '${accessKey}' at line ${line}`,
+                        title: `Unsafe bracket notation access to '${accessKey}'`,
                         details: `Potential prototype pollution via bracket notation in ${relativePath}:${line}`,
                         files: [relativePath],
+                        line,
                         hint: `Block access to '${accessKey}' property when handling user input. Use allowlist for object keys.`
                     });
                 }
@@ -130,9 +135,10 @@ export class TypeScriptHandler extends ASTHandler {
                             const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                             addFailure({
                                 id: 'SECURITY_PROTOTYPE_POLLUTION_MERGE',
-                                title: `Object.assign() merge pattern at line ${line}`,
+                                title: `Object.assign() merge pattern`,
                                 details: `Object.assign({}, ...) can propagate prototype pollution in ${relativePath}:${line}`,
                                 files: [relativePath],
+                                line,
                                 hint: `Validate and sanitize source objects before merging. Block __proto__ and constructor keys.`
                             });
                         }

package/dist/gates/base.d.ts

@@ -11,5 +11,5 @@ export declare abstract class Gate {
     readonly title: string;
     constructor(id: string, title: string);
     abstract run(context: GateContext): Promise<Failure[]>;
-    protected createFailure(details: string, files?: string[], hint?: string, title?: string): Failure;
+    protected createFailure(details: string, files?: string[], hint?: string, title?: string, line?: number, endLine?: number): Failure;
 }

package/dist/gates/base.js

@@ -5,12 +5,14 @@ export class Gate {
         this.id = id;
         this.title = title;
     }
-    createFailure(details, files, hint, title) {
+    createFailure(details, files, hint, title, line, endLine) {
         return {
             id: this.id,
             title: title || this.title,
             details,
             files,
+            line,
+            endLine,
             hint,
         };
     }

package/dist/gates/content.js

@@ -20,20 +20,17 @@ export class ContentGate extends Gate {
             patterns: context.patterns
         });
         const contents = await FileScanner.readFiles(context.cwd, files);
-        const violations = [];
+        const failures = [];
         for (const [file, content] of contents) {
-            for (const pattern of patterns) {
-                if (pattern.test(content)) {
-                    violations.push(file);
-                    break;
+            const lines = content.split('\n');
+            lines.forEach((line, index) => {
+                for (const pattern of patterns) {
+                    if (pattern.test(line)) {
+                        failures.push(this.createFailure(`Forbidden placeholder '${pattern.source}' found`, [file], 'Remove forbidden comments. address the root cause or create a tracked issue.', undefined, index + 1, index + 1));
+                    }
                 }
-            }
+            });
         }
-        if (violations.length > 0) {
-            return [
-                this.createFailure('Forbidden placeholders found in the following files:', violations, 'Remove all TODO and FIXME comments. Use the "Done is Done" mentality—address the root cause or create a tracked issue.'),
-            ];
-        }
-        return [];
+        return failures;
     }
 }

package/dist/gates/context.js

@@ -70,11 +70,22 @@ export class ContextGate extends Gate {
      * Collect naming patterns (function names, class names, variable names)
      */
     collectNamingPatterns(content, file, patterns) {
-        // Function declarations
-        const funcMatches = content.matchAll(/(?:function|const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[=(]/g);
-        for (const match of funcMatches) {
-            const name = match[1];
-            const casing = this.detectCasing(name);
+        // Named function declarations: function fetchData() { ... }
+        const namedFuncMatches = content.matchAll(/function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g);
+        for (const match of namedFuncMatches) {
+            const casing = this.detectCasing(match[1]);
+            this.addPattern(patterns, 'function', { casing, file, count: 1 });
+        }
+        // Arrow function expressions: (export) const fetchData = (async) (...) => { ... }
+        const arrowFuncMatches = content.matchAll(/(?:export\s+)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/g);
+        for (const match of arrowFuncMatches) {
+            const casing = this.detectCasing(match[1]);
+            this.addPattern(patterns, 'function', { casing, file, count: 1 });
+        }
+        // Function expressions: (export) const fetchData = (async) function(...) { ... }
+        const funcExprMatches = content.matchAll(/(?:export\s+)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?function\s*\(/g);
+        for (const match of funcExprMatches) {
+            const casing = this.detectCasing(match[1]);
             this.addPattern(patterns, 'function', { casing, file, count: 1 });
         }
         // Class declarations
@@ -175,6 +186,8 @@ export class ContextGate extends Gate {
             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 (e.g. fetch, use, get)
         if (/^[a-z]+(_[a-z]+)+$/.test(name))
             return 'snake_case';
         if (/^[A-Z]+(_[A-Z]+)*$/.test(name))

package/dist/gates/security-patterns.js

@@ -186,7 +186,7 @@ export class SecurityPatternsGate extends Gate {
         const blockThreshold = this.severityOrder[this.config.block_on_severity ?? 'high'];
         for (const vuln of filteredVulns) {
             if (this.severityOrder[vuln.severity] <= blockThreshold) {
-                failures.push(this.createFailure(`[${vuln.cwe}] ${vuln.description} at line ${vuln.line}`, [vuln.file], `Found: "${vuln.match.slice(0, 60)}..." - Use parameterized queries/sanitization.`, `Security: ${vuln.type.replace('_', ' ').toUpperCase()}`));
+                failures.push(this.createFailure(`[${vuln.cwe}] ${vuln.description}`, [vuln.file], `Found: "${vuln.match.slice(0, 60)}..." - Use parameterized queries/sanitization.`, `Security: ${vuln.type.replace('_', ' ').toUpperCase()}`, vuln.line, vuln.line));
             }
         }
         if (filteredVulns.length > 0 && failures.length === 0) {

package/dist/types/index.d.ts

@@ -1080,18 +1080,24 @@ export declare const FailureSchema: z.ZodObject<{
     title: z.ZodString;
     details: z.ZodString;
     files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    line: z.ZodOptional<z.ZodNumber>;
+    endLine: z.ZodOptional<z.ZodNumber>;
     hint: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     id: string;
     title: string;
     details: string;
     files?: string[] | undefined;
+    line?: number | undefined;
+    endLine?: number | undefined;
     hint?: string | undefined;
 }, {
     id: string;
     title: string;
     details: string;
     files?: string[] | undefined;
+    line?: number | undefined;
+    endLine?: number | undefined;
     hint?: string | undefined;
 }>;
 export type Failure = z.infer<typeof FailureSchema>;
@@ -1103,18 +1109,24 @@ export declare const ReportSchema: z.ZodObject<{
         title: z.ZodString;
         details: z.ZodString;
         files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        line: z.ZodOptional<z.ZodNumber>;
+        endLine: z.ZodOptional<z.ZodNumber>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         id: string;
         title: string;
         details: string;
         files?: string[] | undefined;
+        line?: number | undefined;
+        endLine?: number | undefined;
         hint?: string | undefined;
     }, {
         id: string;
         title: string;
         details: string;
         files?: string[] | undefined;
+        line?: number | undefined;
+        endLine?: number | undefined;
         hint?: string | undefined;
     }>, "many">;
     stats: z.ZodObject<{
@@ -1139,6 +1151,8 @@ export declare const ReportSchema: z.ZodObject<{
         title: string;
         details: string;
         files?: string[] | undefined;
+        line?: number | undefined;
+        endLine?: number | undefined;
         hint?: string | undefined;
     }[];
 }, {
@@ -1153,6 +1167,8 @@ export declare const ReportSchema: z.ZodObject<{
         title: string;
         details: string;
         files?: string[] | undefined;
+        line?: number | undefined;
+        endLine?: number | undefined;
         hint?: string | undefined;
     }[];
 }>;

package/dist/types/index.js

@@ -127,6 +127,8 @@ export const FailureSchema = z.object({
     title: z.string(),
     details: z.string(),
     files: z.array(z.string()).optional(),
+    line: z.number().optional(),
+    endLine: z.number().optional(),
     hint: z.string().optional(),
 });
 export const ReportSchema = z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "2.19.1",
+  "version": "2.20.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/context.test.ts

@@ -84,4 +84,173 @@ describe('Context Awareness Engine', () => {
         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');
+        }
+    });
 });

package/src/gates/ast-handlers/typescript.ts

@@ -65,9 +65,10 @@ export class TypeScriptHandler extends ASTHandler {
                     const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                     addFailure({
                         id: 'STALENESS_NO_VAR',
-                        title: `Stale 'var' keyword at line ${line}`,
+                        title: `Stale 'var' keyword`,
                         details: `Use 'const' or 'let' instead of 'var' in ${relativePath}:${line}`,
                         files: [relativePath],
+                        line,
                         hint: `Replace 'var' with 'const' (preferred) or 'let' for modern JavaScript.`
                     });
                 }
@@ -79,9 +80,10 @@ export class TypeScriptHandler extends ASTHandler {
                     const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                     addFailure({
                         id: 'STALENESS_NO_COMMONJS',
-                        title: `CommonJS require() at line ${line}`,
+                        title: `CommonJS require()`,
                         details: `Use ES6 'import' instead of 'require()' in ${relativePath}:${line}`,
                         files: [relativePath],
+                        line,
                         hint: `Replace require('module') with import module from 'module'.`
                     });
                 }
@@ -95,9 +97,10 @@ export class TypeScriptHandler extends ASTHandler {
                     const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                     addFailure({
                         id: 'STALENESS_NO_ARGUMENTS',
-                        title: `Legacy 'arguments' object at line ${line}`,
+                        title: `Legacy 'arguments' object`,
                         details: `Use rest parameters (...args) instead of 'arguments' in ${relativePath}:${line}`,
                         files: [relativePath],
+                        line,
                         hint: `Replace 'arguments' with rest parameters: function(...args) { }`
                     });
                 }
@@ -110,9 +113,10 @@ export class TypeScriptHandler extends ASTHandler {
                 const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                 addFailure({
                     id: 'SECURITY_PROTOTYPE_POLLUTION',
-                    title: `Direct __proto__ access at line ${line}`,
+                    title: `Direct __proto__ access`,
                     details: `Prototype pollution vulnerability in ${relativePath}:${line}`,
                     files: [relativePath],
+                    line,
                     hint: `Use Object.getPrototypeOf() or Object.setPrototypeOf() instead of __proto__.`
                 });
             }
@@ -124,9 +128,10 @@ export class TypeScriptHandler extends ASTHandler {
                     const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                     addFailure({
                         id: 'SECURITY_PROTOTYPE_POLLUTION',
-                        title: `Unsafe bracket notation access to '${accessKey}' at line ${line}`,
+                        title: `Unsafe bracket notation access to '${accessKey}'`,
                         details: `Potential prototype pollution via bracket notation in ${relativePath}:${line}`,
                         files: [relativePath],
+                        line,
                         hint: `Block access to '${accessKey}' property when handling user input. Use allowlist for object keys.`
                     });
                 }
@@ -144,9 +149,10 @@ export class TypeScriptHandler extends ASTHandler {
                             const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
                             addFailure({
                                 id: 'SECURITY_PROTOTYPE_POLLUTION_MERGE',
-                                title: `Object.assign() merge pattern at line ${line}`,
+                                title: `Object.assign() merge pattern`,
                                 details: `Object.assign({}, ...) can propagate prototype pollution in ${relativePath}:${line}`,
                                 files: [relativePath],
+                                line,
                                 hint: `Validate and sanitize source objects before merging. Block __proto__ and constructor keys.`
                             });
                         }

package/src/gates/base.ts

@@ -13,12 +13,14 @@ export abstract class Gate {
 
     abstract run(context: GateContext): Promise<Failure[]>;
 
-    protected createFailure(details: string, files?: string[], hint?: string, title?: string): Failure {
+    protected createFailure(details: string, files?: string[], hint?: string, title?: string, line?: number, endLine?: number): Failure {
         return {
             id: this.id,
             title: title || this.title,
             details,
             files,
+            line,
+            endLine,
             hint,
         };
     }

package/src/gates/content.ts

@@ -13,7 +13,7 @@ export class ContentGate extends Gate {
     }
 
     async run(context: GateContext): Promise<Failure[]> {
-        const patterns = [];
+        const patterns: RegExp[] = [];
         if (this.config.forbidTodos) patterns.push(/TODO/i);
         if (this.config.forbidFixme) patterns.push(/FIXME/i);
 
@@ -26,26 +26,25 @@ export class ContentGate extends Gate {
         });
         const contents = await FileScanner.readFiles(context.cwd, files);
 
-        const violations: string[] = [];
+        const failures: Failure[] = [];
         for (const [file, content] of contents) {
-            for (const pattern of patterns) {
-                if (pattern.test(content)) {
-                    violations.push(file);
-                    break;
+            const lines = content.split('\n');
+            lines.forEach((line, index) => {
+                for (const pattern of patterns) {
+                    if (pattern.test(line)) {
+                        failures.push(this.createFailure(
+                            `Forbidden placeholder '${pattern.source}' found`,
+                            [file],
+                            'Remove forbidden comments. address the root cause or create a tracked issue.',
+                            undefined,
+                            index + 1,
+                            index + 1
+                        ));
+                    }
                 }
-            }
+            });
         }
 
-        if (violations.length > 0) {
-            return [
-                this.createFailure(
-                    'Forbidden placeholders found in the following files:',
-                    violations,
-                    'Remove all TODO and FIXME comments. Use the "Done is Done" mentality—address the root cause or create a tracked issue.'
-                ),
-            ];
-        }
-
-        return [];
+        return failures;
     }
 }

package/src/gates/context.ts

@@ -107,11 +107,24 @@ export class ContextGate extends Gate {
         file: string,
         patterns: Map<string, { casing: string; file: string; count: number }[]>
     ) {
-        // Function declarations
-        const funcMatches = content.matchAll(/(?:function|const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[=(]/g);
-        for (const match of funcMatches) {
-            const name = match[1];
-            const casing = this.detectCasing(name);
+        // Named function declarations: function fetchData() { ... }
+        const namedFuncMatches = content.matchAll(/function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g);
+        for (const match of namedFuncMatches) {
+            const casing = this.detectCasing(match[1]);
+            this.addPattern(patterns, 'function', { casing, file, count: 1 });
+        }
+
+        // Arrow function expressions: (export) const fetchData = (async) (...) => { ... }
+        const arrowFuncMatches = content.matchAll(/(?:export\s+)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/g);
+        for (const match of arrowFuncMatches) {
+            const casing = this.detectCasing(match[1]);
+            this.addPattern(patterns, 'function', { casing, file, count: 1 });
+        }
+
+        // Function expressions: (export) const fetchData = (async) function(...) { ... }
+        const funcExprMatches = content.matchAll(/(?:export\s+)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?function\s*\(/g);
+        for (const match of funcExprMatches) {
+            const casing = this.detectCasing(match[1]);
             this.addPattern(patterns, 'function', { casing, file, count: 1 });
         }
 
@@ -234,6 +247,7 @@ export class ContextGate extends Gate {
     private 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 (e.g. fetch, use, get)
         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';

package/src/gates/security-patterns.ts

@@ -231,10 +231,12 @@ export class SecurityPatternsGate extends Gate {
         for (const vuln of filteredVulns) {
             if (this.severityOrder[vuln.severity] <= blockThreshold) {
                 failures.push(this.createFailure(
-                    `[${vuln.cwe}] ${vuln.description} at line ${vuln.line}`,
+                    `[${vuln.cwe}] ${vuln.description}`,
                     [vuln.file],
                     `Found: "${vuln.match.slice(0, 60)}..." - Use parameterized queries/sanitization.`,
-                    `Security: ${vuln.type.replace('_', ' ').toUpperCase()}`
+                    `Security: ${vuln.type.replace('_', ' ').toUpperCase()}`,
+                    vuln.line,
+                    vuln.line
                 ));
             }
         }

package/src/types/index.ts

@@ -141,6 +141,8 @@ export const FailureSchema = z.object({
     title: z.string(),
     details: z.string(),
     files: z.array(z.string()).optional(),
+    line: z.number().optional(),
+    endLine: z.number().optional(),
     hint: z.string().optional(),
 });
 export type Failure = z.infer<typeof FailureSchema>;