@rigour-labs/core 2.14.0 → 2.16.0

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

@@ -14,14 +14,89 @@ export class TypeScriptHandler extends ASTHandler {
     }
     analyzeSourceFile(sourceFile, relativePath, failures) {
         const astConfig = this.config.ast || {};
+        const stalenessConfig = this.config.staleness || {};
+        const stalenessRules = stalenessConfig.rules || {};
         const maxComplexity = astConfig.complexity || 10;
         const maxMethods = astConfig.max_methods || 10;
         const maxParams = astConfig.max_params || 5;
+        // Limit failures per file to avoid output bloat on large files
+        const MAX_FAILURES_PER_FILE = 50;
+        const fileFailureCount = {};
+        const addFailure = (failure) => {
+            const ruleId = failure.id;
+            fileFailureCount[ruleId] = (fileFailureCount[ruleId] || 0) + 1;
+            if (fileFailureCount[ruleId] <= MAX_FAILURES_PER_FILE) {
+                failures.push(failure);
+                return true;
+            }
+            // Add summary failure once when limit is reached
+            if (fileFailureCount[ruleId] === MAX_FAILURES_PER_FILE + 1) {
+                failures.push({
+                    id: `${ruleId}_LIMIT_EXCEEDED`,
+                    title: `More than ${MAX_FAILURES_PER_FILE} ${ruleId} violations in ${relativePath}`,
+                    details: `Truncated output: showing first ${MAX_FAILURES_PER_FILE} violations. Consider fixing the root cause.`,
+                    files: [relativePath],
+                    hint: `This file has many violations. Fix them systematically or exclude the file if it's legacy code.`
+                });
+            }
+            return false;
+        };
+        // Helper to check if a staleness rule is enabled
+        const isRuleEnabled = (rule) => {
+            if (!stalenessConfig.enabled)
+                return false;
+            return stalenessRules[rule] !== false; // Enabled by default if staleness is on
+        };
         const visit = (node) => {
+            // === STALENESS CHECKS (Rule-based) ===
+            // no-var: Forbid legacy 'var' keyword
+            if (isRuleEnabled('no-var') && ts.isVariableStatement(node)) {
+                const declarationList = node.declarationList;
+                // NodeFlags: Let = 1, Const = 2, None = 0 (var)
+                if ((declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) === 0) {
+                    const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                    addFailure({
+                        id: 'STALENESS_NO_VAR',
+                        title: `Stale 'var' keyword at line ${line}`,
+                        details: `Use 'const' or 'let' instead of 'var' in ${relativePath}:${line}`,
+                        files: [relativePath],
+                        hint: `Replace 'var' with 'const' (preferred) or 'let' for modern JavaScript.`
+                    });
+                }
+            }
+            // no-commonjs: Forbid require() in favor of import
+            if (isRuleEnabled('no-commonjs') && ts.isCallExpression(node)) {
+                if (ts.isIdentifier(node.expression) && node.expression.text === 'require') {
+                    const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                    addFailure({
+                        id: 'STALENESS_NO_COMMONJS',
+                        title: `CommonJS require() at line ${line}`,
+                        details: `Use ES6 'import' instead of 'require()' in ${relativePath}:${line}`,
+                        files: [relativePath],
+                        hint: `Replace require('module') with import module from 'module'.`
+                    });
+                }
+            }
+            // no-arguments: Forbid 'arguments' object (use rest params)
+            if (isRuleEnabled('no-arguments') && ts.isIdentifier(node) && node.text === 'arguments') {
+                // Check if it's actually the arguments keyword and not a variable named arguments
+                const parent = node.parent;
+                if (!ts.isVariableDeclaration(parent) && !ts.isPropertyAccessExpression(parent)) {
+                    const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                    addFailure({
+                        id: 'STALENESS_NO_ARGUMENTS',
+                        title: `Legacy 'arguments' object at line ${line}`,
+                        details: `Use rest parameters (...args) instead of 'arguments' in ${relativePath}:${line}`,
+                        files: [relativePath],
+                        hint: `Replace 'arguments' with rest parameters: function(...args) { }`
+                    });
+                }
+            }
+            // === COMPLEXITY CHECKS ===
             if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isArrowFunction(node)) {
                 const name = this.getNodeName(node);
                 if (node.parameters.length > maxParams) {
-                    failures.push({
+                    addFailure({
                         id: 'AST_MAX_PARAMS',
                         title: `Function '${name}' has ${node.parameters.length} parameters (max: ${maxParams})`,
                         details: `High parameter count detected in ${relativePath}`,
@@ -46,7 +121,7 @@ export class TypeScriptHandler extends ASTHandler {
                 };
                 ts.forEachChild(node, countComplexity);
                 if (complexity > maxComplexity) {
-                    failures.push({
+                    addFailure({
                         id: 'AST_COMPLEXITY',
                         title: `Function '${name}' has cyclomatic complexity of ${complexity} (max: ${maxComplexity})`,
                         details: `High complexity detected in ${relativePath}`,
@@ -59,7 +134,7 @@ export class TypeScriptHandler extends ASTHandler {
                 const name = node.name?.text || 'Anonymous Class';
                 const methods = node.members.filter(ts.isMethodDeclaration);
                 if (methods.length > maxMethods) {
-                    failures.push({
+                    addFailure({
                         id: 'AST_MAX_METHODS',
                         title: `Class '${name}' has ${methods.length} methods (max: ${maxMethods})`,
                         details: `God Object pattern detected in ${relativePath}`,

package/dist/services/context-engine.js

@@ -31,7 +31,7 @@ export class ContextEngine {
             }
             catch (e) { }
         }
-        console.log(`[ContextEngine] Discovered ${envVars.size} env anchors`);
+        // Logs removed to avoid stdout pollution in JSON mode
         // Convert envVars to anchors
         for (const [name, count] of envVars.entries()) {
             const confidence = count >= 2 ? 1 : 0.5;

package/dist/templates/index.js

@@ -192,6 +192,19 @@ export const UNIVERSAL_CONFIG = {
             auto_classify: true,
             doc_sources: {},
         },
+        staleness: {
+            enabled: false,
+            rules: {
+                'no-var': true,
+                'no-commonjs': false,
+                'no-arguments': false,
+                'prefer-arrow': false,
+                'prefer-template': false,
+                'prefer-spread': false,
+                'prefer-rest': false,
+                'prefer-const': false,
+            },
+        },
     },
     output: {
         report_path: 'rigour-report.json',

package/dist/types/index.d.ts

@@ -30,6 +30,16 @@ export declare const GatesSchema: z.ZodObject<{
         max_class_dependencies?: number | undefined;
         max_function_lines?: number | undefined;
     }>>>;
+    staleness: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        rules: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        rules: Record<string, boolean>;
+    }, {
+        enabled?: boolean | undefined;
+        rules?: Record<string, boolean> | undefined;
+    }>>>;
     dependencies: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         forbid: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
         trusted_registry: z.ZodOptional<z.ZodString>;
@@ -140,6 +150,10 @@ export declare const GatesSchema: z.ZodObject<{
         max_class_dependencies: number;
         max_function_lines: number;
     };
+    staleness: {
+        enabled: boolean;
+        rules: Record<string, boolean>;
+    };
     dependencies: {
         forbid: string[];
         trusted_registry?: string | undefined;
@@ -188,6 +202,10 @@ export declare const GatesSchema: z.ZodObject<{
         max_class_dependencies?: number | undefined;
         max_function_lines?: number | undefined;
     } | undefined;
+    staleness?: {
+        enabled?: boolean | undefined;
+        rules?: Record<string, boolean> | undefined;
+    } | undefined;
     dependencies?: {
         forbid?: string[] | undefined;
         trusted_registry?: string | undefined;
@@ -289,6 +307,16 @@ export declare const ConfigSchema: z.ZodObject<{
             max_class_dependencies?: number | undefined;
             max_function_lines?: number | undefined;
         }>>>;
+        staleness: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            rules: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            rules: Record<string, boolean>;
+        }, {
+            enabled?: boolean | undefined;
+            rules?: Record<string, boolean> | undefined;
+        }>>>;
         dependencies: z.ZodDefault<z.ZodOptional<z.ZodObject<{
             forbid: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
             trusted_registry: z.ZodOptional<z.ZodString>;
@@ -399,6 +427,10 @@ export declare const ConfigSchema: z.ZodObject<{
             max_class_dependencies: number;
             max_function_lines: number;
         };
+        staleness: {
+            enabled: boolean;
+            rules: Record<string, boolean>;
+        };
         dependencies: {
             forbid: string[];
             trusted_registry?: string | undefined;
@@ -447,6 +479,10 @@ export declare const ConfigSchema: z.ZodObject<{
             max_class_dependencies?: number | undefined;
             max_function_lines?: number | undefined;
         } | undefined;
+        staleness?: {
+            enabled?: boolean | undefined;
+            rules?: Record<string, boolean> | undefined;
+        } | undefined;
         dependencies?: {
             forbid?: string[] | undefined;
             trusted_registry?: string | undefined;
@@ -514,6 +550,10 @@ export declare const ConfigSchema: z.ZodObject<{
             max_class_dependencies: number;
             max_function_lines: number;
         };
+        staleness: {
+            enabled: boolean;
+            rules: Record<string, boolean>;
+        };
         dependencies: {
             forbid: string[];
             trusted_registry?: string | undefined;
@@ -580,6 +620,10 @@ export declare const ConfigSchema: z.ZodObject<{
             max_class_dependencies?: number | undefined;
             max_function_lines?: number | undefined;
         } | undefined;
+        staleness?: {
+            enabled?: boolean | undefined;
+            rules?: Record<string, boolean> | undefined;
+        } | undefined;
         dependencies?: {
             forbid?: string[] | undefined;
             trusted_registry?: string | undefined;

package/dist/types/index.js

@@ -19,6 +19,20 @@ export const GatesSchema = z.object({
         max_class_dependencies: z.number().optional().default(5),
         max_function_lines: z.number().optional().default(50),
     }).optional().default({}),
+    staleness: z.object({
+        enabled: z.boolean().optional().default(false),
+        // Rule-based staleness detection (toggle individual rules)
+        rules: z.record(z.boolean()).optional().default({
+            'no-var': true, // var → const/let (ES6+)
+            'no-commonjs': false, // require() → import
+            'no-arguments': false, // arguments → rest params
+            'prefer-arrow': false, // function → arrow function
+            'prefer-template': false, // 'a' + b → `a${b}`
+            'prefer-spread': false, // apply() → spread
+            'prefer-rest': false, // arguments → ...args
+            'prefer-const': false, // let (unchanged) → const
+        }),
+    }).optional().default({}),
     dependencies: z.object({
         forbid: z.array(z.string()).optional().default([]),
         trusted_registry: z.string().optional(),

package/dist/utils/logger.js

@@ -13,12 +13,12 @@ export class Logger {
     }
     static info(message) {
         if (this.level <= LogLevel.INFO) {
-            console.log(chalk.blue('info: ') + message);
+            console.error(chalk.blue('info: ') + message);
         }
     }
     static warn(message) {
         if (this.level <= LogLevel.WARN) {
-            console.log(chalk.yellow('warn: ') + message);
+            console.error(chalk.yellow('warn: ') + message);
         }
     }
     static error(message, error) {
@@ -31,7 +31,7 @@ export class Logger {
     }
     static debug(message) {
         if (this.level <= LogLevel.DEBUG) {
-            console.log(chalk.dim('debug: ') + message);
+            console.error(chalk.dim('debug: ') + message);
         }
     }
 }

package/package.json

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

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

@@ -18,16 +18,98 @@ export class TypeScriptHandler extends ASTHandler {
 
     private analyzeSourceFile(sourceFile: ts.SourceFile, relativePath: string, failures: Failure[]) {
         const astConfig = this.config.ast || {};
+        const stalenessConfig = (this.config as any).staleness || {};
+        const stalenessRules = stalenessConfig.rules || {};
         const maxComplexity = astConfig.complexity || 10;
         const maxMethods = astConfig.max_methods || 10;
         const maxParams = astConfig.max_params || 5;
 
+        // Limit failures per file to avoid output bloat on large files
+        const MAX_FAILURES_PER_FILE = 50;
+        const fileFailureCount: Record<string, number> = {};
+
+        const addFailure = (failure: Failure): boolean => {
+            const ruleId = failure.id;
+            fileFailureCount[ruleId] = (fileFailureCount[ruleId] || 0) + 1;
+            if (fileFailureCount[ruleId] <= MAX_FAILURES_PER_FILE) {
+                failures.push(failure);
+                return true;
+            }
+            // Add summary failure once when limit is reached
+            if (fileFailureCount[ruleId] === MAX_FAILURES_PER_FILE + 1) {
+                failures.push({
+                    id: `${ruleId}_LIMIT_EXCEEDED`,
+                    title: `More than ${MAX_FAILURES_PER_FILE} ${ruleId} violations in ${relativePath}`,
+                    details: `Truncated output: showing first ${MAX_FAILURES_PER_FILE} violations. Consider fixing the root cause.`,
+                    files: [relativePath],
+                    hint: `This file has many violations. Fix them systematically or exclude the file if it's legacy code.`
+                });
+            }
+            return false;
+        };
+
+        // Helper to check if a staleness rule is enabled
+        const isRuleEnabled = (rule: string): boolean => {
+            if (!stalenessConfig.enabled) return false;
+            return stalenessRules[rule] !== false; // Enabled by default if staleness is on
+        };
+
         const visit = (node: ts.Node) => {
+            // === STALENESS CHECKS (Rule-based) ===
+
+            // no-var: Forbid legacy 'var' keyword
+            if (isRuleEnabled('no-var') && ts.isVariableStatement(node)) {
+                const declarationList = node.declarationList;
+                // NodeFlags: Let = 1, Const = 2, None = 0 (var)
+                if ((declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) === 0) {
+                    const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                    addFailure({
+                        id: 'STALENESS_NO_VAR',
+                        title: `Stale 'var' keyword at line ${line}`,
+                        details: `Use 'const' or 'let' instead of 'var' in ${relativePath}:${line}`,
+                        files: [relativePath],
+                        hint: `Replace 'var' with 'const' (preferred) or 'let' for modern JavaScript.`
+                    });
+                }
+            }
+
+            // no-commonjs: Forbid require() in favor of import
+            if (isRuleEnabled('no-commonjs') && ts.isCallExpression(node)) {
+                if (ts.isIdentifier(node.expression) && node.expression.text === 'require') {
+                    const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                    addFailure({
+                        id: 'STALENESS_NO_COMMONJS',
+                        title: `CommonJS require() at line ${line}`,
+                        details: `Use ES6 'import' instead of 'require()' in ${relativePath}:${line}`,
+                        files: [relativePath],
+                        hint: `Replace require('module') with import module from 'module'.`
+                    });
+                }
+            }
+
+            // no-arguments: Forbid 'arguments' object (use rest params)
+            if (isRuleEnabled('no-arguments') && ts.isIdentifier(node) && node.text === 'arguments') {
+                // Check if it's actually the arguments keyword and not a variable named arguments
+                const parent = node.parent;
+                if (!ts.isVariableDeclaration(parent) && !ts.isPropertyAccessExpression(parent)) {
+                    const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                    addFailure({
+                        id: 'STALENESS_NO_ARGUMENTS',
+                        title: `Legacy 'arguments' object at line ${line}`,
+                        details: `Use rest parameters (...args) instead of 'arguments' in ${relativePath}:${line}`,
+                        files: [relativePath],
+                        hint: `Replace 'arguments' with rest parameters: function(...args) { }`
+                    });
+                }
+            }
+
+            // === COMPLEXITY CHECKS ===
+
             if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isArrowFunction(node)) {
                 const name = this.getNodeName(node);
 
                 if (node.parameters.length > maxParams) {
-                    failures.push({
+                    addFailure({
                         id: 'AST_MAX_PARAMS',
                         title: `Function '${name}' has ${node.parameters.length} parameters (max: ${maxParams})`,
                         details: `High parameter count detected in ${relativePath}`,
@@ -54,7 +136,7 @@ export class TypeScriptHandler extends ASTHandler {
                 ts.forEachChild(node, countComplexity);
 
                 if (complexity > maxComplexity) {
-                    failures.push({
+                    addFailure({
                         id: 'AST_COMPLEXITY',
                         title: `Function '${name}' has cyclomatic complexity of ${complexity} (max: ${maxComplexity})`,
                         details: `High complexity detected in ${relativePath}`,
@@ -69,7 +151,7 @@ export class TypeScriptHandler extends ASTHandler {
                 const methods = node.members.filter(ts.isMethodDeclaration);
 
                 if (methods.length > maxMethods) {
-                    failures.push({
+                    addFailure({
                         id: 'AST_MAX_METHODS',
                         title: `Class '${name}' has ${methods.length} methods (max: ${maxMethods})`,
                         details: `God Object pattern detected in ${relativePath}`,

package/src/services/context-engine.ts

@@ -50,7 +50,7 @@ export class ContextEngine {
             } catch (e) { }
         }
 
-        console.log(`[ContextEngine] Discovered ${envVars.size} env anchors`);
+        // Logs removed to avoid stdout pollution in JSON mode
 
         // Convert envVars to anchors
         for (const [name, count] of envVars.entries()) {

package/src/templates/index.ts

@@ -208,6 +208,19 @@ export const UNIVERSAL_CONFIG: Config = {
             auto_classify: true,
             doc_sources: {},
         },
+        staleness: {
+            enabled: false,
+            rules: {
+                'no-var': true,
+                'no-commonjs': false,
+                'no-arguments': false,
+                'prefer-arrow': false,
+                'prefer-template': false,
+                'prefer-spread': false,
+                'prefer-rest': false,
+                'prefer-const': false,
+            },
+        },
     },
     output: {
         report_path: 'rigour-report.json',

package/src/types/index.ts

@@ -20,6 +20,20 @@ export const GatesSchema = z.object({
         max_class_dependencies: z.number().optional().default(5),
         max_function_lines: z.number().optional().default(50),
     }).optional().default({}),
+    staleness: z.object({
+        enabled: z.boolean().optional().default(false),
+        // Rule-based staleness detection (toggle individual rules)
+        rules: z.record(z.boolean()).optional().default({
+            'no-var': true,              // var → const/let (ES6+)
+            'no-commonjs': false,        // require() → import
+            'no-arguments': false,       // arguments → rest params
+            'prefer-arrow': false,       // function → arrow function
+            'prefer-template': false,    // 'a' + b → `a${b}`
+            'prefer-spread': false,      // apply() → spread
+            'prefer-rest': false,        // arguments → ...args
+            'prefer-const': false,       // let (unchanged) → const
+        }),
+    }).optional().default({}),
     dependencies: z.object({
         forbid: z.array(z.string()).optional().default([]),
         trusted_registry: z.string().optional(),

package/src/utils/logger.ts

@@ -16,13 +16,13 @@ export class Logger {
 
     static info(message: string) {
         if (this.level <= LogLevel.INFO) {
-            console.log(chalk.blue('info: ') + message);
+            console.error(chalk.blue('info: ') + message);
         }
     }
 
     static warn(message: string) {
         if (this.level <= LogLevel.WARN) {
-            console.log(chalk.yellow('warn: ') + message);
+            console.error(chalk.yellow('warn: ') + message);
         }
     }
 
@@ -37,7 +37,7 @@ export class Logger {
 
     static debug(message: string) {
         if (this.level <= LogLevel.DEBUG) {
-            console.log(chalk.dim('debug: ') + message);
+            console.error(chalk.dim('debug: ') + message);
         }
     }
 }