@rigour-labs/core 2.0.0 → 2.2.0

package/dist/safety.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SafetyGate } from './gates/safety.js';
+import { execa } from 'execa';
+vi.mock('execa');
+describe('SafetyGate', () => {
+    const config = {
+        safety: {
+            protected_paths: ['docs/'],
+            max_files_changed_per_cycle: 10
+        }
+    };
+    it('should flag modified (M) protected files', async () => {
+        const gate = new SafetyGate(config);
+        vi.mocked(execa).mockResolvedValueOnce({ stdout: ' M docs/SPEC.md\n' });
+        const failures = await gate.run({ cwd: '/test', record: {} });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].title).toContain("Protected file 'docs/SPEC.md' was modified.");
+    });
+    it('should flag added (A) protected files', async () => {
+        const gate = new SafetyGate(config);
+        vi.mocked(execa).mockResolvedValueOnce({ stdout: 'A  docs/NEW.md\n' });
+        const failures = await gate.run({ cwd: '/test', record: {} });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].title).toContain("Protected file 'docs/NEW.md' was modified.");
+    });
+    it('should NOT flag untracked (??) protected files', async () => {
+        const gate = new SafetyGate(config);
+        vi.mocked(execa).mockResolvedValueOnce({ stdout: '?? docs/UNTRAKED.md\n' });
+        const failures = await gate.run({ cwd: '/test', record: {} });
+        expect(failures).toHaveLength(0);
+    });
+    it('should correctly handle multiple mixed statuses', async () => {
+        const gate = new SafetyGate(config);
+        vi.mocked(execa).mockResolvedValueOnce({
+            stdout: ' M docs/MODIFIED.md\n?? docs/NEW_UNTRACKED.md\n D docs/DELETED.md\n'
+        });
+        const failures = await gate.run({ cwd: '/test', record: {} });
+        expect(failures).toHaveLength(2);
+        expect(failures.map(f => f.title)).toContain("Protected file 'docs/MODIFIED.md' was modified.");
+        expect(failures.map(f => f.title)).toContain("Protected file 'docs/DELETED.md' was modified.");
+    });
+});

package/dist/services/context-engine.d.ts

@@ -0,0 +1,22 @@
+import { Config } from '../types/index.js';
+export interface ProjectAnchor {
+    id: string;
+    type: 'env' | 'naming' | 'import';
+    pattern: string;
+    confidence: number;
+    occurrences: number;
+}
+export interface GoldenRecord {
+    anchors: ProjectAnchor[];
+    metadata: {
+        scannedFiles: number;
+        detectedCasing: 'camelCase' | 'snake_case' | 'PascalCase' | 'unknown';
+    };
+}
+export declare class ContextEngine {
+    private config;
+    constructor(config: Config);
+    discover(cwd: string): Promise<GoldenRecord>;
+    private mineEnvVars;
+    private incrementRegistry;
+}

package/dist/services/context-engine.js

@@ -0,0 +1,78 @@
+import { FileScanner } from '../utils/scanner.js';
+import path from 'path';
+import fs from 'fs-extra';
+export class ContextEngine {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async discover(cwd) {
+        const anchors = [];
+        const files = await FileScanner.findFiles({
+            cwd,
+            patterns: [
+                '**/*.{ts,js,py,yaml,yml,json}',
+                '.env*',
+                '**/.env*',
+                '**/package.json',
+                '**/Dockerfile',
+                '**/*.tf'
+            ]
+        });
+        const limit = this.config.gates.context?.mining_depth || 100;
+        const samples = files.slice(0, limit);
+        const envVars = new Map();
+        let scannedFiles = 0;
+        for (const file of samples) {
+            try {
+                const content = await fs.readFile(path.join(cwd, file), 'utf-8');
+                scannedFiles++;
+                this.mineEnvVars(content, file, envVars);
+            }
+            catch (e) { }
+        }
+        console.log(`[ContextEngine] Discovered ${envVars.size} env anchors`);
+        // Convert envVars to anchors
+        for (const [name, count] of envVars.entries()) {
+            const confidence = count >= 2 ? 1 : 0.5;
+            anchors.push({
+                id: name,
+                type: 'env',
+                pattern: name,
+                occurrences: count,
+                confidence
+            });
+        }
+        return {
+            anchors,
+            metadata: {
+                scannedFiles,
+                detectedCasing: 'unknown', // TODO: Implement casing discovery
+            }
+        };
+    }
+    mineEnvVars(content, file, registry) {
+        const isAnchorSource = file.includes('.env') || file.includes('yml') || file.includes('yaml');
+        if (isAnchorSource) {
+            const matches = content.matchAll(/^\s*([A-Z0-9_]+)\s*=/gm);
+            for (const match of matches) {
+                // Anchors from .env count for more initially
+                registry.set(match[1], (registry.get(match[1]) || 0) + 2);
+            }
+        }
+        // Source code matches (process.env.VAR or process.env['VAR'])
+        const tsJsMatches = content.matchAll(/process\.env(?:\.([A-Z0-9_]+)|\[['"]([A-Z0-9_]+)['"]\])/g);
+        for (const match of tsJsMatches) {
+            const name = match[1] || match[2];
+            this.incrementRegistry(registry, name);
+        }
+        // Python matches (os.environ.get('VAR') or os.environ['VAR'])
+        const pyMatches = content.matchAll(/os\.environ(?:\.get\(|\[)['"]([A-Z0-9_]+)['"]/g);
+        for (const match of pyMatches) {
+            this.incrementRegistry(registry, match[1]);
+        }
+    }
+    incrementRegistry(registry, key) {
+        registry.set(key, (registry.get(key) || 0) + 1);
+    }
+}

package/dist/templates/index.js

@@ -174,9 +174,22 @@ export const UNIVERSAL_CONFIG = {
             max_files_changed_per_cycle: 10,
             protected_paths: ['.github/**', 'docs/**', 'rigour.yml'],
         },
+        context: {
+            enabled: true,
+            sensitivity: 0.8,
+            mining_depth: 100,
+            ignored_patterns: [],
+        },
+        environment: {
+            enabled: true,
+            enforce_contracts: true,
+            tools: {},
+            required_env: [],
+        },
     },
     output: {
         report_path: 'rigour-report.json',
     },
     planned: [],
+    ignore: [],
 };

package/dist/types/index.d.ts

@@ -77,6 +77,38 @@ export declare const GatesSchema: z.ZodObject<{
         max_files_changed_per_cycle?: number | undefined;
         protected_paths?: string[] | undefined;
     }>>>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        sensitivity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        mining_depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        ignored_patterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        sensitivity: number;
+        mining_depth: number;
+        ignored_patterns: string[];
+    }, {
+        enabled?: boolean | undefined;
+        sensitivity?: number | undefined;
+        mining_depth?: number | undefined;
+        ignored_patterns?: string[] | undefined;
+    }>>>;
+    environment: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        enforce_contracts: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        tools: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        required_env: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        enforce_contracts: boolean;
+        tools: Record<string, string>;
+        required_env: string[];
+    }, {
+        enabled?: boolean | undefined;
+        enforce_contracts?: boolean | undefined;
+        tools?: Record<string, string> | undefined;
+        required_env?: string[] | undefined;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     max_file_lines: number;
     forbid_todos: boolean;
@@ -107,6 +139,18 @@ export declare const GatesSchema: z.ZodObject<{
         max_files_changed_per_cycle: number;
         protected_paths: string[];
     };
+    context: {
+        enabled: boolean;
+        sensitivity: number;
+        mining_depth: number;
+        ignored_patterns: string[];
+    };
+    environment: {
+        enabled: boolean;
+        enforce_contracts: boolean;
+        tools: Record<string, string>;
+        required_env: string[];
+    };
 }, {
     max_file_lines?: number | undefined;
     forbid_todos?: boolean | undefined;
@@ -137,6 +181,18 @@ export declare const GatesSchema: z.ZodObject<{
         max_files_changed_per_cycle?: number | undefined;
         protected_paths?: string[] | undefined;
     } | undefined;
+    context?: {
+        enabled?: boolean | undefined;
+        sensitivity?: number | undefined;
+        mining_depth?: number | undefined;
+        ignored_patterns?: string[] | undefined;
+    } | undefined;
+    environment?: {
+        enabled?: boolean | undefined;
+        enforce_contracts?: boolean | undefined;
+        tools?: Record<string, string> | undefined;
+        required_env?: string[] | undefined;
+    } | undefined;
 }>;
 export declare const CommandsSchema: z.ZodObject<{
     format: z.ZodOptional<z.ZodString>;
@@ -252,6 +308,38 @@ export declare const ConfigSchema: z.ZodObject<{
             max_files_changed_per_cycle?: number | undefined;
             protected_paths?: string[] | undefined;
         }>>>;
+        context: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            sensitivity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            mining_depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            ignored_patterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            sensitivity: number;
+            mining_depth: number;
+            ignored_patterns: string[];
+        }, {
+            enabled?: boolean | undefined;
+            sensitivity?: number | undefined;
+            mining_depth?: number | undefined;
+            ignored_patterns?: string[] | undefined;
+        }>>>;
+        environment: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            enforce_contracts: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            tools: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+            required_env: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            enforce_contracts: boolean;
+            tools: Record<string, string>;
+            required_env: string[];
+        }, {
+            enabled?: boolean | undefined;
+            enforce_contracts?: boolean | undefined;
+            tools?: Record<string, string> | undefined;
+            required_env?: string[] | undefined;
+        }>>>;
     }, "strip", z.ZodTypeAny, {
         max_file_lines: number;
         forbid_todos: boolean;
@@ -282,6 +370,18 @@ export declare const ConfigSchema: z.ZodObject<{
             max_files_changed_per_cycle: number;
             protected_paths: string[];
         };
+        context: {
+            enabled: boolean;
+            sensitivity: number;
+            mining_depth: number;
+            ignored_patterns: string[];
+        };
+        environment: {
+            enabled: boolean;
+            enforce_contracts: boolean;
+            tools: Record<string, string>;
+            required_env: string[];
+        };
     }, {
         max_file_lines?: number | undefined;
         forbid_todos?: boolean | undefined;
@@ -312,6 +412,18 @@ export declare const ConfigSchema: z.ZodObject<{
             max_files_changed_per_cycle?: number | undefined;
             protected_paths?: string[] | undefined;
         } | undefined;
+        context?: {
+            enabled?: boolean | undefined;
+            sensitivity?: number | undefined;
+            mining_depth?: number | undefined;
+            ignored_patterns?: string[] | undefined;
+        } | undefined;
+        environment?: {
+            enabled?: boolean | undefined;
+            enforce_contracts?: boolean | undefined;
+            tools?: Record<string, string> | undefined;
+            required_env?: string[] | undefined;
+        } | undefined;
     }>>>;
     output: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         report_path: z.ZodDefault<z.ZodString>;
@@ -321,7 +433,9 @@ export declare const ConfigSchema: z.ZodObject<{
         report_path?: string | undefined;
     }>>>;
     planned: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    ignore: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
+    ignore: string[];
     version: number;
     commands: {
         format?: string | undefined;
@@ -359,6 +473,18 @@ export declare const ConfigSchema: z.ZodObject<{
             max_files_changed_per_cycle: number;
             protected_paths: string[];
         };
+        context: {
+            enabled: boolean;
+            sensitivity: number;
+            mining_depth: number;
+            ignored_patterns: string[];
+        };
+        environment: {
+            enabled: boolean;
+            enforce_contracts: boolean;
+            tools: Record<string, string>;
+            required_env: string[];
+        };
     };
     output: {
         report_path: string;
@@ -367,6 +493,7 @@ export declare const ConfigSchema: z.ZodObject<{
     preset?: string | undefined;
     paradigm?: string | undefined;
 }, {
+    ignore?: string[] | undefined;
     version?: number | undefined;
     preset?: string | undefined;
     paradigm?: string | undefined;
@@ -406,6 +533,18 @@ export declare const ConfigSchema: z.ZodObject<{
             max_files_changed_per_cycle?: number | undefined;
             protected_paths?: string[] | undefined;
         } | undefined;
+        context?: {
+            enabled?: boolean | undefined;
+            sensitivity?: number | undefined;
+            mining_depth?: number | undefined;
+            ignored_patterns?: string[] | undefined;
+        } | undefined;
+        environment?: {
+            enabled?: boolean | undefined;
+            enforce_contracts?: boolean | undefined;
+            tools?: Record<string, string> | undefined;
+            required_env?: string[] | undefined;
+        } | undefined;
     } | undefined;
     output?: {
         report_path?: string | undefined;
@@ -415,6 +554,9 @@ export declare const ConfigSchema: z.ZodObject<{
 export type Gates = z.infer<typeof GatesSchema>;
 export type Commands = z.infer<typeof CommandsSchema>;
 export type Config = z.infer<typeof ConfigSchema>;
+export type RawGates = z.input<typeof GatesSchema>;
+export type RawCommands = z.input<typeof CommandsSchema>;
+export type RawConfig = z.input<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<{
@@ -470,6 +612,10 @@ export declare const ReportSchema: z.ZodObject<{
         score?: number | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
+    stats: {
+        duration_ms: number;
+        score?: number | undefined;
+    };
     status: "PASS" | "FAIL" | "SKIP" | "ERROR";
     summary: Record<string, "PASS" | "FAIL" | "SKIP" | "ERROR">;
     failures: {
@@ -479,11 +625,11 @@ export declare const ReportSchema: z.ZodObject<{
         files?: string[] | undefined;
         hint?: string | undefined;
     }[];
+}, {
     stats: {
         duration_ms: number;
         score?: number | undefined;
     };
-}, {
     status: "PASS" | "FAIL" | "SKIP" | "ERROR";
     summary: Record<string, "PASS" | "FAIL" | "SKIP" | "ERROR">;
     failures: {
@@ -493,9 +639,5 @@ export declare const ReportSchema: z.ZodObject<{
         files?: string[] | undefined;
         hint?: string | undefined;
     }[];
-    stats: {
-        duration_ms: number;
-        score?: number | undefined;
-    };
 }>;
 export type Report = z.infer<typeof ReportSchema>;

package/dist/types/index.js

@@ -34,6 +34,18 @@ export const GatesSchema = 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({}),
+    context: z.object({
+        enabled: z.boolean().optional().default(true),
+        sensitivity: z.number().min(0).max(1).optional().default(0.8), // 0.8 correlation threshold
+        mining_depth: z.number().optional().default(100), // Number of files to sample
+        ignored_patterns: z.array(z.string()).optional().default([]),
+    }).optional().default({}),
+    environment: z.object({
+        enabled: z.boolean().optional().default(true),
+        enforce_contracts: z.boolean().optional().default(true), // Auto-discovery of versions from truth sources
+        tools: z.record(z.string()).optional().default({}), // Explicit overrides
+        required_env: z.array(z.string()).optional().default([]),
+    }).optional().default({}),
 });
 export const CommandsSchema = z.object({
     format: z.string().optional(),
@@ -51,6 +63,7 @@ export const ConfigSchema = z.object({
         report_path: z.string().default('rigour-report.json'),
     }).optional().default({}),
     planned: z.array(z.string()).optional().default([]),
+    ignore: z.array(z.string()).optional().default([]),
 });
 export const StatusSchema = z.enum(['PASS', 'FAIL', 'SKIP', 'ERROR']);
 export const FailureSchema = z.object({

package/dist/utils/scanner.js

@@ -12,15 +12,20 @@ export class FileScanner {
         'rigour-report.json'
     ];
     static async findFiles(options) {
-        return globby(options.patterns || this.DEFAULT_PATTERNS, {
-            cwd: options.cwd,
-            ignore: options.ignore || this.DEFAULT_IGNORE,
+        const patterns = (options.patterns || this.DEFAULT_PATTERNS).map(p => p.replace(/\\/g, '/'));
+        const userIgnore = options.ignore || [];
+        const ignore = [...new Set([...this.DEFAULT_IGNORE, ...userIgnore])].map(p => p.replace(/\\/g, '/'));
+        const normalizedCwd = options.cwd.replace(/\\/g, '/');
+        return globby(patterns, {
+            cwd: normalizedCwd,
+            ignore: ignore,
         });
     }
     static async readFiles(cwd, files) {
         const contents = new Map();
         for (const file of files) {
-            const filePath = path.join(cwd, file);
+            const normalizedFile = file.replace(/\//g, path.sep);
+            const filePath = path.isAbsolute(normalizedFile) ? normalizedFile : path.join(cwd, normalizedFile);
             contents.set(file, await fs.readFile(filePath, 'utf-8'));
         }
         return contents;

package/dist/utils/scanner.test.d.ts

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

package/dist/utils/scanner.test.js

@@ -0,0 +1,29 @@
+import { describe, it, expect, vi } from 'vitest';
+import { FileScanner } from './scanner.js';
+import { globby } from 'globby';
+vi.mock('globby', () => ({
+    globby: vi.fn(),
+}));
+describe('FileScanner', () => {
+    it('should merge default ignores with user ignores', async () => {
+        const options = {
+            cwd: '/test',
+            ignore: ['custom-ignore']
+        };
+        await FileScanner.findFiles(options);
+        const call = vi.mocked(globby).mock.calls[0];
+        const ignore = call[1].ignore;
+        expect(ignore).toContain('**/node_modules/**');
+        expect(ignore).toContain('custom-ignore');
+    });
+    it('should normalize paths to forward slashes', async () => {
+        const options = {
+            cwd: 'C:\\test\\path',
+            patterns: ['**\\*.ts']
+        };
+        await FileScanner.findFiles(options);
+        const call = vi.mocked(globby).mock.calls[1];
+        expect(call[0][0]).toBe('**/*.ts');
+        expect(call[1]?.cwd).toBe('C:/test/path');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,6 +18,7 @@
     "fs-extra": "^11.3.3",
     "globby": "^14.1.0",
     "micromatch": "^4.0.8",
+    "semver": "^7.7.3",
     "typescript": "^5.9.3",
     "web-tree-sitter": "^0.26.3",
     "yaml": "^2.3.4",
@@ -26,7 +27,8 @@
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/micromatch": "^4.0.10",
-    "@types/node": "^25.0.3"
+    "@types/node": "^25.0.3",
+    "@types/semver": "^7.7.1"
   },
   "scripts": {
     "build": "tsc",

package/src/context.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { GateRunner } from '../src/gates/runner.js';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEST_CWD = path.join(__dirname, '../temp-test-context');
+
+describe('Context Awareness Engine', () => {
+    beforeAll(async () => {
+        await fs.ensureDir(TEST_CWD);
+    });
+
+    afterAll(async () => {
+        await fs.remove(TEST_CWD);
+    });
+
+    it('should detect context drift for redundant env suffixes (Golden Example)', async () => {
+        // Setup: Define standard GCP_PROJECT_ID
+        await fs.writeFile(path.join(TEST_CWD, '.env.example'), 'GCP_PROJECT_ID=my-project\n');
+
+        // Setup: Use drifted GCP_PROJECT_ID_PRODUCTION
+        await fs.writeFile(path.join(TEST_CWD, 'feature.js'), `
+            const id = process.env.GCP_PROJECT_ID_PRODUCTION;
+            console.log(id);
+        `);
+
+        const config = {
+            version: 1,
+            commands: {},
+            gates: {
+                context: {
+                    enabled: true,
+                    sensitivity: 0.8,
+                    mining_depth: 10,
+                },
+            },
+            output: { report_path: 'rigour-report.json' }
+        };
+
+        const runner = new GateRunner(config as any);
+        const report = await runner.run(TEST_CWD);
+
+        const driftFailures = report.failures.filter(f => f.id === 'context-drift');
+        expect(driftFailures.length).toBeGreaterThan(0);
+        expect(driftFailures[0].details).toContain('GCP_PROJECT_ID_PRODUCTION');
+        expect(driftFailures[0].hint).toContain('GCP_PROJECT_ID');
+    });
+
+    it('should not flag valid environment variables', async () => {
+        await fs.writeFile(path.join(TEST_CWD, 'valid.js'), `
+            const id = process.env.GCP_PROJECT_ID;
+        `);
+
+        const config = {
+            version: 1,
+            commands: {},
+            gates: {
+                context: { enabled: true },
+            },
+            output: { report_path: 'rigour-report.json' }
+        };
+
+        const runner = new GateRunner(config as any);
+        const report = await runner.run(TEST_CWD);
+
+        const driftFailures = report.failures.filter(f => f.id === 'context-drift');
+        // Filter out failures from other files if they still exist in TEST_CWD
+        const specificFailures = driftFailures.filter(f => f.files?.includes('valid.js'));
+        expect(specificFailures.length).toBe(0);
+    });
+});

package/src/discovery.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DiscoveryService } from './discovery.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+vi.mock('fs-extra');
+
+describe('DiscoveryService', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+
+    it('should discover project marker in root directory', async () => {
+        const service = new DiscoveryService();
+        vi.mocked(fs.pathExists).mockImplementation(async (p: string) => p.includes('package.json'));
+        vi.mocked(fs.readdir).mockResolvedValue(['package.json'] as any);
+        vi.mocked(fs.readFile).mockResolvedValue('{}' as any);
+
+        const result = await service.discover('/test');
+        // If package.json doesn't match a specific role marker, it stays Universal.
+        // Let's mock a specific one like 'express'
+        vi.mocked(fs.pathExists).mockImplementation(async (p: string) => p.includes('express'));
+        const result2 = await service.discover('/test');
+        expect(result2.matches.preset?.name).toBe('api');
+    });
+
+    it('should discover project marker in src/ directory (Deep Detection)', async () => {
+        const service = new DiscoveryService();
+        vi.mocked(fs.pathExists).mockImplementation((async (p: string) => {
+            if (p.endsWith('src')) return true;
+            if (p.includes('src/index.ts')) return true;
+            return false;
+        }) as any);
+        vi.mocked(fs.readdir).mockImplementation((async (p: string) => {
+            if (p.toString().endsWith('/test')) return ['src'] as any;
+            if (p.toString().endsWith('src')) return ['index.ts'] as any;
+            return [] as any;
+        }) as any);
+        vi.mocked(fs.readFile).mockResolvedValue('export const x = 1;' as any);
+
+        const result = await service.discover('/test');
+        // Since UNIVERSAL_CONFIG has a default, we check if it found something extra or matches expectation
+        // Default is universal, but detecting .ts should tilt it towards node or similar if configured
+        // In our current templates, package.json is the node marker.
+        // Let's check for paradigm detection which uses content
+        expect(result.config).toBeDefined();
+    });
+
+    it('should identify OOP paradigm from content in subfolder', async () => {
+        const service = new DiscoveryService();
+        vi.mocked(fs.pathExists).mockImplementation((async (p: string) => p.endsWith('src') || p.endsWith('src/Service.ts')) as any);
+        vi.mocked(fs.readdir).mockImplementation((async (p: string) => {
+            if (p.toString().endsWith('src')) return ['Service.ts'] as any;
+            return ['src'] as any;
+        }) as any);
+        vi.mocked(fs.readFile).mockResolvedValue('class MyService {}' as any);
+
+        const result = await service.discover('/test');
+        expect(result.matches.paradigm?.name).toBe('oop');
+    });
+});