@rigour-labs/core 1.0.0 → 1.4.0

package/dist/types/fix-packet.d.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+/**
+ * Fix Packet v2 Schema
+ * Designed for high-fidelity communication with AI agents during the refinement loop.
+ */
+export declare const FixPacketV2Schema: z.ZodObject<{
+    version: z.ZodLiteral<2>;
+    goal: z.ZodDefault<z.ZodString>;
+    violations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        gate: z.ZodString;
+        severity: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+        category: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        details: z.ZodString;
+        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        hint: z.ZodOptional<z.ZodString>;
+        instructions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string;
+        details: string;
+        gate: string;
+        severity: "low" | "medium" | "high" | "critical";
+        files?: string[] | undefined;
+        hint?: string | undefined;
+        category?: string | undefined;
+        instructions?: string[] | undefined;
+        metrics?: Record<string, any> | undefined;
+    }, {
+        id: string;
+        title: string;
+        details: string;
+        gate: string;
+        files?: string[] | undefined;
+        hint?: string | undefined;
+        severity?: "low" | "medium" | "high" | "critical" | undefined;
+        category?: string | undefined;
+        instructions?: string[] | undefined;
+        metrics?: Record<string, any> | undefined;
+    }>, "many">;
+    constraints: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        protected_paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        do_not_touch: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        max_files_changed: z.ZodOptional<z.ZodNumber>;
+        no_new_deps: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        allowed_dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        paradigm: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        no_new_deps: boolean;
+        protected_paths?: string[] | undefined;
+        paradigm?: string | undefined;
+        do_not_touch?: string[] | undefined;
+        max_files_changed?: number | undefined;
+        allowed_dependencies?: string[] | undefined;
+    }, {
+        protected_paths?: string[] | undefined;
+        paradigm?: string | undefined;
+        do_not_touch?: string[] | undefined;
+        max_files_changed?: number | undefined;
+        no_new_deps?: boolean | undefined;
+        allowed_dependencies?: string[] | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    version: 2;
+    goal: string;
+    violations: {
+        id: string;
+        title: string;
+        details: string;
+        gate: string;
+        severity: "low" | "medium" | "high" | "critical";
+        files?: string[] | undefined;
+        hint?: string | undefined;
+        category?: string | undefined;
+        instructions?: string[] | undefined;
+        metrics?: Record<string, any> | undefined;
+    }[];
+    constraints: {
+        no_new_deps: boolean;
+        protected_paths?: string[] | undefined;
+        paradigm?: string | undefined;
+        do_not_touch?: string[] | undefined;
+        max_files_changed?: number | undefined;
+        allowed_dependencies?: string[] | undefined;
+    };
+}, {
+    version: 2;
+    violations: {
+        id: string;
+        title: string;
+        details: string;
+        gate: string;
+        files?: string[] | undefined;
+        hint?: string | undefined;
+        severity?: "low" | "medium" | "high" | "critical" | undefined;
+        category?: string | undefined;
+        instructions?: string[] | undefined;
+        metrics?: Record<string, any> | undefined;
+    }[];
+    goal?: string | undefined;
+    constraints?: {
+        protected_paths?: string[] | undefined;
+        paradigm?: string | undefined;
+        do_not_touch?: string[] | undefined;
+        max_files_changed?: number | undefined;
+        no_new_deps?: boolean | undefined;
+        allowed_dependencies?: string[] | undefined;
+    } | undefined;
+}>;
+export type FixPacketV2 = z.infer<typeof FixPacketV2Schema>;

package/dist/types/fix-packet.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixPacketV2Schema = void 0;
+const zod_1 = require("zod");
+/**
+ * Fix Packet v2 Schema
+ * Designed for high-fidelity communication with AI agents during the refinement loop.
+ */
+exports.FixPacketV2Schema = zod_1.z.object({
+    version: zod_1.z.literal(2),
+    goal: zod_1.z.string().default('Achieve PASS state for all quality gates'),
+    violations: zod_1.z.array(zod_1.z.object({
+        id: zod_1.z.string(),
+        gate: zod_1.z.string(),
+        severity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
+        category: zod_1.z.string().optional(),
+        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(),
+        instructions: zod_1.z.array(zod_1.z.string()).optional(), // Step-by-step fix instructions
+        metrics: zod_1.z.record(zod_1.z.any()).optional(), // e.g., { complexity: 15, max: 10 }
+    })),
+    constraints: zod_1.z.object({
+        protected_paths: zod_1.z.array(zod_1.z.string()).optional(),
+        do_not_touch: zod_1.z.array(zod_1.z.string()).optional(), // Alias for protected_paths
+        max_files_changed: zod_1.z.number().optional(),
+        no_new_deps: zod_1.z.boolean().optional().default(true),
+        allowed_dependencies: zod_1.z.array(zod_1.z.string()).optional(),
+        paradigm: zod_1.z.string().optional(), // 'oop', 'functional'
+    }).optional().default({}),
+});

package/dist/types/index.d.ts

@@ -5,18 +5,118 @@ export declare const GatesSchema: z.ZodObject<{
     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">>>;
+    ast: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        complexity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_methods: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_params: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        complexity: number;
+        max_methods: number;
+        max_params: number;
+    }, {
+        complexity?: number | undefined;
+        max_methods?: number | undefined;
+        max_params?: number | undefined;
+    }>>>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        forbid: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        trusted_registry: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        forbid: string[];
+        trusted_registry?: string | undefined;
+    }, {
+        forbid?: string[] | undefined;
+        trusted_registry?: string | undefined;
+    }>>>;
+    architecture: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        boundaries: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            mode: z.ZodDefault<z.ZodEnum<["allow", "deny"]>>;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            mode: "allow" | "deny";
+        }, {
+            from: string;
+            to: string;
+            mode?: "allow" | "deny" | undefined;
+        }>, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        boundaries: {
+            from: string;
+            to: string;
+            mode: "allow" | "deny";
+        }[];
+    }, {
+        boundaries?: {
+            from: string;
+            to: string;
+            mode?: "allow" | "deny" | undefined;
+        }[] | undefined;
+    }>>>;
+    safety: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        max_files_changed_per_cycle: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        protected_paths: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        max_files_changed_per_cycle: number;
+        protected_paths: string[];
+    }, {
+        max_files_changed_per_cycle?: number | undefined;
+        protected_paths?: string[] | undefined;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     max_file_lines: number;
     forbid_todos: boolean;
     forbid_fixme: boolean;
     forbid_paths: string[];
     required_files: string[];
+    ast: {
+        complexity: number;
+        max_methods: number;
+        max_params: number;
+    };
+    dependencies: {
+        forbid: string[];
+        trusted_registry?: string | undefined;
+    };
+    architecture: {
+        boundaries: {
+            from: string;
+            to: string;
+            mode: "allow" | "deny";
+        }[];
+    };
+    safety: {
+        max_files_changed_per_cycle: number;
+        protected_paths: string[];
+    };
 }, {
     max_file_lines?: number | undefined;
     forbid_todos?: boolean | undefined;
     forbid_fixme?: boolean | undefined;
     forbid_paths?: string[] | undefined;
     required_files?: string[] | undefined;
+    ast?: {
+        complexity?: number | undefined;
+        max_methods?: number | undefined;
+        max_params?: number | undefined;
+    } | undefined;
+    dependencies?: {
+        forbid?: string[] | undefined;
+        trusted_registry?: string | undefined;
+    } | undefined;
+    architecture?: {
+        boundaries?: {
+            from: string;
+            to: string;
+            mode?: "allow" | "deny" | undefined;
+        }[] | undefined;
+    } | undefined;
+    safety?: {
+        max_files_changed_per_cycle?: number | undefined;
+        protected_paths?: string[] | undefined;
+    } | undefined;
 }>;
 export declare const CommandsSchema: z.ZodObject<{
     format: z.ZodOptional<z.ZodString>;
@@ -36,6 +136,8 @@ export declare const CommandsSchema: z.ZodObject<{
 }>;
 export declare const ConfigSchema: z.ZodObject<{
     version: z.ZodDefault<z.ZodNumber>;
+    preset: z.ZodOptional<z.ZodString>;
+    paradigm: z.ZodOptional<z.ZodString>;
     commands: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         format: z.ZodOptional<z.ZodString>;
         lint: z.ZodOptional<z.ZodString>;
@@ -58,18 +160,118 @@ export declare const ConfigSchema: z.ZodObject<{
         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">>>;
+        ast: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            complexity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            max_methods: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            max_params: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            complexity: number;
+            max_methods: number;
+            max_params: number;
+        }, {
+            complexity?: number | undefined;
+            max_methods?: number | undefined;
+            max_params?: number | undefined;
+        }>>>;
+        dependencies: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            forbid: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+            trusted_registry: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            forbid: string[];
+            trusted_registry?: string | undefined;
+        }, {
+            forbid?: string[] | undefined;
+            trusted_registry?: string | undefined;
+        }>>>;
+        architecture: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            boundaries: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                mode: z.ZodDefault<z.ZodEnum<["allow", "deny"]>>;
+            }, "strip", z.ZodTypeAny, {
+                from: string;
+                to: string;
+                mode: "allow" | "deny";
+            }, {
+                from: string;
+                to: string;
+                mode?: "allow" | "deny" | undefined;
+            }>, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            boundaries: {
+                from: string;
+                to: string;
+                mode: "allow" | "deny";
+            }[];
+        }, {
+            boundaries?: {
+                from: string;
+                to: string;
+                mode?: "allow" | "deny" | undefined;
+            }[] | undefined;
+        }>>>;
+        safety: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            max_files_changed_per_cycle: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            protected_paths: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            max_files_changed_per_cycle: number;
+            protected_paths: string[];
+        }, {
+            max_files_changed_per_cycle?: number | undefined;
+            protected_paths?: string[] | undefined;
+        }>>>;
     }, "strip", z.ZodTypeAny, {
         max_file_lines: number;
         forbid_todos: boolean;
         forbid_fixme: boolean;
         forbid_paths: string[];
         required_files: string[];
+        ast: {
+            complexity: number;
+            max_methods: number;
+            max_params: number;
+        };
+        dependencies: {
+            forbid: string[];
+            trusted_registry?: string | undefined;
+        };
+        architecture: {
+            boundaries: {
+                from: string;
+                to: string;
+                mode: "allow" | "deny";
+            }[];
+        };
+        safety: {
+            max_files_changed_per_cycle: number;
+            protected_paths: string[];
+        };
     }, {
         max_file_lines?: number | undefined;
         forbid_todos?: boolean | undefined;
         forbid_fixme?: boolean | undefined;
         forbid_paths?: string[] | undefined;
         required_files?: string[] | undefined;
+        ast?: {
+            complexity?: number | undefined;
+            max_methods?: number | undefined;
+            max_params?: number | undefined;
+        } | undefined;
+        dependencies?: {
+            forbid?: string[] | undefined;
+            trusted_registry?: string | undefined;
+        } | undefined;
+        architecture?: {
+            boundaries?: {
+                from: string;
+                to: string;
+                mode?: "allow" | "deny" | undefined;
+            }[] | undefined;
+        } | undefined;
+        safety?: {
+            max_files_changed_per_cycle?: number | undefined;
+            protected_paths?: string[] | undefined;
+        } | undefined;
     }>>>;
     output: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         report_path: z.ZodDefault<z.ZodString>;
@@ -78,6 +280,7 @@ export declare const ConfigSchema: z.ZodObject<{
     }, {
         report_path?: string | undefined;
     }>>>;
+    planned: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
     version: number;
     commands: {
@@ -92,12 +295,37 @@ export declare const ConfigSchema: z.ZodObject<{
         forbid_fixme: boolean;
         forbid_paths: string[];
         required_files: string[];
+        ast: {
+            complexity: number;
+            max_methods: number;
+            max_params: number;
+        };
+        dependencies: {
+            forbid: string[];
+            trusted_registry?: string | undefined;
+        };
+        architecture: {
+            boundaries: {
+                from: string;
+                to: string;
+                mode: "allow" | "deny";
+            }[];
+        };
+        safety: {
+            max_files_changed_per_cycle: number;
+            protected_paths: string[];
+        };
     };
     output: {
         report_path: string;
     };
+    planned: string[];
+    preset?: string | undefined;
+    paradigm?: string | undefined;
 }, {
     version?: number | undefined;
+    preset?: string | undefined;
+    paradigm?: string | undefined;
     commands?: {
         format?: string | undefined;
         lint?: string | undefined;
@@ -110,10 +338,31 @@ export declare const ConfigSchema: z.ZodObject<{
         forbid_fixme?: boolean | undefined;
         forbid_paths?: string[] | undefined;
         required_files?: string[] | undefined;
+        ast?: {
+            complexity?: number | undefined;
+            max_methods?: number | undefined;
+            max_params?: number | undefined;
+        } | undefined;
+        dependencies?: {
+            forbid?: string[] | undefined;
+            trusted_registry?: string | undefined;
+        } | undefined;
+        architecture?: {
+            boundaries?: {
+                from: string;
+                to: string;
+                mode?: "allow" | "deny" | undefined;
+            }[] | undefined;
+        } | undefined;
+        safety?: {
+            max_files_changed_per_cycle?: number | undefined;
+            protected_paths?: string[] | undefined;
+        } | undefined;
     } | undefined;
     output?: {
         report_path?: string | undefined;
     } | undefined;
+    planned?: string[] | undefined;
 }>;
 export type Gates = z.infer<typeof GatesSchema>;
 export type Commands = z.infer<typeof CommandsSchema>;

package/dist/types/index.js

@@ -13,6 +13,26 @@ exports.GatesSchema = zod_1.z.object({
         '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),
+    }).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(),
+    }).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'),
+        })).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']),
+    }).optional().default({}),
 });
 exports.CommandsSchema = zod_1.z.object({
     format: zod_1.z.string().optional(),
@@ -22,11 +42,14 @@ exports.CommandsSchema = zod_1.z.object({
 });
 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'),
     }).optional().default({}),
+    planned: zod_1.z.array(zod_1.z.string()).optional().default([]),
 });
 exports.StatusSchema = zod_1.z.enum(['PASS', 'FAIL', 'SKIP', 'ERROR']);
 exports.FailureSchema = zod_1.z.object({

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@rigour-labs/core",
-  "version": "1.0.0",
+  "version": "1.4.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "https://github.com/erashu212/rigour"
+    "url": "https://github.com/rigour-labs/rigour"
   },
   "publishConfig": {
     "access": "public",
@@ -16,11 +16,14 @@
     "execa": "^8.0.1",
     "fs-extra": "^11.3.3",
     "globby": "^14.1.0",
+    "micromatch": "^4.0.8",
+    "typescript": "^5.9.3",
     "yaml": "^2.3.4",
     "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
+    "@types/micromatch": "^4.0.10",
     "@types/node": "^25.0.3"
   },
   "scripts": {

package/src/discovery.ts

@@ -1,30 +1,94 @@
 import fs from 'fs-extra';
 import path from 'path';
 import { Config } from './types/index.js';
-import { TEMPLATES, UNIVERSAL_CONFIG } from './templates/index.js';
+import { TEMPLATES, PARADIGM_TEMPLATES, UNIVERSAL_CONFIG } from './templates/index.js';
+
+export interface DiscoveryResult {
+    config: Config;
+    matches: {
+        preset?: { name: string; marker: string };
+        paradigm?: { name: string; marker: string };
+    };
+}
 
 export class DiscoveryService {
-    async discover(cwd: string): Promise<Config> {
-        const config = { ...UNIVERSAL_CONFIG };
+    async discover(cwd: string): Promise<DiscoveryResult> {
+        let config = { ...UNIVERSAL_CONFIG };
+        const matches: DiscoveryResult['matches'] = {};
 
+        // 1. Detect Role (ui, api, infra, data)
         for (const template of 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
+            }
+        }
+
+        // 2. Detect Paradigm (oop, functional)
+        for (const template of 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;
+        return { config, matches };
     }
 
-    private async hasAnyMarker(cwd: string, markers: string[]): Promise<boolean> {
+    private mergeConfig(base: Config, extension: any): Config {
+        return {
+            ...base,
+            preset: extension.preset || base.preset,
+            paradigm: extension.paradigm || base.paradigm,
+            commands: { ...base.commands, ...extension.commands },
+            gates: { ...base.gates, ...extension.gates },
+        };
+    }
+
+    private async findFirstMarker(cwd: string, markers: string[], searchContent: boolean = false): Promise<string | null> {
         for (const marker of markers) {
-            if (await fs.pathExists(path.join(cwd, marker))) {
-                return true;
+            const fullPath = path.join(cwd, marker);
+
+            // File/Directory existence check
+            if (await fs.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;
+    }
+
+    private async existsInContent(cwd: string, pattern: string): Promise<boolean> {
+        // Simple heuristic: search in top 5 source files
+        const files = await this.findSourceFiles(cwd);
+        for (const file of files) {
+            const content = await fs.readFile(file, 'utf-8');
+            if (content.includes(pattern)) return true;
+        }
         return false;
     }
+
+    private async findSourceFiles(cwd: string): Promise<string[]> {
+        // Find a few files to sample
+        const extensions = ['.ts', '.js', '.py', '.go', '.java', '.tf', 'package.json'];
+        const samples: string[] = [];
+
+        const files = await fs.readdir(cwd);
+        for (const file of files) {
+            if (extensions.some(ext => file.endsWith(ext))) {
+                samples.push(path.join(cwd, file));
+                if (samples.length >= 5) break;
+            }
+        }
+        return samples;
+    }
 }