@rigour-labs/core 6.2.4 → 6.3.0

package/dist/deep/index.d.ts

@@ -7,8 +7,13 @@
  *
  * Neither AST nor LLM works alone. Together they're accurate.
  */
-export { extractFacts, factsToPromptString } from './fact-extractor.js';
+export { extractFacts, factsToPromptString, isTestFile } from './fact-extractor.js';
 export type { FileFacts, ClassFact, FunctionFact, ErrorHandlingFact, StructFact, InterfaceFact } from './fact-extractor.js';
 export { buildAnalysisPrompt, buildCrossFilePrompt, chunkFacts, DEEP_SYSTEM_PROMPT } from './prompts.js';
 export { verifyFindings } from './verifier.js';
 export type { VerifiedFinding } from './verifier.js';
+export { parseFindings } from './parse-findings.js';
+export { buildCodeContext } from './code-context.js';
+export type { CodeContext, LineRange } from './code-context.js';
+export { buildCodeReviewPrompt, REVIEW_CATEGORIES } from './code-review-prompt.js';
+export { verifyCodeFindings } from './code-verifier.js';

package/dist/deep/index.js

@@ -7,6 +7,10 @@
  *
  * Neither AST nor LLM works alone. Together they're accurate.
  */
-export { extractFacts, factsToPromptString } from './fact-extractor.js';
+export { extractFacts, factsToPromptString, isTestFile } from './fact-extractor.js';
 export { buildAnalysisPrompt, buildCrossFilePrompt, chunkFacts, DEEP_SYSTEM_PROMPT } from './prompts.js';
 export { verifyFindings } from './verifier.js';
+export { parseFindings } from './parse-findings.js';
+export { buildCodeContext } from './code-context.js';
+export { buildCodeReviewPrompt, REVIEW_CATEGORIES } from './code-review-prompt.js';
+export { verifyCodeFindings } from './code-verifier.js';

package/dist/deep/parse-findings.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parse an LLM response into structured findings.
+ *
+ * Handles raw JSON, markdown-wrapped JSON, a findings object embedded in
+ * prose, and truncated responses (the model hit its token budget mid-array).
+ */
+import type { DeepFinding } from '../inference/types.js';
+export declare function parseFindings(response: string): DeepFinding[];
+/** Extract the complete finding objects from a response cut off mid-array. */
+export declare function recoverTruncatedFindings(response: string): DeepFinding[];
+/** Drop malformed entries and normalise confidence and severity. */
+export declare function validateFindings(raw: unknown[]): DeepFinding[];

package/dist/deep/parse-findings.js

@@ -0,0 +1,73 @@
+import { Logger } from '../utils/logger.js';
+const VALID_SEVERITIES = ['critical', 'high', 'medium', 'low', 'info'];
+const FINDING_OBJECT = /\{\s*"category"\s*:\s*"[^"]+"\s*,[\s\S]*?"description"\s*:\s*"[^"]*"[^}]*\}/g;
+export function parseFindings(response) {
+    if (!response || response.trim().length === 0) {
+        Logger.warn('Empty LLM response received');
+        return [];
+    }
+    const candidates = [
+        response,
+        response.match(/```(?:json)?\s*([\s\S]*?)```/)?.[1],
+        response.match(/\{[\s\S]*"findings"[\s\S]*\}/)?.[0],
+    ];
+    for (const candidate of candidates) {
+        const parsed = candidate === undefined ? null : tryParseFindings(candidate);
+        if (parsed)
+            return parsed;
+    }
+    const recovered = recoverTruncatedFindings(response);
+    if (recovered.length > 0) {
+        Logger.info(`Recovered ${recovered.length} findings from truncated response`);
+        return recovered;
+    }
+    Logger.warn(`Could not parse LLM response as findings JSON. First 200 chars: ${response.substring(0, 200)}`);
+    return [];
+}
+function tryParseFindings(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (Array.isArray(parsed?.findings))
+            return validateFindings(parsed.findings);
+        if (Array.isArray(parsed))
+            return validateFindings(parsed);
+        return [];
+    }
+    catch {
+        return null;
+    }
+}
+/** Extract the complete finding objects from a response cut off mid-array. */
+export function recoverTruncatedFindings(response) {
+    const findings = [];
+    for (const match of response.matchAll(FINDING_OBJECT)) {
+        try {
+            findings.push(JSON.parse(match[0]));
+        }
+        catch {
+            // The object itself was truncated; skip it.
+        }
+    }
+    return validateFindings(findings);
+}
+/** Drop malformed entries and normalise confidence and severity. */
+export function validateFindings(raw) {
+    return raw.filter(hasRequiredFields).map(normalizeFinding);
+}
+function hasRequiredFields(f) {
+    return !!f && typeof f === 'object'
+        && isNonEmptyString(f.category)
+        && isNonEmptyString(f.file)
+        && isNonEmptyString(f.description);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function normalizeFinding(f) {
+    const confidenceOk = typeof f.confidence === 'number' && f.confidence >= 0 && f.confidence <= 1;
+    return {
+        ...f,
+        confidence: confidenceOk ? f.confidence : 0.5,
+        severity: VALID_SEVERITIES.includes(f.severity) ? f.severity : 'medium',
+    };
+}

package/dist/deep/parse-findings.test.d.ts

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

package/dist/deep/parse-findings.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { parseFindings } from './parse-findings.js';
+const finding = { category: 'correctness', severity: 'high', file: 'a.ts', line: 3, description: 'bug', suggestion: 'fix', confidence: 0.8 };
+describe('parseFindings', () => {
+    it('parses a findings object, a bare array and fenced JSON', () => {
+        expect(parseFindings(JSON.stringify({ findings: [finding] }))).toHaveLength(1);
+        expect(parseFindings(JSON.stringify([finding]))).toHaveLength(1);
+        expect(parseFindings('Here you go:\n```json\n' + JSON.stringify({ findings: [finding] }) + '\n```')).toHaveLength(1);
+    });
+    it('recovers complete findings from a response cut off by the token budget', () => {
+        const cut = `{"findings": [${JSON.stringify(finding)}, {"category": "security", "severity": "hi`;
+        expect(parseFindings(cut)).toEqual([finding]);
+    });
+    it('drops malformed entries and normalises confidence and severity', () => {
+        const parsed = parseFindings(JSON.stringify({ findings: [
+                { ...finding, severity: 'urgent', confidence: 7 },
+                { category: 'x', description: 'no file' },
+            ] }));
+        expect(parsed).toEqual([{ ...finding, severity: 'medium', confidence: 0.5 }]);
+    });
+    it('returns nothing for empty or non-JSON output', () => {
+        expect(parseFindings('')).toEqual([]);
+        expect(parseFindings('I could not find any issues.')).toEqual([]);
+    });
+});

package/dist/deep/prompts.d.ts

@@ -2,7 +2,7 @@
  * Prompt Engineering — Step 2 of the three-step pipeline.
  * Constructs structured prompts that ask the LLM to interpret AST-extracted facts.
  */
-import type { FileFacts } from './fact-extractor.js';
+import { type FileFacts } from './fact-extractor.js';
 /**
  * System prompt that defines the LLM's role and output format.
  */

package/dist/deep/prompts.js

@@ -1,3 +1,8 @@
+/**
+ * Prompt Engineering — Step 2 of the three-step pipeline.
+ * Constructs structured prompts that ask the LLM to interpret AST-extracted facts.
+ */
+import { factsToPromptString } from './fact-extractor.js';
 /**
  * System prompt that defines the LLM's role and output format.
  */
@@ -362,13 +367,7 @@ export function chunkFacts(facts, maxCharsPerChunk = 6000) {
     }
     return chunks;
 }
+/** Serialized size of one file's facts, so chunks never overrun the prompt budget. */
 function estimateFactSize(f) {
-    let size = f.path.length + 50;
-    size += f.classes.reduce((a, c) => a + c.name.length + c.methods.length * 20 + 50, 0);
-    size += (f.structs || []).reduce((a, s) => a + s.name.length + s.methods.length * 20 + s.embeds.length * 15 + 60, 0);
-    size += (f.interfaces || []).reduce((a, i) => a + i.name.length + i.methods.length * 15 + 40, 0);
-    size += f.functions.reduce((a, fn) => a + fn.name.length + fn.params.length * 15 + 50, 0);
-    size += f.imports.length * 30;
-    size += f.errorHandling.length * 30;
-    return size;
+    return factsToPromptString([f], Number.POSITIVE_INFINITY).length + 2;
 }

package/dist/deep/prompts.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { buildAnalysisPrompt, buildCrossFilePrompt, chunkFacts, DEEP_SYSTEM_PROMPT } from './prompts.js';
+import { factsToPromptString } from './fact-extractor.js';
 // ── Test helpers ──
 function makeGoFacts(overrides = {}) {
     return {
@@ -195,6 +196,20 @@ describe('Deep Analysis Prompts', () => {
     });
     // ── chunkFacts ──
     describe('chunkFacts', () => {
+        it('never lets the serialized chunk overrun the prompt budget, so no file is dropped', () => {
+            const facts = Array.from({ length: 40 }, (_, i) => makeTsFacts({
+                path: `src/deeply/nested/module-${i}/implementation-file-with-a-long-name-${i}.ts`,
+                lineCount: 300,
+                imports: Array.from({ length: 8 }, (_, j) => `@scope/package-with-long-name-${j}/sub/path`),
+            }));
+            const chunks = chunkFacts(facts, 6000);
+            expect(chunks.flat()).toHaveLength(facts.length);
+            for (const chunk of chunks) {
+                const text = factsToPromptString(chunk);
+                for (const f of chunk)
+                    expect(text).toContain(`FILE: ${f.path}`);
+            }
+        });
         it('should split facts into token-limited chunks', () => {
             const manyFacts = Array.from({ length: 50 }, (_, i) => makeTsFacts({
                 path: `src/file${i}.ts`,

package/dist/discovery-signals.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Framework and library markers. These are decided by the project's declared
+ * dependencies only: as words they are too common in code and prose
+ * ("next()" in Express middleware, "reactivity" in a Svelte comment).
+ */
+export declare const PACKAGE_MARKERS: Set<string>;
+/** Declared dependency names: package.json sections, requirements.txt and pyproject.toml. */
+export declare function dependencyNames(cwd: string): Promise<Set<string>>;
+/** `marker` is declared as a dependency, directly or as its scope (`@nestjs/core`). */
+export declare function declaresPackage(dependencies: Set<string>, marker: string): boolean;
+/** Up to MAX_SAMPLE project source files (not configs or tests), spread evenly so one package cannot fill the sample. */
+export declare function sampleSourceFiles(cwd: string): Promise<string[]>;
+/** Markers naming a file extension (`ipynb`): proven by one such file existing, not by the word. */
+export declare const EXTENSION_MARKERS: Set<string>;
+export declare function hasFileWithExtension(cwd: string, extension: string): Promise<boolean>;
+/** A marker naming a file or folder (`next.config.js`, `k8s/`, `Dockerfile`), which only its existence proves. */
+export declare function isPathMarker(marker: string): boolean;
+/** `marker` as a whole token, not inside a longer word or package name. */
+export declare function containsToken(text: string, marker: string): boolean;
+/** Drop line and block comments so prose is not read as code. */
+export declare function stripComments(text: string): string;
+export interface ParadigmSignal {
+    name: 'oop' | 'functional';
+    marker: string;
+}
+/** OOP or functional by declaration counts in comment-free sources; null when neither clearly dominates. */
+export declare function detectParadigm(contents: string[]): ParadigmSignal | null;

package/dist/discovery-signals.js

@@ -0,0 +1,96 @@
+/**
+ * Signals for `rigour init` discovery.
+ *
+ * Substring search misread projects: "reactivity" in an ESLint comment made
+ * a Svelte repo "react", and "the public internet" in a Playwright comment
+ * made it "OOP". Framework markers now match package.json dependency names,
+ * other markers match whole tokens, and the paradigm comes from counting
+ * declarations in real source files, with no guess when neither side leads.
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { globby } from 'globby';
+const SOURCE_EXT = '{ts,tsx,js,jsx,mjs,py,go,java,kt,rb}';
+const SOURCE_GLOBS = [
+    `{src,lib,app,pkg,api,internal,cmd}/**/*.${SOURCE_EXT}`,
+    `{packages,apps,services}/*/{src,lib,app}/**/*.${SOURCE_EXT}`,
+    '*.{py,go}',
+];
+const SOURCE_IGNORE = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/*.d.ts', '**/*.config.*', '**/*.{test,spec}.*', '**/__tests__/**'];
+const MAX_SAMPLE = 40;
+/**
+ * Framework and library markers. These are decided by the project's declared
+ * dependencies only: as words they are too common in code and prose
+ * ("next()" in Express middleware, "reactivity" in a Svelte comment).
+ */
+export const PACKAGE_MARKERS = new Set(['react', 'next', 'vue', 'svelte', 'express', 'fastify', 'nestjs', 'spark', 'pandas']);
+/** Declared dependency names: package.json sections, requirements.txt and pyproject.toml. */
+export async function dependencyNames(cwd) {
+    const names = new Set();
+    const pkg = await fs.readJson(path.join(cwd, 'package.json')).catch(() => null);
+    for (const section of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+        for (const name of Object.keys(pkg?.[section] ?? {}))
+            names.add(name);
+    }
+    const requirements = await fs.readFile(path.join(cwd, 'requirements.txt'), 'utf-8').catch(() => '');
+    for (const match of requirements.matchAll(/^\s*([A-Za-z0-9][\w.-]*)/gm))
+        names.add(match[1].toLowerCase());
+    const pyproject = await fs.readFile(path.join(cwd, 'pyproject.toml'), 'utf-8').catch(() => '');
+    for (const match of pyproject.matchAll(/["']([A-Za-z0-9][\w.-]*)\s*(?:\[[^\]]*\])?\s*(?:[<>=~!;]|["'])/g))
+        names.add(match[1].toLowerCase());
+    return names;
+}
+/** `marker` is declared as a dependency, directly or as its scope (`@nestjs/core`). */
+export function declaresPackage(dependencies, marker) {
+    if (dependencies.has(marker))
+        return true;
+    for (const name of dependencies)
+        if (name.startsWith(`@${marker}/`))
+            return true;
+    return false;
+}
+/** Up to MAX_SAMPLE project source files (not configs or tests), spread evenly so one package cannot fill the sample. */
+export async function sampleSourceFiles(cwd) {
+    const files = (await globby(SOURCE_GLOBS, { cwd, ignore: SOURCE_IGNORE, gitignore: false, followSymbolicLinks: false })).sort();
+    const stride = Math.max(1, files.length / MAX_SAMPLE);
+    const sample = [];
+    for (let i = 0; i < files.length && sample.length < MAX_SAMPLE; i += stride)
+        sample.push(files[Math.floor(i)]);
+    return sample.map(f => path.join(cwd, f));
+}
+/** Markers naming a file extension (`ipynb`): proven by one such file existing, not by the word. */
+export const EXTENSION_MARKERS = new Set(['ipynb']);
+export async function hasFileWithExtension(cwd, extension) {
+    const found = await globby(`**/*.${extension}`, { cwd, ignore: ['**/node_modules/**', '**/.git/**'], gitignore: false, followSymbolicLinks: false, deep: 4 });
+    return found.length > 0;
+}
+/** A marker naming a file or folder (`next.config.js`, `k8s/`, `Dockerfile`), which only its existence proves. */
+export function isPathMarker(marker) {
+    return /[./]/.test(marker) || /^[A-Z]/.test(marker);
+}
+/** `marker` as a whole token, not inside a longer word or package name. */
+export function containsToken(text, marker) {
+    const escaped = marker.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`(?<![\\w@/.-])${escaped}(?![\\w-])`, 'i').test(text);
+}
+/** Drop line and block comments so prose is not read as code. */
+export function stripComments(text) {
+    return text.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:"'`])\/\/.*$/gm, '$1').replace(/^\s*#.*$/gm, '');
+}
+const CLASS_DECLARATION = /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?(?:public\s+)?class\s+[A-Z]\w*/gm;
+const FUNCTION_DECLARATION = /^\s*(?:export\s+(?:default\s+)?(?:async\s+)?function\b|export\s+const\s+\w+\s*(?::[^=]+)?=\s*(?:async\s*)?(?:\([^)]*\)|\w+)\s*(?::[^=]+)?=>|def\s+\w+\s*\(|func\s+\w+\s*\()/gm;
+/** OOP or functional by declaration counts in comment-free sources; null when neither clearly dominates. */
+export function detectParadigm(contents) {
+    let classes = 0;
+    let functions = 0;
+    for (const text of contents) {
+        classes += text.match(CLASS_DECLARATION)?.length ?? 0;
+        functions += text.match(FUNCTION_DECLARATION)?.length ?? 0;
+    }
+    const marker = `declarations: ${classes} classes, ${functions} functions`;
+    if (classes > 0 && classes >= 2 * functions)
+        return { name: 'oop', marker };
+    if (functions > 0 && functions >= 2 * classes)
+        return { name: 'functional', marker };
+    return null;
+}

package/dist/discovery.d.ts

@@ -16,6 +16,5 @@ export declare class DiscoveryService {
     discover(cwd: string): Promise<DiscoveryResult>;
     private mergeConfig;
     private findFirstMarker;
-    private existsInContent;
-    private findSourceFiles;
+    private recurs;
 }

package/dist/discovery.js

@@ -1,28 +1,37 @@
 import fs from 'fs-extra';
 import path from 'path';
 import { TEMPLATES, PARADIGM_TEMPLATES, UNIVERSAL_CONFIG } from './templates/index.js';
+import { EXTENSION_MARKERS, PACKAGE_MARKERS, containsToken, hasFileWithExtension, declaresPackage, dependencyNames, detectParadigm, isPathMarker, sampleSourceFiles, stripComments, } from './discovery-signals.js';
+/**
+ * Domain keywords are ambiguous alone ("health" score, "transaction" block), and a
+ * domain preset adds compliance docs and stricter gates. It needs several keywords,
+ * each recurring across files rather than listed once.
+ */
+const MIN_KEYWORDS = 2;
+const MIN_KEYWORD_FILES = 2;
 export class DiscoveryService {
     async discover(cwd) {
         let config = { ...UNIVERSAL_CONFIG };
         const matches = {};
-        // 1. Detect Role (ui, api, infra, data)
+        const dependencies = await dependencyNames(cwd);
+        const files = await sampleSourceFiles(cwd);
+        const contents = await Promise.all(files.map(f => fs.readFile(f, 'utf-8').then(stripComments, () => '')));
+        // 1. Role (ui, api, infra, data, domain presets): the first template with a marker wins.
         for (const template of TEMPLATES) {
-            const marker = await this.findFirstMarker(cwd, template.markers, true); // Search content for roles too
+            const marker = await this.findFirstMarker(cwd, template.markers, dependencies, contents);
             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;
             }
         }
+        // 2. Paradigm (oop, functional): only when the declarations clearly lean one way.
+        const paradigm = detectParadigm(contents);
+        const template = paradigm && PARADIGM_TEMPLATES.find(t => t.name === paradigm.name);
+        if (paradigm && template) {
+            config = this.mergeConfig(config, template.config);
+            matches.paradigm = paradigm;
+        }
         return { config, matches };
     }
     mergeConfig(base, extension) {
@@ -47,49 +56,27 @@ export class DiscoveryService {
             ignore: [...new Set([...(base.ignore || []), ...(extension.ignore || [])])],
         };
     }
-    async findFirstMarker(cwd, markers, searchContent = false) {
+    async findFirstMarker(cwd, markers, dependencies, contents) {
+        const keywords = [];
         for (const marker of markers) {
-            const fullPath = path.join(cwd, marker);
-            // File/Directory existence check
-            if (await fs.pathExists(fullPath)) {
+            if (PACKAGE_MARKERS.has(marker)) {
+                if (declaresPackage(dependencies, marker))
+                    return `dependency:${marker}`;
+            }
+            else if (EXTENSION_MARKERS.has(marker)) {
+                if (await hasFileWithExtension(cwd, marker))
+                    return `file:*.${marker}`;
+            }
+            else if (await fs.pathExists(path.join(cwd, marker))) {
                 return marker;
             }
-            // Deep content check for paradigms
-            if (searchContent) {
-                const match = await this.existsInContent(cwd, marker);
-                if (match)
-                    return `content:${marker}`;
+            else if (!isPathMarker(marker) && this.recurs(contents, marker)) {
+                keywords.push(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.readFile(file, 'utf-8');
-            if (content.includes(pattern))
-                return true;
-        }
-        return false;
+        return keywords.length >= MIN_KEYWORDS ? `content:${keywords.join(',')}` : null;
     }
-    async findSourceFiles(cwd) {
-        const extensions = ['.ts', '.js', '.py', '.go', '.java', '.tf', 'package.json'];
-        const samples = [];
-        const commonDirs = ['.', 'src', 'app', 'lib', 'api', 'pkg'];
-        for (const dir of commonDirs) {
-            const fullDir = path.join(cwd, dir);
-            if (!(await fs.pathExists(fullDir)))
-                continue;
-            const files = await fs.readdir(fullDir);
-            for (const file of files) {
-                if (extensions.some(ext => file.endsWith(ext))) {
-                    samples.push(path.join(fullDir, file));
-                    if (samples.length >= 5)
-                        return samples;
-                }
-            }
-        }
-        return samples;
+    recurs(contents, keyword) {
+        return contents.filter(text => containsToken(text, keyword)).length >= MIN_KEYWORD_FILES;
     }
 }

package/dist/discovery.test.js

@@ -1,80 +1,93 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { DiscoveryService } from './discovery.js';
-import fs from 'fs-extra';
-vi.mock('fs-extra');
+import { containsToken, detectParadigm, stripComments } from './discovery-signals.js';
 describe('DiscoveryService', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
+    let cwd;
+    beforeEach(() => { cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'discovery-')); });
+    afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
+    function write(rel, body) {
+        fs.mkdirSync(path.dirname(path.join(cwd, rel)), { recursive: true });
+        fs.writeFileSync(path.join(cwd, rel), body);
+    }
+    const discover = () => new DiscoveryService().discover(cwd);
+    it('detects an API from a declared dependency', async () => {
+        write('package.json', JSON.stringify({ dependencies: { express: '^4.0.0' } }));
+        const result = await discover();
+        expect(result.matches.preset).toEqual({ name: 'api', marker: 'dependency:express' });
     });
-    it('should discover project marker in root directory', async () => {
-        const service = new DiscoveryService();
-        vi.mocked(fs.pathExists).mockImplementation(async (p) => p.includes('package.json'));
-        vi.mocked(fs.readdir).mockResolvedValue(['package.json']);
-        vi.mocked(fs.readFile).mockResolvedValue('{}');
-        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) => p.includes('express'));
-        const result2 = await service.discover('/test');
-        expect(result2.matches.preset?.name).toBe('api');
+    it('detects a scoped framework package such as @nestjs/core', async () => {
+        write('package.json', JSON.stringify({ dependencies: { '@nestjs/core': '^10.0.0' } }));
+        expect((await discover()).matches.preset?.marker).toBe('dependency:nestjs');
     });
-    it('should discover project marker in src/ directory (Deep Detection)', async () => {
-        const service = new DiscoveryService();
-        vi.mocked(fs.pathExists).mockImplementation((async (p) => {
-            if (p.endsWith('src'))
-                return true;
-            if (p.includes('src/index.ts'))
-                return true;
-            return false;
-        }));
-        vi.mocked(fs.readdir).mockImplementation((async (p) => {
-            if (p.toString().endsWith('/test'))
-                return ['src'];
-            if (p.toString().endsWith('src'))
-                return ['index.ts'];
-            return [];
-        }));
-        vi.mocked(fs.readFile).mockResolvedValue('export const x = 1;');
-        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) => p.endsWith('src') || p.endsWith('src/Service.ts')));
-        vi.mocked(fs.readdir).mockImplementation((async (p) => {
-            if (p.toString().endsWith('src'))
-                return ['Service.ts'];
-            return ['src'];
-        }));
-        vi.mocked(fs.readFile).mockResolvedValue('class MyService {}');
-        const result = await service.discover('/test');
-        expect(result.matches.paradigm?.name).toBe('oop');
-    });
-    it('should include project-type-aware ignore patterns for API preset', async () => {
-        const service = new DiscoveryService();
-        // Mock finding requirements.txt (Python API marker)
-        vi.mocked(fs.pathExists).mockImplementation(async (p) => p.includes('requirements.txt'));
-        vi.mocked(fs.readdir).mockResolvedValue(['requirements.txt']);
-        vi.mocked(fs.readFile).mockResolvedValue('flask==2.0.0');
-        const result = await service.discover('/test');
+    it('detects a Python API with its ignore patterns', async () => {
+        write('requirements.txt', 'flask==2.0.0\n');
+        const result = await discover();
         expect(result.matches.preset?.name).toBe('api');
-        expect(result.config.ignore).toContain('venv/**');
-        expect(result.config.ignore).toContain('__pycache__/**');
-        expect(result.config.ignore).toContain('*.pyc');
+        expect(result.config.ignore).toEqual(expect.arrayContaining(['venv/**', '__pycache__/**', '*.pyc']));
     });
-    it('should include project-type-aware ignore patterns for UI preset', async () => {
-        const service = new DiscoveryService();
-        // Mock finding next.config.js (UI marker)
-        vi.mocked(fs.pathExists).mockImplementation(async (p) => p.includes('next.config.js'));
-        vi.mocked(fs.readdir).mockResolvedValue(['next.config.js']);
-        vi.mocked(fs.readFile).mockResolvedValue('module.exports = {}');
-        const result = await service.discover('/test');
+    it('detects a UI project from a config file with its ignore patterns', async () => {
+        write('next.config.js', 'module.exports = {};\n');
+        const result = await discover();
         expect(result.matches.preset?.name).toBe('ui');
-        expect(result.config.ignore).toContain('node_modules/**');
-        expect(result.config.ignore).toContain('.next/**');
+        expect(result.config.ignore).toEqual(expect.arrayContaining(['node_modules/**', '.next/**']));
+    });
+    it('detects Svelte from its dependencies, not "reactivity" or "public" in comments', async () => {
+        write('package.json', JSON.stringify({ devDependencies: { '@sveltejs/kit': '^2.0.0', svelte: '^5.0.0' } }));
+        write('eslint.config.js', '// Svelte 5 rules (state_referenced_locally, a11y, reactivity)\nexport default [];\n');
+        write('playwright.config.ts', '// rides the public internet\nexport default {};\n');
+        write('src/lib/format.ts', 'export function format(v: number) { return v.toFixed(2); }\nexport const pad = (s: string) => s.padStart(2);\n');
+        const result = await discover();
+        expect(result.matches.preset).toEqual({ name: 'ui', marker: 'dependency:svelte' });
+        expect(result.matches.paradigm?.name).toBe('functional');
+    });
+    it('does not read a framework name in source text as a dependency', async () => {
+        write('src/middleware.ts', 'export function run(next: () => void) { next(); }\n');
+        expect((await discover()).matches.preset).toBeUndefined();
+    });
+    it('identifies OOP from class declarations in a subfolder', async () => {
+        write('src/Service.ts', 'export class MyService {}\nexport class OtherService {}\n');
+        const result = await discover();
+        expect(result.matches.paradigm).toEqual({ name: 'oop', marker: 'declarations: 2 classes, 0 functions' });
+    });
+    it('needs several recurring domain keywords before choosing a domain preset', async () => {
+        write('src/billing.ts', 'export const ledger = new Map<string, number>();\n');
+        write('src/report.ts', "import { ledger } from './billing';\nexport const total = () => ledger.size;\n");
+        expect((await discover()).matches.preset).toBeUndefined();
+        write('src/pay.ts', 'export function payment(ledger: Map<string, number>) { return ledger; }\n');
+        write('src/refund.ts', 'export function refund(payment: number) { return -payment; }\n');
+        expect((await discover()).matches.preset).toEqual({ name: 'fintech', marker: 'content:payment,ledger' });
+    });
+    it('needs a file marker to exist, not to be mentioned', async () => {
+        write('src/serve.ts', "export const page = () => 'index.html';\n");
+        expect((await discover()).matches.preset).toBeUndefined();
+    });
+    it('detects notebooks by file, not by the word ipynb in code', async () => {
+        write('src/scan.ts', "export const exts = ['.ipynb', '.py'];\n");
+        expect((await discover()).matches.preset).toBeUndefined();
+        write('notebooks/explore.ipynb', '{}');
+        expect((await discover()).matches.preset).toEqual({ name: 'data', marker: 'file:*.ipynb' });
+    });
+    it('leaves the paradigm unset for an empty project', async () => {
+        expect((await discover()).matches.paradigm).toBeUndefined();
+    });
+});
+describe('discovery signals', () => {
+    it('matches whole tokens only', () => {
+        expect(containsToken('import x from "react"', 'react')).toBe(true);
+        expect(containsToken('reactivity', 'react')).toBe(false);
+        expect(containsToken('@vue/compiler', 'vue')).toBe(false);
+        expect(containsToken('GET /health', 'health')).toBe(false);
+    });
+    it('drops comments but keeps URLs in strings', () => {
+        const text = stripComments('/* public */\nconst u = "https://x.io"; // public\n# public\n');
+        expect(text).not.toContain('public');
+        expect(text).toContain('https://x.io');
+    });
+    it('declines to guess a paradigm when neither side clearly leads', () => {
+        expect(detectParadigm(['export class A {}\nexport function f() {}\n'])).toBeNull();
+        expect(detectParadigm(['export class A {}\nexport function f() {}\nexport function g() {}\n'])?.name).toBe('functional');
     });
 });

package/dist/gates/context.js

@@ -1,5 +1,6 @@
 import { Gate } from './base.js';
 import { FileScanner } from '../utils/scanner.js';
+import { isScoped, resolveScopedFiles, touchesScope } from '../utils/scope.js';
 import fs from 'fs-extra';
 import path from 'path';
 export class ContextGate extends Gate {
@@ -57,6 +58,12 @@ export class ContextGate extends Gate {
         if (this.extendedConfig.import_relationships) {
             this.analyzeImportPatterns(importPatterns, failures);
         }
+        // Cross-file patterns need the whole repo, but a scoped run reports
+        // only findings that cite a file in scope.
+        if (isScoped(context.patterns)) {
+            const scoped = await resolveScopedFiles(context.cwd, context.patterns, context.ignore);
+            return failures.filter(f => touchesScope(f.files, scoped));
+        }
         return failures;
     }
     checkEnvDrift(content, file, anchors, failures) {