@rigour-labs/core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rigour Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/discovery.d.ts

@@ -0,0 +1,5 @@
+import { Config } from './types/index.js';
+export declare class DiscoveryService {
+    discover(cwd: string): Promise<Config>;
+    private hasAnyMarker;
+}

package/dist/discovery.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryService = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+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 };
+        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 };
+            }
+        }
+        return config;
+    }
+    async hasAnyMarker(cwd, markers) {
+        for (const marker of markers) {
+            if (await fs_extra_1.default.pathExists(path_1.default.join(cwd, marker))) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.DiscoveryService = DiscoveryService;

package/dist/gates/base.d.ts

@@ -0,0 +1,11 @@
+import { Failure } from '../types/index.js';
+export interface GateContext {
+    cwd: string;
+}
+export declare abstract class Gate {
+    readonly id: string;
+    readonly title: string;
+    constructor(id: string, title: string);
+    abstract run(context: GateContext): Promise<Failure[]>;
+    protected createFailure(details: string, files?: string[], hint?: string): Failure;
+}

package/dist/gates/base.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gate = void 0;
+class Gate {
+    id;
+    title;
+    constructor(id, title) {
+        this.id = id;
+        this.title = title;
+    }
+    createFailure(details, files, hint) {
+        return {
+            id: this.id,
+            title: this.title,
+            details,
+            files,
+            hint,
+        };
+    }
+}
+exports.Gate = Gate;

package/dist/gates/content.d.ts

@@ -0,0 +1,11 @@
+import { Gate, GateContext } from './base.js';
+import { Failure } from '../types/index.js';
+export interface ContentGateConfig {
+    forbidTodos: boolean;
+    forbidFixme: boolean;
+}
+export declare class ContentGate extends Gate {
+    private config;
+    constructor(config: ContentGateConfig);
+    run(context: GateContext): Promise<Failure[]>;
+}

package/dist/gates/content.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentGate = void 0;
+const base_js_1 = require("./base.js");
+const scanner_js_1 = require("../utils/scanner.js");
+class ContentGate extends base_js_1.Gate {
+    config;
+    constructor(config) {
+        super('content-check', 'Forbidden Content');
+        this.config = config;
+    }
+    async run(context) {
+        const patterns = [];
+        if (this.config.forbidTodos)
+            patterns.push(/TODO/i);
+        if (this.config.forbidFixme)
+            patterns.push(/FIXME/i);
+        if (patterns.length === 0)
+            return [];
+        const files = await scanner_js_1.FileScanner.findFiles({ cwd: context.cwd });
+        const contents = await scanner_js_1.FileScanner.readFiles(context.cwd, files);
+        const violations = [];
+        for (const [file, content] of contents) {
+            for (const pattern of patterns) {
+                if (pattern.test(content)) {
+                    violations.push(file);
+                    break;
+                }
+            }
+        }
+        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 [];
+    }
+}
+exports.ContentGate = ContentGate;

package/dist/gates/file.d.ts

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

package/dist/gates/file.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileGate = void 0;
+const base_js_1 = require("./base.js");
+const scanner_js_1 = require("../utils/scanner.js");
+class FileGate extends base_js_1.Gate {
+    config;
+    constructor(config) {
+        super('file-size', 'File Size Limit');
+        this.config = config;
+    }
+    async run(context) {
+        const files = await scanner_js_1.FileScanner.findFiles({ cwd: context.cwd });
+        const contents = await scanner_js_1.FileScanner.readFiles(context.cwd, files);
+        const violations = [];
+        for (const [file, content] of contents) {
+            const lines = content.split('\n').length;
+            if (lines > this.config.maxLines) {
+                violations.push(`${file} (${lines} lines)`);
+            }
+        }
+        if (violations.length > 0) {
+            return [
+                this.createFailure(`The following files exceed the maximum limit of ${this.config.maxLines} lines:`, violations, 'Break these files into smaller, more modular components to improve maintainability (SOLID - Single Responsibility Principle).'),
+            ];
+        }
+        return [];
+    }
+}
+exports.FileGate = FileGate;

package/dist/gates/runner.d.ts

@@ -0,0 +1,13 @@
+import { Gate } from './base.js';
+import { Config, Report } from '../types/index.js';
+export declare class GateRunner {
+    private config;
+    private gates;
+    constructor(config: Config);
+    private initializeGates;
+    /**
+     * Allows adding custom gates dynamically (SOLID - Open/Closed Principle)
+     */
+    addGate(gate: Gate): void;
+    run(cwd: string): Promise<Report>;
+}

package/dist/gates/runner.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 execa_1 = require("execa");
+const logger_js_1 = require("../utils/logger.js");
+class GateRunner {
+    config;
+    gates = [];
+    constructor(config) {
+        this.config = config;
+        this.initializeGates();
+    }
+    initializeGates() {
+        if (this.config.gates.max_file_lines) {
+            this.gates.push(new file_js_1.FileGate({ maxLines: this.config.gates.max_file_lines }));
+        }
+        this.gates.push(new content_js_1.ContentGate({
+            forbidTodos: !!this.config.gates.forbid_todos,
+            forbidFixme: !!this.config.gates.forbid_fixme,
+        }));
+        if (this.config.gates.required_files) {
+            this.gates.push(new structure_js_1.StructureGate({ requiredFiles: this.config.gates.required_files }));
+        }
+    }
+    /**
+     * Allows adding custom gates dynamically (SOLID - Open/Closed Principle)
+     */
+    addGate(gate) {
+        this.gates.push(gate);
+    }
+    async run(cwd) {
+        const start = Date.now();
+        const failures = [];
+        const summary = {};
+        // 1. Run internal gates
+        for (const gate of this.gates) {
+            try {
+                const gateFailures = await gate.run({ cwd });
+                if (gateFailures.length > 0) {
+                    failures.push(...gateFailures);
+                    summary[gate.id] = 'FAIL';
+                }
+                else {
+                    summary[gate.id] = 'PASS';
+                }
+            }
+            catch (error) {
+                logger_js_1.Logger.error(`Gate ${gate.id} failed with error: ${error.message}`);
+                summary[gate.id] = 'ERROR';
+                failures.push({
+                    id: gate.id,
+                    title: `Gate Error: ${gate.title}`,
+                    details: error.message,
+                    hint: 'There was an internal error running this gate. Check the logs.',
+                });
+            }
+        }
+        // 2. Run command gates (lint, test, etc.)
+        const commands = this.config.commands;
+        if (commands) {
+            for (const [key, cmd] of Object.entries(commands)) {
+                if (!cmd) {
+                    summary[key] = 'SKIP';
+                    continue;
+                }
+                try {
+                    logger_js_1.Logger.info(`Running command gate: ${key} (${cmd})`);
+                    await (0, execa_1.execa)(cmd, { shell: true, cwd });
+                    summary[key] = 'PASS';
+                }
+                catch (error) {
+                    summary[key] = 'FAIL';
+                    failures.push({
+                        id: key,
+                        title: `${key.toUpperCase()} Check Failed`,
+                        details: error.stderr || error.stdout || error.message,
+                        hint: `Fix the issues reported by \`${cmd}\`. Use rigorous standards (SOLID, DRY) in your resolution.`,
+                    });
+                }
+            }
+        }
+        const status = failures.length > 0 ? 'FAIL' : 'PASS';
+        return {
+            status,
+            summary,
+            failures,
+            stats: {
+                duration_ms: Date.now() - start,
+            },
+        };
+    }
+}
+exports.GateRunner = GateRunner;

package/dist/gates/structure.d.ts

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

package/dist/gates/structure.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructureGate = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const base_js_1 = require("./base.js");
+class StructureGate extends base_js_1.Gate {
+    config;
+    constructor(config) {
+        super('structure-check', 'Project Structure');
+        this.config = config;
+    }
+    async run(context) {
+        const missing = [];
+        for (const file of this.config.requiredFiles) {
+            const filePath = path_1.default.join(context.cwd, file);
+            if (!(await fs_extra_1.default.pathExists(filePath))) {
+                missing.push(file);
+            }
+        }
+        if (missing.length > 0) {
+            return [
+                this.createFailure('The following required files are missing:', missing, 'Create these files to maintain project documentation and consistency.'),
+            ];
+        }
+        return [];
+    }
+}
+exports.StructureGate = StructureGate;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types/index.js';
+export * from './gates/runner.js';
+export * from './discovery.js';
+export * from './templates/index.js';
+export * from './utils/logger.js';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./types/index.js"), exports);
+__exportStar(require("./gates/runner.js"), exports);
+__exportStar(require("./discovery.js"), exports);
+__exportStar(require("./templates/index.js"), exports);
+__exportStar(require("./utils/logger.js"), exports);

package/dist/smoke.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/smoke.test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const runner_js_1 = require("../src/gates/runner.js");
+(0, vitest_1.describe)('GateRunner Smoke Test', () => {
+    (0, vitest_1.it)('should initialize with empty config', async () => {
+        const config = {
+            version: 1,
+            commands: {},
+            gates: {
+                max_file_lines: 500,
+                forbid_todos: true,
+                forbid_fixme: true,
+            },
+        };
+        const runner = new runner_js_1.GateRunner(config);
+        (0, vitest_1.expect)(runner).toBeDefined();
+    });
+});

package/dist/templates/index.d.ts

@@ -0,0 +1,8 @@
+import { Config } from '../types/index.js';
+export interface Template {
+    name: string;
+    markers: string[];
+    config: Partial<Config>;
+}
+export declare const TEMPLATES: Template[];
+export declare const UNIVERSAL_CONFIG: Config;

package/dist/templates/index.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNIVERSAL_CONFIG = exports.TEMPLATES = void 0;
+exports.TEMPLATES = [
+    {
+        name: 'Node.js',
+        markers: ['package.json'],
+        config: {
+            commands: {
+                lint: 'npm run lint',
+                test: 'npm test',
+            },
+            gates: {
+                max_file_lines: 500,
+                forbid_todos: true,
+                forbid_fixme: true,
+                forbid_paths: [],
+                required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
+            },
+        },
+    },
+    {
+        name: 'Python',
+        markers: ['pyproject.toml', 'requirements.txt', 'setup.py'],
+        config: {
+            commands: {
+                lint: 'ruff check .',
+                test: 'pytest',
+            },
+            gates: {
+                max_file_lines: 500,
+                forbid_todos: true,
+                forbid_fixme: true,
+                forbid_paths: [],
+                required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
+            },
+        },
+    },
+    {
+        name: 'Frontend (React/Vite/Next)',
+        markers: ['next.config.js', 'vite.config.ts', 'tailwind.config.js'],
+        config: {
+            commands: {
+                lint: 'npm run lint',
+                test: 'npm test',
+            },
+            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'],
+            },
+        },
+    },
+];
+exports.UNIVERSAL_CONFIG = {
+    version: 1,
+    commands: {},
+    gates: {
+        max_file_lines: 500,
+        forbid_todos: true,
+        forbid_fixme: true,
+        forbid_paths: [],
+        required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'docs/DECISIONS.md', 'docs/TASKS.md'],
+    },
+    output: {
+        report_path: 'rigour-report.json',
+    },
+};

package/dist/types/index.d.ts

@@ -0,0 +1,199 @@
+import { z } from 'zod';
+export declare const GatesSchema: z.ZodObject<{
+    max_file_lines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    forbid_todos: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    forbid_fixme: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    forbid_paths: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    required_files: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    max_file_lines: number;
+    forbid_todos: boolean;
+    forbid_fixme: boolean;
+    forbid_paths: string[];
+    required_files: string[];
+}, {
+    max_file_lines?: number | undefined;
+    forbid_todos?: boolean | undefined;
+    forbid_fixme?: boolean | undefined;
+    forbid_paths?: string[] | undefined;
+    required_files?: string[] | undefined;
+}>;
+export declare const CommandsSchema: z.ZodObject<{
+    format: z.ZodOptional<z.ZodString>;
+    lint: z.ZodOptional<z.ZodString>;
+    typecheck: z.ZodOptional<z.ZodString>;
+    test: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    format?: string | undefined;
+    lint?: string | undefined;
+    typecheck?: string | undefined;
+    test?: string | undefined;
+}, {
+    format?: string | undefined;
+    lint?: string | undefined;
+    typecheck?: string | undefined;
+    test?: string | undefined;
+}>;
+export declare const ConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodNumber>;
+    commands: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        format: z.ZodOptional<z.ZodString>;
+        lint: z.ZodOptional<z.ZodString>;
+        typecheck: z.ZodOptional<z.ZodString>;
+        test: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        format?: string | undefined;
+        lint?: string | undefined;
+        typecheck?: string | undefined;
+        test?: string | undefined;
+    }, {
+        format?: string | undefined;
+        lint?: string | undefined;
+        typecheck?: string | undefined;
+        test?: string | undefined;
+    }>>>;
+    gates: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        max_file_lines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        forbid_todos: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        forbid_fixme: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        forbid_paths: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        required_files: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        max_file_lines: number;
+        forbid_todos: boolean;
+        forbid_fixme: boolean;
+        forbid_paths: string[];
+        required_files: string[];
+    }, {
+        max_file_lines?: number | undefined;
+        forbid_todos?: boolean | undefined;
+        forbid_fixme?: boolean | undefined;
+        forbid_paths?: string[] | undefined;
+        required_files?: string[] | undefined;
+    }>>>;
+    output: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        report_path: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        report_path: string;
+    }, {
+        report_path?: string | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    commands: {
+        format?: string | undefined;
+        lint?: string | undefined;
+        typecheck?: string | undefined;
+        test?: string | undefined;
+    };
+    gates: {
+        max_file_lines: number;
+        forbid_todos: boolean;
+        forbid_fixme: boolean;
+        forbid_paths: string[];
+        required_files: string[];
+    };
+    output: {
+        report_path: string;
+    };
+}, {
+    version?: number | undefined;
+    commands?: {
+        format?: string | undefined;
+        lint?: string | undefined;
+        typecheck?: string | undefined;
+        test?: string | undefined;
+    } | undefined;
+    gates?: {
+        max_file_lines?: number | undefined;
+        forbid_todos?: boolean | undefined;
+        forbid_fixme?: boolean | undefined;
+        forbid_paths?: string[] | undefined;
+        required_files?: string[] | undefined;
+    } | undefined;
+    output?: {
+        report_path?: string | undefined;
+    } | undefined;
+}>;
+export type Gates = z.infer<typeof GatesSchema>;
+export type Commands = z.infer<typeof CommandsSchema>;
+export type Config = z.infer<typeof ConfigSchema>;
+export declare const StatusSchema: z.ZodEnum<["PASS", "FAIL", "SKIP", "ERROR"]>;
+export type Status = z.infer<typeof StatusSchema>;
+export declare const FailureSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    details: z.ZodString;
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    hint: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    details: string;
+    files?: string[] | undefined;
+    hint?: string | undefined;
+}, {
+    id: string;
+    title: string;
+    details: string;
+    files?: string[] | undefined;
+    hint?: string | undefined;
+}>;
+export type Failure = z.infer<typeof FailureSchema>;
+export declare const ReportSchema: z.ZodObject<{
+    status: z.ZodEnum<["PASS", "FAIL", "SKIP", "ERROR"]>;
+    summary: z.ZodRecord<z.ZodString, z.ZodEnum<["PASS", "FAIL", "SKIP", "ERROR"]>>;
+    failures: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        details: z.ZodString;
+        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        hint: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string;
+        details: string;
+        files?: string[] | undefined;
+        hint?: string | undefined;
+    }, {
+        id: string;
+        title: string;
+        details: string;
+        files?: string[] | undefined;
+        hint?: string | undefined;
+    }>, "many">;
+    stats: z.ZodObject<{
+        duration_ms: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        duration_ms: number;
+    }, {
+        duration_ms: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    status: "PASS" | "FAIL" | "SKIP" | "ERROR";
+    summary: Record<string, "PASS" | "FAIL" | "SKIP" | "ERROR">;
+    failures: {
+        id: string;
+        title: string;
+        details: string;
+        files?: string[] | undefined;
+        hint?: string | undefined;
+    }[];
+    stats: {
+        duration_ms: number;
+    };
+}, {
+    status: "PASS" | "FAIL" | "SKIP" | "ERROR";
+    summary: Record<string, "PASS" | "FAIL" | "SKIP" | "ERROR">;
+    failures: {
+        id: string;
+        title: string;
+        details: string;
+        files?: string[] | undefined;
+        hint?: string | undefined;
+    }[];
+    stats: {
+        duration_ms: number;
+    };
+}>;
+export type Report = z.infer<typeof ReportSchema>;