@rigour-labs/core 1.0.0 → 1.4.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Rigour Contributors
+Copyright (c) 2026 Ashutosh (https://github.com/erashu212), Rigour Labs.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/discovery.d.ts

@@ -1,5 +1,21 @@
 import { Config } from './types/index.js';
+export interface DiscoveryResult {
+    config: Config;
+    matches: {
+        preset?: {
+            name: string;
+            marker: string;
+        };
+        paradigm?: {
+            name: string;
+            marker: string;
+        };
+    };
+}
 export declare class DiscoveryService {
-    discover(cwd: string): Promise<Config>;
-    private hasAnyMarker;
+    discover(cwd: string): Promise<DiscoveryResult>;
+    private mergeConfig;
+    private findFirstMarker;
+    private existsInContent;
+    private findSourceFiles;
 }

package/dist/discovery.js

@@ -9,24 +9,76 @@ const path_1 = __importDefault(require("path"));
 const index_js_1 = require("./templates/index.js");
 class DiscoveryService {
     async discover(cwd) {
-        const config = { ...index_js_1.UNIVERSAL_CONFIG };
+        let config = { ...index_js_1.UNIVERSAL_CONFIG };
+        const matches = {};
+        // 1. Detect Role (ui, api, infra, data)
         for (const template of index_js_1.TEMPLATES) {
-            const match = await this.hasAnyMarker(cwd, template.markers);
-            if (match) {
-                // Merge template config
-                config.commands = { ...config.commands, ...template.config.commands };
-                config.gates = { ...config.gates, ...template.config.gates };
+            const marker = await this.findFirstMarker(cwd, template.markers, true); // Search content for roles too
+            if (marker) {
+                config = this.mergeConfig(config, template.config);
+                matches.preset = { name: template.name, marker };
+                break; // Only one role for now
             }
         }
-        return config;
+        // 2. Detect Paradigm (oop, functional)
+        for (const template of index_js_1.PARADIGM_TEMPLATES) {
+            const marker = await this.findFirstMarker(cwd, template.markers, true); // Search content
+            if (marker) {
+                config = this.mergeConfig(config, template.config);
+                matches.paradigm = { name: template.name, marker };
+                break;
+            }
+        }
+        return { config, matches };
+    }
+    mergeConfig(base, extension) {
+        return {
+            ...base,
+            preset: extension.preset || base.preset,
+            paradigm: extension.paradigm || base.paradigm,
+            commands: { ...base.commands, ...extension.commands },
+            gates: { ...base.gates, ...extension.gates },
+        };
     }
-    async hasAnyMarker(cwd, markers) {
+    async findFirstMarker(cwd, markers, searchContent = false) {
         for (const marker of markers) {
-            if (await fs_extra_1.default.pathExists(path_1.default.join(cwd, marker))) {
-                return true;
+            const fullPath = path_1.default.join(cwd, marker);
+            // File/Directory existence check
+            if (await fs_extra_1.default.pathExists(fullPath)) {
+                return marker;
+            }
+            // Deep content check for paradigms
+            if (searchContent) {
+                const match = await this.existsInContent(cwd, marker);
+                if (match)
+                    return `content:${marker}`;
             }
         }
+        return null;
+    }
+    async existsInContent(cwd, pattern) {
+        // Simple heuristic: search in top 5 source files
+        const files = await this.findSourceFiles(cwd);
+        for (const file of files) {
+            const content = await fs_extra_1.default.readFile(file, 'utf-8');
+            if (content.includes(pattern))
+                return true;
+        }
         return false;
     }
+    async findSourceFiles(cwd) {
+        // Find a few files to sample
+        const extensions = ['.ts', '.js', '.py', '.go', '.java', '.tf', 'package.json'];
+        const samples = [];
+        const files = await fs_extra_1.default.readdir(cwd);
+        for (const file of files) {
+            if (extensions.some(ext => file.endsWith(ext))) {
+                samples.push(path_1.default.join(cwd, file));
+                if (samples.length >= 5)
+                    break;
+            }
+        }
+        return samples;
+    }
 }
 exports.DiscoveryService = DiscoveryService;

package/dist/gates/ast.d.ts

@@ -0,0 +1,10 @@
+import { Gate, GateContext } from './base.js';
+import { Failure, Gates } from '../types/index.js';
+export declare class ASTGate extends Gate {
+    private config;
+    constructor(config: Gates);
+    run(context: GateContext): Promise<Failure[]>;
+    private analyzeSourceFile;
+    private checkBoundary;
+    private getNodeName;
+}

package/dist/gates/ast.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASTGate = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const globby_1 = require("globby");
+const base_js_1 = require("./base.js");
+const micromatch_1 = __importDefault(require("micromatch"));
+class ASTGate extends base_js_1.Gate {
+    config;
+    constructor(config) {
+        super('ast-analysis', 'AST Structural Analysis');
+        this.config = config;
+    }
+    async run(context) {
+        const failures = [];
+        const files = await (0, globby_1.globby)(['**/*.{ts,js,tsx,jsx}'], {
+            cwd: context.cwd,
+            ignore: ['node_modules/**', 'dist/**', 'build/**', '**/*.test.*', '**/*.spec.*'],
+        });
+        for (const file of files) {
+            const fullPath = path_1.default.join(context.cwd, file);
+            const content = await fs_extra_1.default.readFile(fullPath, 'utf-8');
+            const sourceFile = typescript_1.default.createSourceFile(file, content, typescript_1.default.ScriptTarget.Latest, true);
+            this.analyzeSourceFile(sourceFile, file, failures);
+        }
+        return failures;
+    }
+    analyzeSourceFile(sourceFile, relativePath, failures) {
+        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) => {
+            // 1. Complexity & Params for functions
+            if (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isArrowFunction(node)) {
+                const name = this.getNodeName(node);
+                // Parameter count
+                if (node.parameters.length > maxParams) {
+                    failures.push(this.createFailure(`Function '${name}' has ${node.parameters.length} parameters (max: ${maxParams})`, [relativePath], `Reduce number of parameters or use an options object.`));
+                    // Update: Failures in Runner will be mapped to FixPacket
+                    failures[failures.length - 1].metrics = { count: node.parameters.length, max: maxParams };
+                }
+                // Cyclomatic Complexity (Simplified: nodes that cause branching)
+                let complexity = 1;
+                const countComplexity = (n) => {
+                    if (typescript_1.default.isIfStatement(n) || typescript_1.default.isCaseClause(n) || typescript_1.default.isDefaultClause(n) ||
+                        typescript_1.default.isForStatement(n) || typescript_1.default.isForInStatement(n) || typescript_1.default.isForOfStatement(n) ||
+                        typescript_1.default.isWhileStatement(n) || typescript_1.default.isDoStatement(n) || typescript_1.default.isConditionalExpression(n)) {
+                        complexity++;
+                    }
+                    if (typescript_1.default.isBinaryExpression(n)) {
+                        if (n.operatorToken.kind === typescript_1.default.SyntaxKind.AmpersandAmpersandToken ||
+                            n.operatorToken.kind === typescript_1.default.SyntaxKind.BarBarToken) {
+                            complexity++;
+                        }
+                    }
+                    typescript_1.default.forEachChild(n, countComplexity);
+                };
+                typescript_1.default.forEachChild(node, countComplexity);
+                if (complexity > maxComplexity) {
+                    failures.push(this.createFailure(`Function '${name}' has cyclomatic complexity of ${complexity} (max: ${maxComplexity})`, [relativePath], `Refactor '${name}' into smaller, more focused functions.`));
+                    failures[failures.length - 1].metrics = { complexity, max: maxComplexity };
+                }
+            }
+            // 2. Class metrics
+            if (typescript_1.default.isClassDeclaration(node)) {
+                const name = node.name?.text || 'Anonymous Class';
+                const methods = node.members.filter(typescript_1.default.isMethodDeclaration);
+                if (methods.length > maxMethods) {
+                    failures.push(this.createFailure(`Class '${name}' has ${methods.length} methods (max: ${maxMethods})`, [relativePath], `Class '${name}' is becoming a 'God Object'. Split it into smaller services.`));
+                    failures[failures.length - 1].metrics = { methodCount: methods.length, max: maxMethods };
+                }
+            }
+            // 3. Import check for Layer Boundaries
+            if (typescript_1.default.isImportDeclaration(node)) {
+                const importPath = node.moduleSpecifier.text;
+                this.checkBoundary(importPath, relativePath, failures);
+            }
+            typescript_1.default.forEachChild(node, visit);
+        };
+        typescript_1.default.forEachChild(sourceFile, visit);
+    }
+    checkBoundary(importPath, relativePath, failures) {
+        const boundaries = this.config.architecture?.boundaries || [];
+        if (boundaries.length === 0)
+            return;
+        for (const rule of boundaries) {
+            const isFromMatch = micromatch_1.default.isMatch(relativePath, rule.from);
+            if (isFromMatch) {
+                // Approximate resolution (simplified for now)
+                // Real implementation would need to handle alias and absolute path resolution
+                const resolved = importPath.startsWith('.')
+                    ? path_1.default.join(path_1.default.dirname(relativePath), importPath)
+                    : importPath;
+                const isToMatch = micromatch_1.default.isMatch(resolved, rule.to);
+                if (rule.mode === 'deny' && isToMatch) {
+                    failures.push(this.createFailure(`Architectural Violation: '${relativePath}' is forbidden from importing '${importPath}' (denied by boundary rule).`, [relativePath], `Remove this import to maintain architectural layering.`));
+                }
+                else if (rule.mode === 'allow' && !isToMatch && importPath.startsWith('.')) {
+                    // Complexity: Allow rules are trickier to implement strictly without full resolution
+                }
+            }
+        }
+    }
+    getNodeName(node) {
+        if (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isMethodDeclaration(node)) {
+            return node.name?.getText() || 'anonymous';
+        }
+        if (typescript_1.default.isArrowFunction(node)) {
+            const parent = node.parent;
+            if (typescript_1.default.isVariableDeclaration(parent)) {
+                return parent.name.getText();
+            }
+            return 'anonymous arrow';
+        }
+        return 'unknown';
+    }
+}
+exports.ASTGate = ASTGate;

package/dist/gates/dependency.d.ts

@@ -0,0 +1,7 @@
+import { Failure, Config } from '../types/index.js';
+import { Gate, GateContext } from './base.js';
+export declare class DependencyGate extends Gate {
+    private config;
+    constructor(config: Config);
+    run(context: GateContext): Promise<Failure[]>;
+}

package/dist/gates/dependency.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyGate = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const base_js_1 = require("./base.js");
+class DependencyGate extends base_js_1.Gate {
+    config;
+    constructor(config) {
+        super('dependency-guardian', 'Dependency Guardian');
+        this.config = config;
+    }
+    async run(context) {
+        const failures = [];
+        const forbidden = this.config.gates.dependencies?.forbid || [];
+        if (forbidden.length === 0)
+            return [];
+        const { cwd } = context;
+        // 1. Scan Node.js (package.json)
+        const pkgPath = path_1.default.join(cwd, 'package.json');
+        if (await fs_extra_1.default.pathExists(pkgPath)) {
+            try {
+                const pkg = await fs_extra_1.default.readJson(pkgPath);
+                const allDeps = {
+                    ...(pkg.dependencies || {}),
+                    ...(pkg.devDependencies || {}),
+                    ...(pkg.peerDependencies || {}),
+                };
+                for (const dep of forbidden) {
+                    if (allDeps[dep]) {
+                        failures.push(this.createFailure(`The package '${dep}' is forbidden by project standards.`, ['package.json'], `Remove '${dep}' from package.json and use approved alternatives.`));
+                    }
+                }
+            }
+            catch (e) { }
+        }
+        return failures;
+    }
+}
+exports.DependencyGate = DependencyGate;

package/dist/gates/runner.js

@@ -4,6 +4,9 @@ exports.GateRunner = void 0;
 const file_js_1 = require("./file.js");
 const content_js_1 = require("./content.js");
 const structure_js_1 = require("./structure.js");
+const ast_js_1 = require("./ast.js");
+const safety_js_1 = require("./safety.js");
+const dependency_js_1 = require("./dependency.js");
 const execa_1 = require("execa");
 const logger_js_1 = require("../utils/logger.js");
 class GateRunner {
@@ -24,6 +27,9 @@ class GateRunner {
         if (this.config.gates.required_files) {
             this.gates.push(new structure_js_1.StructureGate({ requiredFiles: this.config.gates.required_files }));
         }
+        this.gates.push(new ast_js_1.ASTGate(this.config.gates));
+        this.gates.push(new dependency_js_1.DependencyGate(this.config));
+        this.gates.push(new safety_js_1.SafetyGate(this.config.gates));
     }
     /**
      * Allows adding custom gates dynamically (SOLID - Open/Closed Principle)

package/dist/gates/safety.d.ts

@@ -0,0 +1,8 @@
+import { Gate, GateContext } from './base.js';
+import { Failure, Gates } from '../types/index.js';
+export declare class SafetyGate extends Gate {
+    private config;
+    constructor(config: Gates);
+    run(context: GateContext): Promise<Failure[]>;
+    private isProtected;
+}

package/dist/gates/safety.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafetyGate = void 0;
+const base_js_1 = require("./base.js");
+const execa_1 = require("execa");
+class SafetyGate extends base_js_1.Gate {
+    config;
+    constructor(config) {
+        super('safety-rail', 'Safety & Protection Rails');
+        this.config = config;
+    }
+    async run(context) {
+        const failures = [];
+        const safety = this.config.safety || {};
+        const protectedPaths = safety.protected_paths || [];
+        if (protectedPaths.length === 0)
+            return [];
+        try {
+            // Check for modified files in protected paths using git
+            // This is a "Safety Rail" - if an agent touched these, we fail.
+            const { stdout } = await (0, execa_1.execa)('git', ['status', '--porcelain'], { cwd: context.cwd });
+            const modifiedFiles = stdout.split('\n')
+                .filter(line => line.trim().length > 0)
+                .map(line => line.slice(3));
+            for (const file of modifiedFiles) {
+                if (this.isProtected(file, protectedPaths)) {
+                    failures.push(this.createFailure(`Protected file '${file}' was modified.`, [file], `Agents are forbidden from modifying files in ${protectedPaths.join(', ')}.`));
+                }
+            }
+        }
+        catch (error) {
+            // If not a git repo, skip safety for now
+        }
+        return failures;
+    }
+    isProtected(file, patterns) {
+        return patterns.some(p => {
+            const cleanP = p.replace('/**', '').replace('/*', '');
+            if (file === cleanP)
+                return true;
+            if (cleanP.endsWith('/'))
+                return file.startsWith(cleanP);
+            return file.startsWith(cleanP + '/');
+        });
+    }
+}
+exports.SafetyGate = SafetyGate;

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export * from './types/index.js';
 export * from './gates/runner.js';
 export * from './discovery.js';
+export * from './services/fix-packet-service.js';
 export * from './templates/index.js';
+export * from './types/fix-packet.js';
+export { Gate, GateContext } from './gates/base.js';
 export * from './utils/logger.js';

package/dist/index.js

@@ -14,8 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gate = void 0;
 __exportStar(require("./types/index.js"), exports);
 __exportStar(require("./gates/runner.js"), exports);
 __exportStar(require("./discovery.js"), exports);
+__exportStar(require("./services/fix-packet-service.js"), exports);
 __exportStar(require("./templates/index.js"), exports);
+__exportStar(require("./types/fix-packet.js"), exports);
+var base_js_1 = require("./gates/base.js");
+Object.defineProperty(exports, "Gate", { enumerable: true, get: function () { return base_js_1.Gate; } });
 __exportStar(require("./utils/logger.js"), exports);

package/dist/services/fix-packet-service.d.ts

@@ -0,0 +1,6 @@
+import { Report, Config } from '../types/index.js';
+import { FixPacketV2 } from '../types/fix-packet.js';
+export declare class FixPacketService {
+    generate(report: Report, config: Config): FixPacketV2;
+    private inferSeverity;
+}

package/dist/services/fix-packet-service.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixPacketService = void 0;
+const fix_packet_js_1 = require("../types/fix-packet.js");
+class FixPacketService {
+    generate(report, config) {
+        const violations = report.failures.map(f => ({
+            id: f.id,
+            gate: f.id,
+            severity: this.inferSeverity(f),
+            title: f.title,
+            details: f.details,
+            files: f.files,
+            hint: f.hint,
+            instructions: f.hint ? [f.hint] : [], // Use hint as first instruction
+            metrics: f.metrics,
+        }));
+        const packet = {
+            version: 2,
+            goal: "Achieve PASS state by resolving all listed engineering violations.",
+            violations,
+            constraints: {
+                paradigm: config.paradigm,
+                protected_paths: config.gates.safety?.protected_paths,
+                do_not_touch: config.gates.safety?.protected_paths,
+                max_files_changed: config.gates.safety?.max_files_changed_per_cycle,
+                no_new_deps: true,
+            },
+        };
+        return fix_packet_js_1.FixPacketV2Schema.parse(packet);
+    }
+    inferSeverity(f) {
+        // High complexity or God objects are usually High severity
+        if (f.id === 'ast-analysis')
+            return 'high';
+        // Unit test or Lint failures are Medium
+        if (f.id === 'test' || f.id === 'lint')
+            return 'medium';
+        // Documentation or small file size issues are Low
+        return 'medium';
+    }
+}
+exports.FixPacketService = FixPacketService;

package/dist/templates/index.d.ts

@@ -1,8 +1,15 @@
-import { Config } from '../types/index.js';
+import { Config, Commands, Gates } from '../types/index.js';
 export interface Template {
     name: string;
     markers: string[];
-    config: Partial<Config>;
+    config: {
+        preset?: string;
+        paradigm?: string;
+        commands?: Partial<Commands>;
+        gates?: Partial<Gates>;
+        planned?: string[];
+    };
 }
 export declare const TEMPLATES: Template[];
+export declare const PARADIGM_TEMPLATES: Template[];
 export declare const UNIVERSAL_CONFIG: Config;

package/dist/templates/index.js

@@ -1,55 +1,125 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UNIVERSAL_CONFIG = exports.TEMPLATES = void 0;
+exports.UNIVERSAL_CONFIG = exports.PARADIGM_TEMPLATES = exports.TEMPLATES = void 0;
 exports.TEMPLATES = [
     {
-        name: 'Node.js',
-        markers: ['package.json'],
+        name: 'ui',
+        markers: [
+            'react',
+            'next',
+            'vue',
+            'svelte',
+            'next.config.js',
+            'vite.config.ts',
+            'tailwind.config.js',
+            'base.css',
+            'index.html',
+        ],
         config: {
-            commands: {
-                lint: 'npm run lint',
-                test: 'npm test',
+            preset: 'ui',
+            gates: {
+                max_file_lines: 300,
+                required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
             },
+            planned: [
+                'Layer Boundary: Components cannot import from DB',
+                'Prop-Drilling Detection: Max depth 5',
+            ],
+        },
+    },
+    {
+        name: 'api',
+        markers: [
+            'express',
+            'fastify',
+            'nestjs',
+            'go.mod',
+            'requirements.txt',
+            'pyproject.toml',
+            'app.py',
+            'main.go',
+            'index.js',
+        ],
+        config: {
+            preset: 'api',
             gates: {
-                max_file_lines: 500,
-                forbid_todos: true,
-                forbid_fixme: true,
-                forbid_paths: [],
+                max_file_lines: 400,
                 required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
             },
+            planned: [
+                'Service Layer Enforcement: Controllers -> Services only',
+                'Repo Pattern: Databases access isolated to repositories/',
+            ],
         },
     },
     {
-        name: 'Python',
-        markers: ['pyproject.toml', 'requirements.txt', 'setup.py'],
+        name: 'infra',
+        markers: [
+            'Dockerfile',
+            'docker-compose.yml',
+            'main.tf',
+            'k8s/',
+            'helm/',
+            'ansible/',
+        ],
         config: {
-            commands: {
-                lint: 'ruff check .',
-                test: 'pytest',
+            preset: 'infra',
+            gates: {
+                max_file_lines: 300,
+                required_files: ['docs/RUNBOOK.md', 'docs/ARCH.md', 'README.md'],
             },
+        },
+    },
+    {
+        name: 'data',
+        markers: [
+            'ipynb',
+            'spark',
+            'pandas',
+            'data/',
+            'dbt_project.yml',
+        ],
+        config: {
+            preset: 'data',
             gates: {
                 max_file_lines: 500,
-                forbid_todos: true,
-                forbid_fixme: true,
-                forbid_paths: [],
-                required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
+                required_files: ['docs/DATA_DICTIONARY.md', 'docs/PIPELINE.md', 'README.md'],
             },
+            planned: [
+                'Stochastic Determinism: Seed setting enforcement',
+                'Data Leaks: Detecting PII in notebook outputs',
+            ],
         },
     },
+];
+exports.PARADIGM_TEMPLATES = [
     {
-        name: 'Frontend (React/Vite/Next)',
-        markers: ['next.config.js', 'vite.config.ts', 'tailwind.config.js'],
+        name: 'oop',
+        markers: [
+            'class ',
+            'interface ',
+            'implements ',
+            'extends ',
+        ],
         config: {
-            commands: {
-                lint: 'npm run lint',
-                test: 'npm test',
+            paradigm: 'oop',
+            gates: {
+            // Future: class-specific gates
             },
+        },
+    },
+    {
+        name: 'functional',
+        markers: [
+            '=>',
+            'export const',
+            'map(',
+            'filter(',
+        ],
+        config: {
+            paradigm: 'functional',
             gates: {
-                max_file_lines: 300, // Frontend files often should be smaller
-                forbid_todos: true,
-                forbid_fixme: true,
-                forbid_paths: [],
-                required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
+            // Future: function-specific gates
             },
         },
     },
@@ -63,8 +133,24 @@ exports.UNIVERSAL_CONFIG = {
         forbid_fixme: true,
         forbid_paths: [],
         required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'docs/DECISIONS.md', 'docs/TASKS.md'],
+        ast: {
+            complexity: 10,
+            max_methods: 10,
+            max_params: 5,
+        },
+        dependencies: {
+            forbid: [],
+        },
+        architecture: {
+            boundaries: [],
+        },
+        safety: {
+            max_files_changed_per_cycle: 10,
+            protected_paths: ['.github/**', 'docs/**', 'rigour.yml'],
+        },
     },
     output: {
         report_path: 'rigour-report.json',
     },
+    planned: [],
 };