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

package/dist/task/thread.test.js

@@ -1,133 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { appendTaskEvent, readThread, taskOf, threadsDir, threadText } from './thread.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'thread-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    fs.writeFileSync(path.join(repo, 'a.ts'), 'export const a = 1;\n');
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-});
-afterEach(() => fs.rmSync(repo, { recursive: true, force: true }));
-describe('the engineering task', () => {
-    const commit = (subject) => {
-        fs.appendFileSync(path.join(repo, 'a.ts'), `// ${subject}\n`);
-        git('commit', '-qam', subject);
-    };
-    it('is the ticket the branch names only when its own commits name it too; a version token is never a ticket', () => {
-        for (const branch of ['chore/pin-node-22', 'fix/utf-8-decoding', 'feat/http-2-push', 'release-1.4', 'bump/python-3-12']) {
-            git('checkout', '-q', 'main');
-            git('checkout', '-qb', branch);
-            commit(`${branch.split('/').pop()}: bump it`); // the version token in the subject, as people write it
-            expect(taskOf(repo)?.key).toBe(`branch:${branch}`);
-        }
-        git('checkout', '-q', 'main');
-        git('checkout', '-qb', 'feat/proj-123-resume-emails');
-        expect(taskOf(repo)?.key).toBe('branch:feat/proj-123-resume-emails'); // named by the branch, not yet by a commit
-        commit('proj-123 resume emails');
-        expect(taskOf(repo)?.key).toBe('branch:feat/proj-123-resume-emails'); // lower case is how versions are written, not tickets
-        commit('PROJ-123: resume emails');
-        expect(taskOf(repo)).toMatchObject({ key: 'PROJ-123', branch: 'feat/proj-123-resume-emails' });
-        git('checkout', '-qb', 'fix-the-thing');
-        expect(taskOf(repo)?.key).toBe('branch:fix-the-thing'); // a branch with no ticket in its name
-        git('checkout', '-q', '--detach');
-        expect(taskOf(repo)).toBeUndefined();
-        expect(appendTaskEvent(repo, { kind: 'push', passed: true })).toBeUndefined();
-    });
-    it("takes the ticket from the pull request's title once a review recorded it, when the commits use another scope", () => {
-        git('checkout', '-qb', 'feat/PROJ-7-retry');
-        commit('fix(retry): back off on 429');
-        appendTaskEvent(repo, { kind: 'edit-check', files: ['src/retry.ts'], findings: 0 });
-        expect(taskOf(repo)?.key).toBe('branch:feat/PROJ-7-retry');
-        appendTaskEvent(repo, { kind: 'review', pr: 7, pr_title: 'feat(PROJ-7): retry with backoff', outcome: 'passed', blocking: 0 });
-        expect(taskOf(repo)?.key).toBe('PROJ-7'); // the same commit: the title confirmed it, and the kept task was dropped
-        appendTaskEvent(repo, { kind: 'push', passed: true });
-        expect(readThread(repo, 'PROJ-7')?.events.map(e => [e.kind, e.task])).toEqual([['edit-check', 'branch:feat/PROJ-7-retry'], ['review', 'branch:feat/PROJ-7-retry'], ['push', 'PROJ-7']]);
-    });
-    it('works the task out once per commit and keeps it, so the edit hook does not read the branch history on every edit', () => {
-        git('checkout', '-qb', 'feat/PROJ-9-cache');
-        commit('PROJ-9: start');
-        expect(taskOf(repo)?.key).toBe('PROJ-9');
-        const cache = path.join(repo, '.git', 'rigour', 'task-cache.json');
-        expect(JSON.parse(fs.readFileSync(cache, 'utf8'))['feat/PROJ-9-cache']).toEqual({ head: git('rev-parse', 'HEAD'), key: 'PROJ-9' });
-        fs.writeFileSync(cache, JSON.stringify({ 'feat/PROJ-9-cache': { head: git('rev-parse', 'HEAD'), key: 'KEPT-1' } }));
-        expect(taskOf(repo)?.key).toBe('KEPT-1'); // read from what was kept, not worked out again
-        commit('PROJ-9: more');
-        expect(taskOf(repo)?.key).toBe('PROJ-9'); // a new commit: worked out again
-    });
-    it('keeps one file per exact branch: a/b and a_b never share a thread', () => {
-        git('checkout', '-qb', 'feat/a/b');
-        appendTaskEvent(repo, { kind: 'push', passed: true });
-        git('checkout', '-q', 'main');
-        git('checkout', '-qb', 'feat/a_b');
-        appendTaskEvent(repo, { kind: 'push', passed: false, failed: 2 });
-        expect(readThread(repo, 'feat/a/b')?.events.map(e => [e.branch, e.passed])).toEqual([['feat/a/b', true]]);
-        expect(readThread(repo, 'feat/a_b')?.events.map(e => [e.branch, e.passed])).toEqual([['feat/a_b', false]]);
-        expect(fs.readdirSync(threadsDir(repo))).toHaveLength(2);
-    });
-    it('gathers a ticket across the branches and worktrees that worked on it, from their first event', () => {
-        git('checkout', '-qb', 'feat/PROJ-5-api');
-        appendTaskEvent(repo, { kind: 'edit-check', files: ['src/api.ts'], findings: 1 }); // before the first commit names the ticket
-        commit('PROJ-5: the api');
-        appendTaskEvent(repo, { kind: 'push', passed: true });
-        const other = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'thread-wt-')), 'wt');
-        git('worktree', 'add', '-q', '-b', 'feat/PROJ-5-ui', other, 'main');
-        fs.appendFileSync(path.join(other, 'a.ts'), '// ui\n');
-        execFileSync('git', ['-C', other, 'commit', '-qam', 'PROJ-5 the ui'], { encoding: 'utf8' });
-        appendTaskEvent(other, { kind: 'push', passed: true }); // written from the other worktree, into the same folder
-        const thread = readThread(repo, 'proj-5');
-        expect(thread?.task).toBe('PROJ-5');
-        expect(thread?.events.map(e => [e.kind, e.branch])).toEqual([['edit-check', 'feat/PROJ-5-api'], ['push', 'feat/PROJ-5-api'], ['push', 'feat/PROJ-5-ui']]);
-        expect(readThread(repo, 'feat/PROJ-5-ui')?.events).toHaveLength(1);
-        git('worktree', 'remove', '--force', other);
-    });
-    it('keeps an append-only thread, read by ticket, branch, pull request or the checkout, oldest first, skipping a broken line', () => {
-        git('checkout', '-qb', 'feat/PROJ-7-retry');
-        commit('PROJ-7 retry');
-        appendTaskEvent(repo, { kind: 'edit-check', session: 'sess-aaaa1111', agent: 'claude', files: ['src/job.ts'], findings: 2 });
-        appendTaskEvent(repo, { kind: 'edit-check', session: 'sess-aaaa1111', agent: 'claude', files: ['src/job.ts'], findings: 0 });
-        appendTaskEvent(repo, { kind: 'stop-review', session: 'sess-aaaa1111', agent: 'claude', blocked: true, blocking: 1 });
-        appendTaskEvent(repo, { kind: 'push', passed: false, failed: 1 });
-        appendTaskEvent(repo, { kind: 'push', passed: true, failed: 0 });
-        appendTaskEvent(repo, { kind: 'review', pr: 42, outcome: 'passed', blocking: 0, should_fix: 1, integrity: 'abcdef0123456789abcdef' });
-        const [name] = fs.readdirSync(threadsDir(repo));
-        const file = path.join(threadsDir(repo), name);
-        expect(name).toMatch(/^feat_PROJ-7-retry-[0-9a-f]{8}\.jsonl$/);
-        expect(fs.realpathSync(file)).toBe(fs.realpathSync(path.join(repo, '.git', 'rigour', 'threads', name)));
-        expect(git('status', '--porcelain')).toBe(''); // nothing in the working tree
-        fs.appendFileSync(file, 'not json\n{"kind":"push"}\n');
-        const byTicket = readThread(repo, 'proj-7');
-        expect(byTicket?.task).toBe('PROJ-7');
-        expect(byTicket?.events.map(e => e.kind)).toEqual(['edit-check', 'edit-check', 'stop-review', 'push', 'push', 'review']);
-        expect(readThread(repo, 'feat/PROJ-7-retry')?.events).toHaveLength(6);
-        expect(readThread(repo, '#42')?.task).toBe('PROJ-7');
-        expect(readThread(repo, '42')?.task).toBe('PROJ-7');
-        expect(readThread(repo)?.events).toHaveLength(6);
-        expect(readThread(repo, '#43')).toBeUndefined();
-        expect(readThread(repo, 'OTHER-1')).toBeUndefined();
-        expect(byTicket.events[0]).toMatchObject({ task: 'PROJ-7', branch: 'feat/PROJ-7-retry', head: git('rev-parse', 'HEAD') });
-        const text = threadText(byTicket).join('\n');
-        expect(text).toContain('PROJ-7 · feat/PROJ-7-retry · PR #42');
-        expect(text).toContain('1 agent session(s) (claude)');
-        expect(text).toContain('findings caught while writing: 2, files clean again after a finding: 1');
-        expect(text).toContain('stop reviews: 1, blocked: 1');
-        expect(text).toContain('pushes: 2, blocked: 1');
-        expect(text).toContain('reviews: 1, last: passed with 0 blocking (record abcdef0123456789)');
-        expect(text).toContain('blocked: 1 check(s) failed');
-    });
-    it('never fails the hook it runs in: an unwritable thread folder is skipped', () => {
-        git('checkout', '-qb', 'feat/PROJ-8');
-        fs.writeFileSync(path.join(repo, '.git', 'rigour'), 'a file where the folder should be');
-        expect(appendTaskEvent(repo, { kind: 'push', passed: true })).toBeUndefined();
-        expect(readThread(repo)?.events ?? []).toEqual([]);
-        expect(threadText({ task: 'PROJ-8', events: [] })).toEqual(['PROJ-8: nothing recorded yet']);
-    });
-});

package/dist/telemetry/telemetry.test.d.ts

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

package/dist/telemetry/telemetry.test.js

@@ -1,64 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { countUsage, durationBucket, flushDailyUsage, isTelemetryEnabled, readTelemetryState, setTelemetryEnabled, shouldAskTelemetry, trackUsage } from './telemetry.js';
-let home;
-const env = { RIGOUR_MIXPANEL_TOKEN: 'tok' };
-beforeEach(() => { home = fs.mkdtempSync(path.join(os.tmpdir(), 'telemetry-')); });
-afterEach(() => { fs.rmSync(home, { recursive: true, force: true }); });
-describe('telemetry consent', () => {
-    it('sends nothing until the person says yes, and the environment always wins', () => {
-        expect(isTelemetryEnabled({ env, home })).toBe(false);
-        expect(shouldAskTelemetry(true, { env, home })).toBe(true);
-        setTelemetryEnabled(true, home);
-        expect(isTelemetryEnabled({ env, home })).toBe(true);
-        expect(shouldAskTelemetry(true, { env, home })).toBe(false); // asked once
-        expect(isTelemetryEnabled({ env: { ...env, DO_NOT_TRACK: '1' }, home })).toBe(false);
-        expect(isTelemetryEnabled({ env: { ...env, RIGOUR_TELEMETRY: '0' }, home })).toBe(false);
-        expect(isTelemetryEnabled({ env: { ...env, CI: 'true' }, home })).toBe(false);
-        expect(isTelemetryEnabled({ env: {}, home })).toBe(false); // a build without a token never sends
-    });
-    it('never asks in CI or without a terminal, and keeps one random install id', () => {
-        expect(shouldAskTelemetry(false, { env, home })).toBe(false);
-        expect(shouldAskTelemetry(true, { env: { ...env, GITHUB_ACTIONS: 'true' }, home })).toBe(false);
-        setTelemetryEnabled(true, home);
-        for (const ci of ['JENKINS_URL', 'TF_BUILD', 'TEAMCITY_VERSION']) {
-            expect(isTelemetryEnabled({ env: { ...env, [ci]: 'x' }, home })).toBe(false); // a build agent's stored yes is not a CI opt-in
-            expect(isTelemetryEnabled({ env: { ...env, [ci]: 'x', RIGOUR_TELEMETRY: '1' }, home })).toBe(true);
-        }
-        const first = setTelemetryEnabled(false, home).installId;
-        expect(readTelemetryState(home).installId).toBe(first);
-        expect(first).toMatch(/^[0-9a-f-]{36}$/);
-    });
-});
-describe('telemetry sending', () => {
-    it('sends one event with the install id and no IP, and swallows a failing network', async () => {
-        setTelemetryEnabled(true, home);
-        const fetch = vi.fn().mockResolvedValue({ ok: true });
-        await trackUsage('review_completed', { status: 'PASS', findings_by_gate: { 'semantic-bugs': 1 } }, { env, home, fetch, version: '6.5.0' });
-        const [url, init] = fetch.mock.calls[0];
-        expect(url).toBe('https://api.mixpanel.com/track?ip=0');
-        const [event] = JSON.parse(init.body);
-        expect(event.event).toBe('review_completed');
-        expect(event.properties).toMatchObject({ token: 'tok', distinct_id: readTelemetryState(home).installId, version: '6.5.0', status: 'PASS' });
-        expect(JSON.stringify(event)).not.toContain(home);
-        await expect(trackUsage('x', {}, { env, home, fetch: vi.fn().mockRejectedValue(new Error('offline')) })).resolves.toBeUndefined();
-    });
-    it('counts hot-path activity locally and sends it as one daily event', async () => {
-        setTelemetryEnabled(true, home);
-        const fetch = vi.fn().mockResolvedValue({ ok: true });
-        const day = 24 * 60 * 60 * 1000;
-        countUsage('hook_check', 1, { env, home, now: 0 });
-        countUsage('hook_check', 1, { env, home, now: 1000 });
-        countUsage('mcp:rigour_review', 1, { env, home, now: 2000 });
-        expect(await flushDailyUsage({ env, home, fetch, now: 5000 })).toBe(false); // not a day yet
-        expect(await flushDailyUsage({ env, home, fetch, now: day + 1 })).toBe(true);
-        const [event] = JSON.parse(fetch.mock.calls[0][1].body);
-        expect(event).toMatchObject({ event: 'daily_usage', properties: { hook_check: 2, 'mcp:rigour_review': 1 } });
-        expect(await flushDailyUsage({ env, home, fetch, now: 2 * day + 2 })).toBe(false); // counters reset
-    });
-    it('buckets durations so timing never identifies a run', () => {
-        expect([500, 3000, 20000, 60000, 600000].map(durationBucket)).toEqual(['<1s', '1-5s', '5-30s', '30s-2m', '>2m']);
-    });
-});

package/dist/types/index.test.d.ts

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

package/dist/types/index.test.js

@@ -1,33 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import yaml from 'yaml';
-import { ConfigSchema } from './index.js';
-describe('rigour.yml', () => {
-    it('still loads a file that sets the settings no check ever read, and keeps everything else', () => {
-        const old = yaml.parse(`
-version: 1
-planned: [Layer boundaries]
-hooks: { enabled: true, tools: [claude], fast_gates: [file-size], timeout_ms: 5000, block_on_failure: true, dlp: false, require_review_ack: true }
-gates:
-  max_file_lines: 300
-  forbid_paths: [secret/]
-  ast: { complexity: 7, max_nesting: 3, max_function_lines: 40 }
-  adaptive: { enabled: true, forced_tier: enterprise }
-  input_validation: { enabled: true, min_secret_length: 12 }
-  deep: { enabled: true, provider: claude, api_key: sk-test, model_name: x, threads: 8, temperature: 0.2 }
-  test_quality: { check_snapshot_abuse: false, ignore_patterns: [x], max_mocks_per_test: 3 }
-`);
-        const config = ConfigSchema.parse(old);
-        expect(config.gates.max_file_lines).toBe(300);
-        expect(config.gates.ast.complexity).toBe(7);
-        expect(config.gates.deep.temperature).toBe(0.2);
-        expect(config.gates.test_quality.max_mocks_per_test).toBe(3);
-        expect(config.hooks.require_review_ack).toBe(true);
-        // What nothing read is dropped, so no code can start depending on it by accident.
-        expect(config).not.toHaveProperty('version');
-        expect(config).not.toHaveProperty('planned');
-        expect(config.gates).not.toHaveProperty('adaptive');
-        expect(config.gates).not.toHaveProperty('input_validation');
-        expect(config.gates.deep).not.toHaveProperty('api_key');
-        expect(config.hooks).not.toHaveProperty('block_on_failure');
-    });
-});

package/dist/utils/command-line.test.d.ts

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

package/dist/utils/command-line.test.js

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { splitCommand } from './command-line.js';
-describe('splitCommand', () => {
-    it('splits on spaces and keeps a quoted argument whole, without its quotes', () => {
-        expect(splitCommand('npm run lint')).toEqual({ bin: 'npm', args: ['run', 'lint'] });
-        expect(splitCommand(`vitest run "src/a b.test.ts" --reporter 'dot'`)).toEqual({ bin: 'vitest', args: ['run', 'src/a b.test.ts', '--reporter', 'dot'] });
-    });
-});

package/dist/utils/diff-removed.test.d.ts

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

package/dist/utils/diff-removed.test.js

@@ -1,29 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseDiff, removedByFile } from './diff.js';
-const DIFF = `diff --git a/src/a.ts b/src/a.ts
---- a/src/a.ts
-+++ b/src/a.ts
-@@ -1,5 +1,4 @@
- export function load(id: string) {
--  if (!id) return null;
--  audit(id);
-+  audit(id ?? '');
-   return fetch(id);
- }
-@@ -20,2 +19,1 @@
--const legacy = true;
- export const x = 1;
-`;
-describe('removedByFile', () => {
-    it('groups removed lines into blocks anchored at the new-side line', () => {
-        expect(removedByFile(DIFF)).toEqual({
-            'src/a.ts': [
-                { line: 2, text: ['  if (!id) return null;', '  audit(id);'] },
-                { line: 19, text: ['const legacy = true;'] },
-            ],
-        });
-    });
-    it('leaves added-line parsing unchanged', () => {
-        expect([...parseDiff(DIFF)['src/a.ts']]).toEqual([2]);
-    });
-});

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

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

package/dist/utils/diff.test.js

@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { changedLinesByFile, parseDiff } from './diff.js';
-const lines = (m) => changedLinesByFile(m);
-describe('parseDiff', () => {
-    it('maps added lines to new-side line numbers', () => {
-        const diff = [
-            'diff --git a/src/a.ts b/src/a.ts',
-            '--- a/src/a.ts',
-            '+++ b/src/a.ts',
-            '@@ -1,3 +1,4 @@',
-            ' const a = 1;',
-            '-const b = 2;',
-            '+const b = 3;',
-            '+const c = 4;',
-            ' export { a };',
-        ].join('\n');
-        expect(lines(parseDiff(diff))).toEqual({ 'src/a.ts': [2, 3] });
-    });
-    it('handles several files and hunks', () => {
-        const diff = [
-            '+++ b/a.ts', '@@ -10,2 +10,3 @@', ' x', '+y', ' z',
-            '+++ b/b.ts', '@@ -1 +1 @@', '-old', '+new',
-        ].join('\n');
-        expect(lines(parseDiff(diff))).toEqual({ 'a.ts': [11], 'b.ts': [1] });
-    });
-    it('does not mistake content lines starting with +++ or --- for headers', () => {
-        const diff = ['+++ b/a.ts', '@@ -1,2 +1,3 @@', ' let i = 0;', '+++i;', '---j;', ' done();'].join('\n');
-        expect(lines(parseDiff(diff))).toEqual({ 'a.ts': [2] });
-    });
-    it('does not count "No newline at end of file" as a line', () => {
-        const diff = ['+++ b/a.ts', '@@ -1,1 +1,2 @@', ' a', '\', '+b'].join('\n');
-        expect(lines(parseDiff(diff))).toEqual({ 'a.ts': [2] });
-    });
-    it('ignores deleted files', () => {
-        const diff = ['diff --git a/gone.ts b/gone.ts', '--- a/gone.ts', '+++ /dev/null', '@@ -1,2 +0,0 @@', '-a', '-b'].join('\n');
-        expect(parseDiff(diff)).toEqual({});
-    });
-});

package/dist/utils/glob-paths.test.d.ts

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

package/dist/utils/glob-paths.test.js

@@ -1,40 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { FileScanner } from './scanner.js';
-import { directoriesAsGlobs, withDirectoryForms } from './glob-paths.js';
-let root;
-beforeEach(() => {
-    root = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-paths-'));
-    fs.mkdirSync(path.join(root, 'src'));
-    fs.mkdirSync(path.join(root, 'legacy'));
-    fs.writeFileSync(path.join(root, 'src', 'a.ts'), 'export const a = 1;\n');
-    fs.writeFileSync(path.join(root, 'legacy', 'old.ts'), 'export const b = 2;\n');
-});
-afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
-describe('withDirectoryForms', () => {
-    it('adds the directory form to plain paths and leaves globs alone', () => {
-        expect(withDirectoryForms(['legacy', 'build/', '.git/**', '**/*.min.js'])).toEqual(['legacy', 'legacy/**', 'build/', 'build/**', '.git/**', '**/*.min.js']);
-    });
-});
-describe('directoriesAsGlobs', () => {
-    it('turns a directory into dir/** and leaves files, missing paths and globs alone', () => {
-        expect(directoriesAsGlobs(root, ['src', 'src/a.ts', 'missing', '**/*.ts'])).toEqual(['src/**', 'src/a.ts', 'missing', '**/*.ts']);
-    });
-});
-describe('FileScanner in a git worktree', () => {
-    it('scans when .git is a file and the config ignores .git/**', async () => {
-        fs.writeFileSync(path.join(root, '.git'), 'gitdir: /elsewhere/.git/worktrees/x\n');
-        const files = await FileScanner.findFiles({ cwd: root, patterns: ['**/*.ts'], ignore: ['.git/**'] });
-        expect(files.sort()).toEqual(['legacy/old.ts', 'src/a.ts']);
-    });
-    it('finds a file or a whole directory named by a plain path', async () => {
-        expect(await FileScanner.findFiles({ cwd: root, patterns: ['src/a.ts'] })).toEqual(['src/a.ts']);
-        expect(await FileScanner.findFiles({ cwd: root, patterns: ['legacy'] })).toEqual(['legacy/old.ts']);
-    });
-    it('still ignores a whole directory named by a plain path', async () => {
-        const files = await FileScanner.findFiles({ cwd: root, patterns: ['**/*.ts'], ignore: ['legacy'] });
-        expect(files).toEqual(['src/a.ts']);
-    });
-});

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

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

package/dist/utils/profile.test.js

@@ -1,68 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { applyProfile, hostPath, profileFor, profileMismatch } from './profile.js';
-let root;
-const saved = { ...process.env };
-const repo = (rel, remote) => {
-    const dir = path.join(root, rel);
-    fs.mkdirSync(dir, { recursive: true });
-    execFileSync('git', ['init', '-q'], { cwd: dir });
-    if (remote)
-        execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: dir });
-    return dir;
-};
-beforeEach(() => { root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'profiles-'))); });
-afterEach(() => { process.env = { ...saved }; fs.rmSync(root, { recursive: true, force: true }); });
-describe('profiles', () => {
-    it('matches a repository by path prefix or by origin remote, first match winning', () => {
-        const byPath = repo('work/acme/api');
-        const byRemote = repo('elsewhere/web', 'git@github.com:Acme/web.git');
-        const other = repo('personal/tool', 'https://github.com/me/tool');
-        const profiles = [
-            { name: 'acme-path', match: [path.join(root, 'work/acme')] },
-            { name: 'acme-remote', match: ['github.com/acme/*'] },
-        ];
-        expect(profileFor(path.join(byPath, 'src'), profiles)?.name).toBe('acme-path');
-        expect(profileFor(byRemote, profiles)?.name).toBe('acme-remote');
-        expect(profileFor(other, profiles)).toBeUndefined();
-        expect(profileFor(path.join(root, 'work/acme-evil'), profiles)).toBeUndefined();
-        expect(hostPath('https://GitHub.com/Acme/web.git/')).toBe('github.com/acme/web');
-    });
-    it("applies the profile's home and team, clearing team settings inherited from the shell", () => {
-        const dir = repo('work/acme/api');
-        delete process.env.RIGOUR_HOME; // no home of your own: the profile chooses it
-        process.env.RIGOUR_TEAM_DATABASE_URL = 'postgres://other-org';
-        process.env.RIGOUR_ORGANIZATION_ID = 'other-org';
-        applyProfile(dir, [{ name: 'acme', match: [path.join(root, 'work/acme')], home: path.join(root, 'acme-home'), githubAccount: 'acme-dev' }]);
-        expect(process.env.RIGOUR_HOME).toBe(path.join(root, 'acme-home'));
-        expect(process.env.RIGOUR_PROFILE).toBe('acme');
-        expect(process.env.RIGOUR_GITHUB_ACCOUNT).toBe('acme-dev');
-        expect(process.env.RIGOUR_TEAM_DATABASE_URL).toBeUndefined();
-        expect(process.env.RIGOUR_ORGANIZATION_ID).toBeUndefined();
-        applyProfile(dir, [{ name: 'acme', match: [dir], team: { organization: 'acme', team: 'web', actor: 'dev', repositories: ['github.com/acme/*'], databaseUrlCommand: 'echo url' } }]);
-        expect([process.env.RIGOUR_ORGANIZATION_ID, process.env.RIGOUR_TEAM_REPOSITORIES, process.env.RIGOUR_TEAM_DATABASE_URL_COMMAND]).toEqual(['acme', 'github.com/acme/*', 'echo url']);
-    });
-    it('leaves a RIGOUR_HOME you set yourself alone: no profile replaces it or brings its team', () => {
-        const dir = repo('work/acme/api');
-        delete process.env.RIGOUR_PROFILE;
-        process.env.RIGOUR_HOME = path.join(root, 'isolated');
-        const applied = applyProfile(dir, [{ name: 'acme', match: [path.join(root, 'work/acme')], home: path.join(root, 'acme-home'), team: { organization: 'acme', team: 'web', actor: 'dev' } }]);
-        expect(applied).toBeUndefined();
-        expect(process.env.RIGOUR_HOME).toBe(path.join(root, 'isolated'));
-        expect(process.env.RIGOUR_ORGANIZATION_ID).toBeUndefined();
-    });
-    it('refuses to act for a repository of another profile than the one the process started with', () => {
-        const acme = repo('work/acme/api');
-        const mine = repo('personal/tool');
-        const profiles = [{ name: 'acme', match: [path.join(root, 'work/acme')] }];
-        delete process.env.RIGOUR_PROFILE;
-        expect(profileMismatch(mine, profiles)).toBeNull();
-        expect(profileMismatch(acme, profiles)).toContain('belongs to the Rigour profile "acme"');
-        process.env.RIGOUR_PROFILE = 'acme';
-        expect(profileMismatch(acme, profiles)).toBeNull();
-        expect(profileMismatch(mine, profiles)).toContain('started as "acme"');
-    });
-});

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

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

package/dist/utils/scanner.test.js

@@ -1,48 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { FileScanner } from './scanner.js';
-import { globby } from 'globby';
-vi.mock('globby', async (importOriginal) => ({
-    isDynamicPattern: (await importOriginal()).isDynamicPattern,
-    globby: vi.fn(async () => []),
-}));
-describe('FileScanner', () => {
-    it('returns files in a fixed order, whatever order the walk found them in', async () => {
-        vi.mocked(globby).mockResolvedValueOnce(['src/z.ts', 'scripts/a.ts', 'src/a.ts']);
-        expect(await FileScanner.findFiles({ cwd: '/test' })).toEqual(['scripts/a.ts', 'src/a.ts', 'src/z.ts']);
-    });
-    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.at(-1);
-        const ignore = call[1].ignore;
-        expect(ignore).toContain('**/node_modules/**');
-        expect(ignore).toContain('custom-ignore');
-    });
-    it('should normalize Windows paths to forward slashes', async () => {
-        const platform = Object.getOwnPropertyDescriptor(process, 'platform');
-        Object.defineProperty(process, 'platform', { value: 'win32' });
-        try {
-            await FileScanner.findFiles({ cwd: 'C:\\test\\path', patterns: ['**\\*.ts', 'app\\\\[key\\]\\route.ts'] });
-        }
-        finally {
-            Object.defineProperty(process, 'platform', platform);
-        }
-        const call = vi.mocked(globby).mock.calls.at(-1);
-        expect(call[0]).toEqual(['**/*.ts', 'app/\\[key\\]/route.ts']);
-        expect(call[1]?.cwd).toBe('C:/test/path');
-    });
-    it('should keep glob escapes on POSIX', async () => {
-        const platform = Object.getOwnPropertyDescriptor(process, 'platform');
-        Object.defineProperty(process, 'platform', { value: 'linux' });
-        try {
-            await FileScanner.findFiles({ cwd: '/repo', patterns: ['src/app/\\[key\\]/route.ts'] });
-        }
-        finally {
-            Object.defineProperty(process, 'platform', platform);
-        }
-        expect(vi.mocked(globby).mock.calls.at(-1)[0]).toEqual(['src/app/\\[key\\]/route.ts']);
-    });
-});

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

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

package/dist/utils/scope.test.js

@@ -1,38 +0,0 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { isScoped, normalizeScopePatterns, resolveScopedFiles, touchesScope } from './scope.js';
-describe('scope', () => {
-    let cwd;
-    beforeEach(async () => {
-        cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-scope-'));
-        await fs.outputFile(path.join(cwd, 'src/app/[key]/route.ts'), 'export {}');
-        await fs.outputFile(path.join(cwd, 'src/app/k/route.ts'), 'export {}');
-        await fs.outputFile(path.join(cwd, 'src/lib/a.ts'), 'export {}');
-    });
-    afterEach(async () => { await fs.remove(cwd); });
-    it('turns absolute, relative and directory inputs into cwd-relative patterns', async () => {
-        const patterns = await normalizeScopePatterns(cwd, [path.join(cwd, 'src/lib/a.ts'), './src/lib', 'src/lib/a.ts']);
-        expect(patterns).toEqual(['src/lib/a.ts', 'src/lib/**/*', 'src/lib/a.ts']);
-    });
-    it('escapes glob characters so a Next.js [key] route matches only itself', async () => {
-        const patterns = await normalizeScopePatterns(cwd, ['src/app/[key]/route.ts']);
-        expect([...await resolveScopedFiles(cwd, patterns)]).toEqual(['src/app/[key]/route.ts']);
-    });
-    it('keeps a non-existent input as the glob the user wrote', async () => {
-        expect(await normalizeScopePatterns(cwd, ['src/**/*.ts'])).toEqual(['src/**/*.ts']);
-    });
-    it('treats the repo root as everything', async () => {
-        expect(await normalizeScopePatterns(cwd, ['.'])).toEqual(['**/*']);
-    });
-    it('detects scoped runs and scope membership', () => {
-        expect(isScoped(undefined)).toBe(false);
-        expect(isScoped([])).toBe(false);
-        expect(isScoped(['a.ts'])).toBe(true);
-        const scoped = new Set(['src/lib/a.ts']);
-        expect(touchesScope(['./src/lib/a.ts', 'b.ts'], scoped)).toBe(true);
-        expect(touchesScope(['b.ts'], scoped)).toBe(false);
-        expect(touchesScope(undefined, scoped)).toBe(false);
-    });
-});