@rigour-labs/core 1.6.0 → 2.0.0

package/dist/types/index.js

@@ -1,73 +1,71 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReportSchema = exports.FailureSchema = exports.StatusSchema = exports.ConfigSchema = exports.CommandsSchema = exports.GatesSchema = void 0;
-const zod_1 = require("zod");
-exports.GatesSchema = zod_1.z.object({
-    max_file_lines: zod_1.z.number().optional().default(500),
-    forbid_todos: zod_1.z.boolean().optional().default(true),
-    forbid_fixme: zod_1.z.boolean().optional().default(true),
-    forbid_paths: zod_1.z.array(zod_1.z.string()).optional().default([]),
-    required_files: zod_1.z.array(zod_1.z.string()).optional().default([
+import { z } from 'zod';
+export const GatesSchema = z.object({
+    max_file_lines: z.number().optional().default(500),
+    forbid_todos: z.boolean().optional().default(true),
+    forbid_fixme: z.boolean().optional().default(true),
+    forbid_paths: z.array(z.string()).optional().default([]),
+    required_files: z.array(z.string()).optional().default([
         'docs/SPEC.md',
         'docs/ARCH.md',
         'docs/DECISIONS.md',
         'docs/TASKS.md',
     ]),
-    ast: zod_1.z.object({
-        complexity: zod_1.z.number().optional().default(10),
-        max_methods: zod_1.z.number().optional().default(10),
-        max_params: zod_1.z.number().optional().default(5),
-        max_nesting: zod_1.z.number().optional().default(4),
-        max_inheritance_depth: zod_1.z.number().optional().default(3),
-        max_class_dependencies: zod_1.z.number().optional().default(5),
-        max_function_lines: zod_1.z.number().optional().default(50),
+    ast: z.object({
+        complexity: z.number().optional().default(10),
+        max_methods: z.number().optional().default(10),
+        max_params: z.number().optional().default(5),
+        max_nesting: z.number().optional().default(4),
+        max_inheritance_depth: z.number().optional().default(3),
+        max_class_dependencies: z.number().optional().default(5),
+        max_function_lines: z.number().optional().default(50),
     }).optional().default({}),
-    dependencies: zod_1.z.object({
-        forbid: zod_1.z.array(zod_1.z.string()).optional().default([]),
-        trusted_registry: zod_1.z.string().optional(),
+    dependencies: z.object({
+        forbid: z.array(z.string()).optional().default([]),
+        trusted_registry: z.string().optional(),
     }).optional().default({}),
-    architecture: zod_1.z.object({
-        boundaries: zod_1.z.array(zod_1.z.object({
-            from: zod_1.z.string(),
-            to: zod_1.z.string(),
-            mode: zod_1.z.enum(['allow', 'deny']).default('deny'),
+    architecture: z.object({
+        boundaries: z.array(z.object({
+            from: z.string(),
+            to: z.string(),
+            mode: z.enum(['allow', 'deny']).default('deny'),
         })).optional().default([]),
     }).optional().default({}),
-    safety: zod_1.z.object({
-        max_files_changed_per_cycle: zod_1.z.number().optional().default(10),
-        protected_paths: zod_1.z.array(zod_1.z.string()).optional().default(['.github/**', 'docs/**', 'rigour.yml']),
+    safety: z.object({
+        max_files_changed_per_cycle: z.number().optional().default(10),
+        protected_paths: z.array(z.string()).optional().default(['.github/**', 'docs/**', 'rigour.yml']),
     }).optional().default({}),
 });
-exports.CommandsSchema = zod_1.z.object({
-    format: zod_1.z.string().optional(),
-    lint: zod_1.z.string().optional(),
-    typecheck: zod_1.z.string().optional(),
-    test: zod_1.z.string().optional(),
+export const CommandsSchema = z.object({
+    format: z.string().optional(),
+    lint: z.string().optional(),
+    typecheck: z.string().optional(),
+    test: z.string().optional(),
 });
-exports.ConfigSchema = zod_1.z.object({
-    version: zod_1.z.number().default(1),
-    preset: zod_1.z.string().optional(),
-    paradigm: zod_1.z.string().optional(),
-    commands: exports.CommandsSchema.optional().default({}),
-    gates: exports.GatesSchema.optional().default({}),
-    output: zod_1.z.object({
-        report_path: zod_1.z.string().default('rigour-report.json'),
+export const ConfigSchema = z.object({
+    version: z.number().default(1),
+    preset: z.string().optional(),
+    paradigm: z.string().optional(),
+    commands: CommandsSchema.optional().default({}),
+    gates: GatesSchema.optional().default({}),
+    output: z.object({
+        report_path: z.string().default('rigour-report.json'),
     }).optional().default({}),
-    planned: zod_1.z.array(zod_1.z.string()).optional().default([]),
+    planned: z.array(z.string()).optional().default([]),
 });
-exports.StatusSchema = zod_1.z.enum(['PASS', 'FAIL', 'SKIP', 'ERROR']);
-exports.FailureSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    title: zod_1.z.string(),
-    details: zod_1.z.string(),
-    files: zod_1.z.array(zod_1.z.string()).optional(),
-    hint: zod_1.z.string().optional(),
+export const StatusSchema = z.enum(['PASS', 'FAIL', 'SKIP', 'ERROR']);
+export const FailureSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    details: z.string(),
+    files: z.array(z.string()).optional(),
+    hint: z.string().optional(),
 });
-exports.ReportSchema = zod_1.z.object({
-    status: exports.StatusSchema,
-    summary: zod_1.z.record(exports.StatusSchema),
-    failures: zod_1.z.array(exports.FailureSchema),
-    stats: zod_1.z.object({
-        duration_ms: zod_1.z.number(),
+export const ReportSchema = z.object({
+    status: StatusSchema,
+    summary: z.record(StatusSchema),
+    failures: z.array(FailureSchema),
+    stats: z.object({
+        duration_ms: z.number(),
+        score: z.number().optional(),
     }),
 });

package/dist/utils/logger.js

@@ -1,35 +1,29 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.LogLevel = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-var LogLevel;
+import chalk from 'chalk';
+export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
     LogLevel[LogLevel["INFO"] = 1] = "INFO";
     LogLevel[LogLevel["WARN"] = 2] = "WARN";
     LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));
-class Logger {
+})(LogLevel || (LogLevel = {}));
+export class Logger {
     static level = LogLevel.INFO;
     static setLevel(level) {
         this.level = level;
     }
     static info(message) {
         if (this.level <= LogLevel.INFO) {
-            console.log(chalk_1.default.blue('info: ') + message);
+            console.log(chalk.blue('info: ') + message);
         }
     }
     static warn(message) {
         if (this.level <= LogLevel.WARN) {
-            console.log(chalk_1.default.yellow('warn: ') + message);
+            console.log(chalk.yellow('warn: ') + message);
         }
     }
     static error(message, error) {
         if (this.level <= LogLevel.ERROR) {
-            console.error(chalk_1.default.red('error: ') + message);
+            console.error(chalk.red('error: ') + message);
             if (error) {
                 console.error(error);
             }
@@ -37,8 +31,7 @@ class Logger {
     }
     static debug(message) {
         if (this.level <= LogLevel.DEBUG) {
-            console.log(chalk_1.default.dim('debug: ') + message);
+            console.log(chalk.dim('debug: ') + message);
         }
     }
 }
-exports.Logger = Logger;

package/dist/utils/scanner.js

@@ -1,13 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileScanner = void 0;
-const globby_1 = require("globby");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-class FileScanner {
+import { globby } from 'globby';
+import fs from 'fs-extra';
+import path from 'path';
+export class FileScanner {
     static DEFAULT_PATTERNS = ['**/*.{ts,js,py,css,html,md}'];
     static DEFAULT_IGNORE = [
         '**/node_modules/**',
@@ -18,7 +12,7 @@ class FileScanner {
         'rigour-report.json'
     ];
     static async findFiles(options) {
-        return (0, globby_1.globby)(options.patterns || this.DEFAULT_PATTERNS, {
+        return globby(options.patterns || this.DEFAULT_PATTERNS, {
             cwd: options.cwd,
             ignore: options.ignore || this.DEFAULT_IGNORE,
         });
@@ -26,10 +20,9 @@ class FileScanner {
     static async readFiles(cwd, files) {
         const contents = new Map();
         for (const file of files) {
-            const filePath = path_1.default.join(cwd, file);
-            contents.set(file, await fs_extra_1.default.readFile(filePath, 'utf-8'));
+            const filePath = path.join(cwd, file);
+            contents.set(file, await fs.readFile(filePath, 'utf-8'));
         }
         return contents;
     }
 }
-exports.FileScanner = FileScanner;

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@rigour-labs/core",
-  "version": "1.6.0",
+  "version": "2.0.0",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
@@ -18,6 +19,7 @@
     "globby": "^14.1.0",
     "micromatch": "^4.0.8",
     "typescript": "^5.9.3",
+    "web-tree-sitter": "^0.26.3",
     "yaml": "^2.3.4",
     "zod": "^3.22.4"
   },

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

@@ -0,0 +1,13 @@
+import { Failure, Gates } from '../../types/index.js';
+
+export interface ASTHandlerContext {
+    cwd: string;
+    file: string;
+    content: string;
+}
+
+export abstract class ASTHandler {
+    constructor(protected config: Gates) { }
+    abstract supports(file: string): boolean;
+    abstract run(context: ASTHandlerContext): Promise<Failure[]>;
+}

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

@@ -0,0 +1,71 @@
+import { execa } from 'execa';
+import { ASTHandler, ASTHandlerContext } from './base.js';
+import { Failure } from '../../types/index.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export class PythonHandler extends ASTHandler {
+    supports(file: string): boolean {
+        return /\.py$/.test(file);
+    }
+
+    async run(context: ASTHandlerContext): Promise<Failure[]> {
+        const failures: Failure[] = [];
+        const scriptPath = path.join(__dirname, 'python_parser.py');
+
+        try {
+            const { stdout } = await execa('python3', [scriptPath], {
+                input: context.content,
+                cwd: context.cwd
+            });
+
+            const metrics = JSON.parse(stdout);
+            if (metrics.error) return [];
+
+            const astConfig = this.config.ast || {};
+            const maxComplexity = astConfig.complexity || 10;
+            const maxParams = astConfig.max_params || 5;
+            const maxMethods = astConfig.max_methods || 10;
+
+            for (const item of metrics) {
+                if (item.type === 'function') {
+                    if (item.parameters > maxParams) {
+                        failures.push({
+                            id: 'AST_MAX_PARAMS',
+                            title: `Function '${item.name}' has ${item.parameters} parameters (max: ${maxParams})`,
+                            details: `High parameter count detected in ${context.file} at line ${item.lineno}`,
+                            files: [context.file],
+                            hint: `Reduce number of parameters or use an options object.`
+                        });
+                    }
+                    if (item.complexity > maxComplexity) {
+                        failures.push({
+                            id: 'AST_COMPLEXITY',
+                            title: `Function '${item.name}' has complexity of ${item.complexity} (max: ${maxComplexity})`,
+                            details: `High complexity detected in ${context.file} at line ${item.lineno}`,
+                            files: [context.file],
+                            hint: `Refactor '${item.name}' into smaller, more focused functions.`
+                        });
+                    }
+                } else if (item.type === 'class') {
+                    if (item.methods > maxMethods) {
+                        failures.push({
+                            id: 'AST_MAX_METHODS',
+                            title: `Class '${item.name}' has ${item.methods} methods (max: ${maxMethods})`,
+                            details: `God Object pattern detected in ${context.file} at line ${item.lineno}`,
+                            files: [context.file],
+                            hint: `Split class '${item.name}' into smaller services.`
+                        });
+                    }
+                }
+            }
+
+        } catch (e: any) {
+            // If python3 is missing, we skip AST but other gates still run
+        }
+
+        return failures;
+    }
+}

package/src/gates/ast-handlers/python_parser.py

@@ -0,0 +1,60 @@
+import ast
+import sys
+import json
+
+class MetricsVisitor(ast.NodeVisitor):
+    def __init__(self):
+        self.metrics = []
+
+    def visit_FunctionDef(self, node):
+        self.analyze_function(node)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        self.analyze_function(node)
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node):
+        methods = [n for n in node.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
+        self.metrics.append({
+            "type": "class",
+            "name": node.name,
+            "methods": len(methods),
+            "lineno": node.lineno
+        })
+        self.generic_visit(node)
+
+    def analyze_function(self, node):
+        complexity = 1
+        for n in ast.walk(node):
+            if isinstance(n, (ast.If, ast.While, ast.For, ast.AsyncFor, ast.Try, ast.ExceptHandler, ast.With, ast.AsyncWith)):
+                complexity += 1
+            elif isinstance(n, ast.BoolOp):
+                complexity += len(n.values) - 1
+            elif isinstance(n, ast.IfExp):
+                complexity += 1
+        
+        params = len(node.args.args) + len(node.args.kwonlyargs)
+        if node.args.vararg: params += 1
+        if node.args.kwarg: params += 1
+
+        self.metrics.append({
+            "type": "function",
+            "name": node.name,
+            "complexity": complexity,
+            "parameters": params,
+            "lineno": node.lineno
+        })
+
+def analyze_code(content):
+    try:
+        tree = ast.parse(content)
+        visitor = MetricsVisitor()
+        visitor.visit(tree)
+        return visitor.metrics
+    except Exception as e:
+        return {"error": str(e)}
+
+if __name__ == "__main__":
+    content = sys.stdin.read()
+    print(json.dumps(analyze_code(content)))

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

@@ -0,0 +1,125 @@
+import ts from 'typescript';
+import { ASTHandler, ASTHandlerContext } from './base.js';
+import { Failure } from '../../types/index.js';
+import micromatch from 'micromatch';
+import path from 'path';
+
+export class TypeScriptHandler extends ASTHandler {
+    supports(file: string): boolean {
+        return /\.(ts|js|tsx|jsx)$/.test(file);
+    }
+
+    async run(context: ASTHandlerContext): Promise<Failure[]> {
+        const failures: Failure[] = [];
+        const sourceFile = ts.createSourceFile(context.file, context.content, ts.ScriptTarget.Latest, true);
+        this.analyzeSourceFile(sourceFile, context.file, failures);
+        return failures;
+    }
+
+    private analyzeSourceFile(sourceFile: ts.SourceFile, relativePath: string, failures: Failure[]) {
+        const astConfig = this.config.ast || {};
+        const maxComplexity = astConfig.complexity || 10;
+        const maxMethods = astConfig.max_methods || 10;
+        const maxParams = astConfig.max_params || 5;
+
+        const visit = (node: ts.Node) => {
+            if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isArrowFunction(node)) {
+                const name = this.getNodeName(node);
+
+                if (node.parameters.length > maxParams) {
+                    failures.push({
+                        id: 'AST_MAX_PARAMS',
+                        title: `Function '${name}' has ${node.parameters.length} parameters (max: ${maxParams})`,
+                        details: `High parameter count detected in ${relativePath}`,
+                        files: [relativePath],
+                        hint: `Reduce number of parameters or use an options object.`
+                    });
+                }
+
+                let complexity = 1;
+                const countComplexity = (n: ts.Node) => {
+                    if (ts.isIfStatement(n) || ts.isCaseClause(n) || ts.isDefaultClause(n) ||
+                        ts.isForStatement(n) || ts.isForInStatement(n) || ts.isForOfStatement(n) ||
+                        ts.isWhileStatement(n) || ts.isDoStatement(n) || ts.isConditionalExpression(n)) {
+                        complexity++;
+                    }
+                    if (ts.isBinaryExpression(n)) {
+                        if (n.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                            n.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+                            complexity++;
+                        }
+                    }
+                    ts.forEachChild(n, countComplexity);
+                };
+                ts.forEachChild(node, countComplexity);
+
+                if (complexity > maxComplexity) {
+                    failures.push({
+                        id: 'AST_COMPLEXITY',
+                        title: `Function '${name}' has cyclomatic complexity of ${complexity} (max: ${maxComplexity})`,
+                        details: `High complexity detected in ${relativePath}`,
+                        files: [relativePath],
+                        hint: `Refactor '${name}' into smaller, more focused functions.`
+                    });
+                }
+            }
+
+            if (ts.isClassDeclaration(node)) {
+                const name = node.name?.text || 'Anonymous Class';
+                const methods = node.members.filter(ts.isMethodDeclaration);
+
+                if (methods.length > maxMethods) {
+                    failures.push({
+                        id: 'AST_MAX_METHODS',
+                        title: `Class '${name}' has ${methods.length} methods (max: ${maxMethods})`,
+                        details: `God Object pattern detected in ${relativePath}`,
+                        files: [relativePath],
+                        hint: `Class '${name}' is becoming too large. Split it into smaller services.`
+                    });
+                }
+            }
+
+            if (ts.isImportDeclaration(node)) {
+                const importPath = (node.moduleSpecifier as ts.StringLiteral).text;
+                this.checkBoundary(importPath, relativePath, failures);
+            }
+
+            ts.forEachChild(node, visit);
+        };
+
+        ts.forEachChild(sourceFile, visit);
+    }
+
+    private checkBoundary(importPath: string, relativePath: string, failures: Failure[]) {
+        const boundaries = (this.config as any).architecture?.boundaries || [];
+        for (const rule of boundaries) {
+            if (micromatch.isMatch(relativePath, rule.from)) {
+                const resolved = importPath.startsWith('.')
+                    ? path.join(path.dirname(relativePath), importPath)
+                    : importPath;
+
+                if (rule.mode === 'deny' && micromatch.isMatch(resolved, rule.to)) {
+                    failures.push({
+                        id: 'ARCH_BOUNDARY',
+                        title: `Architectural Violation`,
+                        details: `'${relativePath}' is forbidden from importing '${importPath}' (denied by boundary rule).`,
+                        files: [relativePath],
+                        hint: `Remove this import to maintain architectural layering.`
+                    });
+                }
+            }
+        }
+    }
+
+    private getNodeName(node: ts.Node): string {
+        if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) {
+            return node.name?.getText() || 'anonymous';
+        }
+        if (ts.isArrowFunction(node)) {
+            const parent = node.parent;
+            if (ts.isVariableDeclaration(parent)) return parent.name.getText();
+            return 'anonymous arrow';
+        }
+        return 'unknown';
+    }
+}