@rigour-labs/core 6.7.10 → 6.8.1-rc.1

package/dist/types/index.d.ts

@@ -2399,6 +2399,19 @@ export declare const ConfigSchema: z.ZodObject<{
     }, {
         report_path?: string | undefined;
     }>>>;
+    /** The briefing an agent gets before it writes (rigour brief, the prompt hook, rigour_brief). */
+    brief: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        /** The kill switch: false stops every briefing, including an installed hook. The hook itself is installed only with `rigour hooks init --brief`. */
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /** At most this many items, never more than 10. */
+        max_items: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        max_items: number;
+    }, {
+        enabled?: boolean | undefined;
+        max_items?: number | undefined;
+    }>>>;
     /** rigour review / rigour_review / the PR bot / the stop hook. */
     review: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         /** Let heuristic gates decide the verdict too; by default only findings that prove a defect do (quiet.ts). */
@@ -2873,6 +2886,10 @@ export declare const ConfigSchema: z.ZodObject<{
     output: {
         report_path: string;
     };
+    brief: {
+        enabled: boolean;
+        max_items: number;
+    };
     review: {
         include_heuristics: boolean;
         show_preexisting: boolean;
@@ -3165,6 +3182,10 @@ export declare const ConfigSchema: z.ZodObject<{
     output?: {
         report_path?: string | undefined;
     } | undefined;
+    brief?: {
+        enabled?: boolean | undefined;
+        max_items?: number | undefined;
+    } | undefined;
     review?: {
         include_heuristics?: boolean | undefined;
         show_preexisting?: boolean | undefined;

package/dist/types/index.js

@@ -365,6 +365,13 @@ export const ConfigSchema = z.object({
     output: z.object({
         report_path: z.string().default('rigour-report.json'),
     }).optional().default({}),
+    /** The briefing an agent gets before it writes (rigour brief, the prompt hook, rigour_brief). */
+    brief: z.object({
+        /** The kill switch: false stops every briefing, including an installed hook. The hook itself is installed only with `rigour hooks init --brief`. */
+        enabled: z.boolean().optional().default(true),
+        /** At most this many items, never more than 10. */
+        max_items: z.number().int().min(1).max(10).optional().default(10),
+    }).optional().default({}),
     /** rigour review / rigour_review / the PR bot / the stop hook. */
     review: z.object({
         /** Let heuristic gates decide the verdict too; by default only findings that prove a defect do (quiet.ts). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.7.10",
+  "version": "6.8.1-rc.1",
   "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22.13"
@@ -30,7 +30,10 @@
   "type": "module",
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map"
   ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -69,14 +72,14 @@
     "zod": "^3.22.4"
   },
   "optionalDependencies": {
-    "@anthropic-ai/sdk": "^0.30.1",
+    "@anthropic-ai/sdk": "^0.132.1",
     "pg": "^8.16.3",
     "openai": "^5.23.2",
-    "@rigour-labs/brain-darwin-arm64": "6.7.10",
-    "@rigour-labs/brain-darwin-x64": "6.7.10",
-    "@rigour-labs/brain-linux-x64": "6.7.10",
-    "@rigour-labs/brain-win-x64": "6.7.10",
-    "@rigour-labs/brain-linux-arm64": "6.7.10"
+    "@rigour-labs/brain-darwin-arm64": "6.8.1-rc.1",
+    "@rigour-labs/brain-darwin-x64": "6.8.1-rc.1",
+    "@rigour-labs/brain-linux-arm64": "6.8.1-rc.1",
+    "@rigour-labs/brain-linux-x64": "6.8.1-rc.1",
+    "@rigour-labs/brain-win-x64": "6.8.1-rc.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

package/dist/context/automatic-index-cache.test.d.ts

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

package/dist/context/automatic-index-cache.test.js

@@ -1,30 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const writes = vi.hoisted(() => ({ count: 0 }));
-vi.mock('../storage/context-telemetry.js', async (importOriginal) => ({
-    ...(await importOriginal()),
-    setContextCacheRecord: async () => { writes.count++; },
-}));
-const { ensureAutomaticIndex, updateAutomaticIndexForFiles } = await import('./automatic-index.js');
-let cwd;
-beforeEach(() => {
-    writes.count = 0;
-    cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'auto-index-'));
-    fs.mkdirSync(path.join(cwd, 'src'));
-    fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'export function alpha() { return 1; }\n');
-    fs.writeFileSync(path.join(cwd, 'src/b.ts'), 'export function beta() { return 2; }\n');
-});
-afterEach(() => fs.rmSync(cwd, { recursive: true, force: true }));
-describe('automatic indexing', () => {
-    it('writes nothing to the context cache, however many edits it sees', async () => {
-        await ensureAutomaticIndex(cwd, { backgroundSemantic: false });
-        for (let edit = 0; edit < 5; edit++) {
-            fs.writeFileSync(path.join(cwd, 'src/a.ts'), `export function alpha() { return ${edit}; }\n`);
-            await updateAutomaticIndexForFiles(cwd, ['src/a.ts']);
-        }
-        expect(writes.count).toBe(0);
-        expect(fs.existsSync(path.join(cwd, '.rigour', 'patterns.json'))).toBe(true);
-    });
-});

package/dist/context/automatic-index.test.d.ts

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

package/dist/context/automatic-index.test.js

@@ -1,45 +0,0 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { ensureAutomaticIndex, mergeSemanticEmbeddings, updateAutomaticIndexForFiles } from './automatic-index.js';
-describe('automatic incremental index', () => {
-    const cwd = path.join(os.tmpdir(), `rigour-auto-index-${process.pid}`);
-    afterEach(() => fs.remove(cwd));
-    it('builds once and refreshes only changed files and their dependents', async () => {
-        await fs.outputFile(path.join(cwd, 'src/value.ts'), 'export const value = 1;');
-        await fs.outputFile(path.join(cwd, 'src/consumer.ts'), "import { value } from './value';\nexport const doubled = value * 2;");
-        const baseline = await ensureAutomaticIndex(cwd, { backgroundSemantic: false });
-        const untouched = baseline.files.find(file => file.path === 'src/consumer.ts')?.indexedAt;
-        await fs.writeFile(path.join(cwd, 'src/value.ts'), 'export const value = 2;');
-        const result = await updateAutomaticIndexForFiles(cwd, ['src/value.ts']);
-        expect(result.affectedFiles.sort()).toEqual(['src/consumer.ts', 'src/value.ts']);
-        expect(result.index.files.find(file => file.path === 'src/consumer.ts')?.indexedAt).not.toBe(untouched);
-    });
-    it('ignores changed-file paths outside the repository', async () => {
-        await fs.outputFile(path.join(cwd, 'src/value.ts'), 'export const value = 1;');
-        const baseline = await ensureAutomaticIndex(cwd, { backgroundSemantic: false });
-        const result = await updateAutomaticIndexForFiles(cwd, [path.join(cwd, '..', 'outside.ts')]);
-        expect(result.affectedFiles).toEqual([]);
-        expect(result.index.patterns).toEqual(baseline.patterns);
-    });
-    it('merges background embeddings onto the latest structural snapshot', () => {
-        const pattern = (id, file, embedding) => ({
-            id, file, embedding, type: 'function', name: id, line: 1, endLine: 1,
-            signature: '', description: '', keywords: [], hash: id, exported: true,
-            usageCount: 0, indexedAt: '2026-09-10T00:00:00.000Z',
-        });
-        const makeIndex = (patterns) => ({
-            version: '1.0.0', lastUpdated: '2026-09-10T00:00:00.000Z', rootDir: cwd,
-            patterns,
-            files: patterns.map(entry => ({ path: entry.file, hash: entry.hash, patternCount: 1, indexedAt: entry.indexedAt })),
-            stats: { totalPatterns: patterns.length, totalFiles: patterns.length, byType: { function: patterns.length }, indexDurationMs: 1 },
-        });
-        const latest = makeIndex([pattern('changed', 'src/changed.ts'), pattern('new', 'src/new.ts')]);
-        const enriched = makeIndex([pattern('changed', 'src/old.ts', [0.1, 0.2]), pattern('deleted', 'src/deleted.ts', [0.3])]);
-        const merged = mergeSemanticEmbeddings(latest, enriched);
-        expect(merged.patterns.map(entry => entry.id)).toEqual(['changed', 'new']);
-        expect(merged.patterns[0].file).toBe('src/changed.ts');
-        expect(merged.patterns[0].embedding).toEqual([0.1, 0.2]);
-    });
-});

package/dist/context/cache-engine.test.d.ts

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

package/dist/context/cache-engine.test.js

@@ -1,99 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import path from 'path';
-import os from 'os';
-import fs from 'fs-extra';
-vi.mock('./db.js', () => ({
-    isSQLiteAvailable: () => false,
-    openDatabase: async () => null,
-    DB_PATH: '/tmp/rigour-test.db',
-    RIGOUR_DIR: '/tmp/.rigour',
-}));
-import { getSemanticQueryCache, setSemanticQueryCache, findRelatedSemanticQueryCache, queryTokenOverlap, distinctiveTokenAgreement, filterExistingEditScope, getTaskCheckpointCache, setTaskCheckpointCache, hashContent, normalizeQuery } from './cache-engine.js';
-describe('Context cache engine', () => {
-    const testCwd = path.join(os.tmpdir(), `rigour-cache-test-${Date.now()}`);
-    beforeEach(async () => {
-        await fs.ensureDir(testCwd);
-    });
-    it('should calculate consistent SHA-256 hashes', () => {
-        const hash1 = hashContent('const x = 1;');
-        const hash2 = hashContent('const x = 1;');
-        const hash3 = hashContent('const x = 2;');
-        expect(hash1).toBe(hash2);
-        expect(hash1).not.toBe(hash3);
-        expect(hash1.length).toBe(16);
-    });
-    it('should normalize intent queries correctly', () => {
-        expect(normalizeQuery('  Add priority to task!! ')).toBe('add priority to task');
-        expect(normalizeQuery('Task SHOULD Support Priority.')).toBe('task should support priority');
-    });
-    it('Layer 3: should store and retrieve semantic query scope', async () => {
-        const entry = {
-            query: 'task priority persistence',
-            resolvedOwner: 'task-team',
-            editScope: ['services/task.ts'],
-            validationScope: ['npm test'],
-            evidence: ['AST match'],
-            commitSha: 'commit-99',
-            confidence: 0.95
-        };
-        await setSemanticQueryCache('add priority to task', 'commit-99', entry, testCwd);
-        const retrieved = await getSemanticQueryCache('add priority to task', 'commit-99', testCwd);
-        expect(retrieved).not.toBeNull();
-        expect(retrieved?.resolvedOwner).toBe('task-team');
-        expect(retrieved?.editScope).toContain('services/task.ts');
-    });
-    it('Layer 4: should store and retrieve subagent task checkpoint packet', async () => {
-        const packet = {
-            taskId: 'CTP-142',
-            agentId: 'CTP-142-task',
-            phase: 'implementation',
-            component: 'services/task',
-            changedFiles: ['services/task.ts'],
-            decisions: ['Added priority field'],
-            validation: ['npm test passed'],
-            remainingWork: ['Add integration test'],
-            risks: ['Migration needed']
-        };
-        await setTaskCheckpointCache(packet, 126000, testCwd);
-        const retrieved = await getTaskCheckpointCache('CTP-142', 'CTP-142-task', 'implementation', testCwd);
-        expect(retrieved).not.toBeNull();
-        expect(retrieved?.taskId).toBe('CTP-142');
-        expect(retrieved?.decisions).toContain('Added priority field');
-    });
-    it('Layer 3: finds related semantic queries at same commit for partial reuse', async () => {
-        expect(queryTokenOverlap('task priority persistence service', 'task priority persistence service layer')).toBeGreaterThan(0.7);
-        expect(distinctiveTokenAgreement('task service', 'payment service')).toBeLessThan(0.67);
-        await setSemanticQueryCache('task priority persistence service', 'commit-rel', {
-            query: 'task priority persistence service',
-            resolvedOwner: 'task-team',
-            editScope: ['services/task.ts'],
-            validationScope: ['npm test'],
-            evidence: ['related'],
-            commitSha: 'commit-rel',
-            confidence: 0.9,
-        }, testCwd);
-        const related = await findRelatedSemanticQueryCache('task priority persistence service layer', 'commit-rel', testCwd);
-        expect(related).not.toBeNull();
-        expect(related?.entry.editScope).toContain('services/task.ts');
-        // Same generic stem, different distinctive noun → reject
-        await setSemanticQueryCache('payment service billing', 'commit-rel', {
-            query: 'payment service billing',
-            resolvedOwner: 'pay',
-            editScope: ['services/pay.ts'],
-            validationScope: [],
-            evidence: [],
-            commitSha: 'commit-rel',
-            confidence: 0.9,
-        }, testCwd);
-        const crossDomain = await findRelatedSemanticQueryCache('task service billing', 'commit-rel', testCwd);
-        expect(crossDomain).toBeNull();
-        const otherCommit = await findRelatedSemanticQueryCache('task priority persistence service layer', 'commit-other', testCwd);
-        expect(otherCommit).toBeNull();
-    });
-    it('filters missing edit-scope files for quality', async () => {
-        await fs.writeFile(path.join(testCwd, 'alive.ts'), 'export const ok = 1;\n');
-        const result = await filterExistingEditScope(['alive.ts', 'gone.ts'], testCwd);
-        expect(result.valid).toEqual(['alive.ts']);
-        expect(result.missing).toEqual(['gone.ts']);
-    });
-});

package/dist/context/dependency-graph.test.d.ts

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

package/dist/context/dependency-graph.test.js

@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { affectedDependents } from './dependency-graph.js';
-describe('affectedDependents', () => {
-    it('includes direct and transitive consumers', () => {
-        const affected = affectedDependents({
-            version: 1,
-            generatedAt: '2026-09-10T00:00:00Z',
-            nodes: ['a.ts', 'b.ts', 'c.ts'],
-            edges: [{ from: 'b.ts', to: 'a.ts' }, { from: 'c.ts', to: 'b.ts' }],
-        }, ['a.ts']);
-        expect(new Set(affected)).toEqual(new Set(['a.ts', 'b.ts', 'c.ts']));
-    });
-});

package/dist/context/index-status.test.d.ts

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

package/dist/context/index-status.test.js

@@ -1,26 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { getAutomaticIndexStatus, recordIndexChoice } from './automatic-index.js';
-let cwd;
-beforeEach(() => { cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'index-status-')); });
-afterEach(() => fs.rmSync(cwd, { recursive: true, force: true }));
-const index = (embedded) => ({
-    version: '1.0.0', lastUpdated: '', rootDir: cwd, files: [],
-    patterns: [{ id: 'a', type: 'function', name: 'a', file: 'a.ts', line: 1, endLine: 1, signature: '', description: '', keywords: [], hash: 'a', exported: true, usageCount: 0, indexedAt: '', ...(embedded ? { embedding: [0.1] } : {}) }],
-    stats: { totalPatterns: 1, totalFiles: 1, byType: {}, indexDurationMs: 0 },
-});
-describe('semantic index status', () => {
-    it('treats no status yet as warming, not as an opt-out', async () => {
-        expect((await getAutomaticIndexStatus(cwd)).semantic).toBe('warming');
-    });
-    it('records what an explicit index chose, so automatic indexing and Studio agree', async () => {
-        await recordIndexChoice(cwd, index(false), false);
-        expect((await getAutomaticIndexStatus(cwd)).semantic).toBe('disabled');
-        await recordIndexChoice(cwd, index(true), true);
-        expect((await getAutomaticIndexStatus(cwd)).semantic).toBe('ready');
-        await recordIndexChoice(cwd, index(false), true);
-        expect((await getAutomaticIndexStatus(cwd)).semantic).toBe('degraded');
-    });
-});

package/dist/context.test.d.ts

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

package/dist/context.test.js

@@ -1,228 +0,0 @@
-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 os from 'os';
-const TEST_CWD = path.join(os.tmpdir(), 'rigour-temp-test-context-' + process.pid);
-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,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-        const runner = new GateRunner(config);
-        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,
-                    sensitivity: 0.8,
-                    mining_depth: 100,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-        const runner = new GateRunner(config);
-        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);
-    });
-    it('should classify arrow function exports as camelCase, not unknown', async () => {
-        // Create files with arrow function patterns that previously returned 'unknown'
-        await fs.writeFile(path.join(TEST_CWD, 'api.ts'), `
-            export const fetchData = async () => { return []; };
-            export const getUserProfile = async (id: string) => { return {}; };
-            export const use = () => {};
-            export const get = async () => {};
-            const handleClick = (e: Event) => {};
-            let processItem = async (item: any) => {};
-        `);
-        // Create a second file with consistent arrow function naming
-        await fs.writeFile(path.join(TEST_CWD, 'service.ts'), `
-            export const createUser = async (data: any) => {};
-            export const deleteUser = async (id: string) => {};
-            export const updateUser = async (id: string, data: any) => {};
-        `);
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-        const runner = new GateRunner(config);
-        const report = await runner.run(TEST_CWD);
-        // Should NOT have any "unknown" naming convention failures
-        const namingFailures = report.failures.filter(f => f.id === 'context-drift' && f.details?.includes('unknown'));
-        expect(namingFailures.length).toBe(0);
-    });
-    it('should not classify plain variable declarations as function patterns', async () => {
-        // Create file with non-function const declarations
-        await fs.writeFile(path.join(TEST_CWD, 'constants.ts'), `
-            export const API_URL = 'https://api.example.com';
-            export const MAX_RETRIES = 3;
-            const config = { timeout: 5000 };
-            let count = 0;
-        `);
-        // Create file with actual functions for a dominant pattern
-        await fs.writeFile(path.join(TEST_CWD, 'utils.ts'), `
-            function getData() { return []; }
-            function setData(d: any) { return d; }
-            function processRequest(req: any) { return req; }
-        `);
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-        const runner = new GateRunner(config);
-        const report = await runner.run(TEST_CWD);
-        // SCREAMING_SNAKE constants should NOT create naming drift failures
-        // because they should not be in the 'function' pattern bucket at all
-        const namingFailures = report.failures.filter(f => f.id === 'context-drift' && f.details?.includes('SCREAMING_SNAKE'));
-        expect(namingFailures.length).toBe(0);
-    });
-});
-/**
- * Direct unit tests for detectCasing logic
- */
-describe('detectCasing classification', () => {
-    // We test the regex rules directly since detectCasing is private
-    function detectCasing(name) {
-        if (/^[A-Z][a-z]/.test(name) && /[a-z][A-Z]/.test(name))
-            return 'PascalCase';
-        if (/^[a-z]/.test(name) && /[a-z][A-Z]/.test(name))
-            return 'camelCase';
-        if (/^[a-z][a-zA-Z0-9]*$/.test(name))
-            return 'camelCase'; // single-word lowercase
-        if (/^[a-z]+(_[a-z]+)+$/.test(name))
-            return 'snake_case';
-        if (/^[A-Z]+(_[A-Z]+)*$/.test(name))
-            return 'SCREAMING_SNAKE';
-        if (/^[A-Z][a-zA-Z]*$/.test(name))
-            return 'PascalCase';
-        return 'unknown';
-    }
-    // Multi-word camelCase
-    it('classifies multi-word camelCase', () => {
-        expect(detectCasing('fetchData')).toBe('camelCase');
-        expect(detectCasing('getUserProfile')).toBe('camelCase');
-        expect(detectCasing('handleClick')).toBe('camelCase');
-        expect(detectCasing('processItem')).toBe('camelCase');
-        expect(detectCasing('createNewUser')).toBe('camelCase');
-    });
-    // Single-word lowercase (the bug fix)
-    it('classifies single-word lowercase as camelCase', () => {
-        expect(detectCasing('fetch')).toBe('camelCase');
-        expect(detectCasing('use')).toBe('camelCase');
-        expect(detectCasing('get')).toBe('camelCase');
-        expect(detectCasing('set')).toBe('camelCase');
-        expect(detectCasing('run')).toBe('camelCase');
-        expect(detectCasing('a')).toBe('camelCase');
-        expect(detectCasing('x')).toBe('camelCase');
-        expect(detectCasing('id')).toBe('camelCase');
-    });
-    // Single-word lowercase with digits
-    it('classifies lowercase with digits as camelCase', () => {
-        expect(detectCasing('handler2')).toBe('camelCase');
-        expect(detectCasing('config3')).toBe('camelCase');
-        expect(detectCasing('v2')).toBe('camelCase');
-    });
-    // PascalCase
-    it('classifies PascalCase', () => {
-        expect(detectCasing('MyComponent')).toBe('PascalCase');
-        expect(detectCasing('UserService')).toBe('PascalCase');
-        expect(detectCasing('App')).toBe('PascalCase');
-        expect(detectCasing('A')).toBe('SCREAMING_SNAKE'); // single uppercase letter
-    });
-    // snake_case
-    it('classifies snake_case', () => {
-        expect(detectCasing('my_func')).toBe('snake_case');
-        expect(detectCasing('get_data')).toBe('snake_case');
-        expect(detectCasing('process_all_items')).toBe('snake_case');
-    });
-    // SCREAMING_SNAKE
-    it('classifies SCREAMING_SNAKE_CASE', () => {
-        expect(detectCasing('API_URL')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('MAX_RETRIES')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('A')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('DB')).toBe('SCREAMING_SNAKE');
-    });
-    // Edge cases that should NOT be unknown
-    it('does not return unknown for valid identifiers', () => {
-        const validIdentifiers = [
-            'fetch', 'getData', 'MyClass', 'my_func', 'API_KEY',
-            'use', 'run', 'a', 'x', 'id', 'App', 'handler2',
-            'processItem', 'UserProfile', 'get_all_data', 'MAX_SIZE',
-        ];
-        for (const name of validIdentifiers) {
-            expect(detectCasing(name)).not.toBe('unknown');
-        }
-    });
-});

package/dist/deep/agent-review.test.d.ts

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

package/dist/deep/agent-review.test.js

@@ -1,53 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { reviewWithTools } from './agent-review.js';
-import { verifyCodeFindings } from './code-verifier.js';
-let repo;
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-review-'));
-    fs.writeFileSync(path.join(repo, 'limits.ts'), 'export const MAX_ROWS = 0;\n');
-    fs.writeFileSync(path.join(repo, 'page.ts'), Array.from({ length: 60 }, (_, i) => `// line ${i + 1}`).join('\n'));
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-const context = { file: 'page.ts', language: 'typescript', text: '1| export function page() {}', ranges: [[1, 5]], source: 'export function page() {}' };
-function scripted(replies) {
-    const seen = [];
-    const provider = {
-        name: 'fake', isAvailable: async () => true, setup: async () => { }, dispose: () => { }, analyze: async () => '',
-        chat: async (messages, tools, options) => {
-            seen.push({ messages: [...messages], tools: tools.length, toolChoice: options?.toolChoice });
-            return replies.shift() ?? { text: '{"findings": []}', toolCalls: [] };
-        },
-    };
-    return { provider, seen };
-}
-const findingJson = (line, description) => JSON.stringify({ findings: [{ category: 'correctness', severity: 'high', file: 'page.ts', line, description, suggestion: 's', confidence: 0.9 }] });
-describe('reviewWithTools', () => {
-    it('runs the tools the model asks for, then grounds its finding in what it read', async () => {
-        const { provider, seen } = scripted([
-            { text: '', toolCalls: [{ id: 't1', name: 'read_file', arguments: { path: 'limits.ts' } }, { id: 't2', name: 'read_file', arguments: { path: 'page.ts', start_line: 40, end_line: 45 } }] },
-            { text: findingJson(42, '`MAX_ROWS` is 0, so the page loop never runs.'), toolCalls: [] },
-        ]);
-        const result = await reviewWithTools(provider, context, '', repo, {});
-        expect(result.toolCalls).toBe(2);
-        const toolResults = seen[1].messages.filter(m => m.role === 'tool').map(m => m.content);
-        expect(toolResults[0]).toContain('export const MAX_ROWS = 0;');
-        // Line 42 was outside the sent source, but the model read it, and it read MAX_ROWS.
-        expect(verifyCodeFindings(result.findings, [result.context])).toHaveLength(1);
-        expect(verifyCodeFindings(result.findings, [context])).toHaveLength(0);
-    });
-    it('forbids tool calls after the budget, keeping the tools defined for the history, and asks for the answer', async () => {
-        const greedy = Array.from({ length: 20 }, (_, i) => ({ text: '', toolCalls: [{ id: `t${i}`, name: 'grep', arguments: { pattern: 'line' } }] }));
-        const { provider, seen } = scripted(greedy);
-        const result = await reviewWithTools(provider, context, '', repo, {});
-        expect(result.toolCalls).toBeLessThanOrEqual(12);
-        expect(seen.at(-1)).toMatchObject({ tools: 2, toolChoice: 'none' });
-        expect(result.findings).toEqual([]);
-    });
-    it('refuses a provider that cannot call tools', async () => {
-        const provider = { name: 'local', isAvailable: async () => true, setup: async () => { }, dispose: () => { }, analyze: async () => '' };
-        await expect(reviewWithTools(provider, context, '', repo, {})).rejects.toThrow('cannot call tools');
-    });
-});

package/dist/deep/code-context.test.d.ts

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