@alex-dbs/coderuler 1.3.1 → 1.5.0

package/dist/adapter/filesystem/rule-tests.js

@@ -1,10 +1,10 @@
-import { mkdtemp, realpath, rm } from 'node:fs/promises';
+import { lstat, mkdtemp, realpath, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { Worker } from 'node:worker_threads';
 import { isRecord, validateJsonValue } from '../../app/validate.js';
-import { getRuleDependencies } from './rule-resolution.js';
+import { getRuleDependencies, registerRuleDependencies } from './rule-resolution.js';
 // A JavaScript entry lets inherited tsx hooks resolve the source worker's .js import.
 const WORKER_MODULE = new URL('./rule-test-worker.js', import.meta.url);
 const WORKER_ENTRY = new URL(`data:text/javascript,${encodeURIComponent(`import ${JSON.stringify(WORKER_MODULE.href)};`)}`);
@@ -24,6 +24,35 @@ function validateCase(value, label) {
     }
     return value;
 }
+async function loadExternalTests(ruleFile, testFile) {
+    try {
+        await lstat(testFile);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    try {
+        const dependencies = getRuleDependencies(ruleFile);
+        if (dependencies !== undefined)
+            registerRuleDependencies(testFile, dependencies);
+        // The companion path comes from the selected rule filename.
+        return await import(pathToFileURL(testFile).href);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Rule test module ${testFile} failed to import: ${detail}`, { cause: error });
+    }
+}
+function addTestGroup(groups, values, sourceLabel, exportName, ai) {
+    if (values === undefined)
+        return;
+    if (!Array.isArray(values)) {
+        throw new Error(`${sourceLabel} ${exportName}: expected an array of test cases`);
+    }
+    groups.push({ values, label: `${sourceLabel} ${exportName}`, ai });
+}
 class RuleTestWorkerSession {
     worker = new Worker(WORKER_ENTRY);
     nextId = 0;
@@ -75,7 +104,7 @@ class RuleTestWorkerSession {
             else if ('error' in message)
                 result.reject(new Error(message.error));
             else
-                result.resolve(message.actual);
+                result.resolve(message.outcome);
         };
         this.rejectPending = error => {
             if (performance.now() >= deadline)
@@ -114,7 +143,7 @@ async function stopSession(session) {
     if (session.current === current)
         session.current = undefined;
 }
-async function runCase(entry, example, ai, timeoutMs, session, onFailure) {
+async function runCase(entry, example, ai, timeoutMs, session, onFailure, includeDisabled) {
     const started = performance.now();
     const deadline = started + timeoutMs;
     let failure;
@@ -129,6 +158,7 @@ async function runCase(entry, example, ai, timeoutMs, session, onFailure) {
     try {
         const root = await mkdtemp(join(await realpath(tmpdir()), 'coderuler-test-'));
         let actual;
+        let aiScores;
         let active;
         try {
             if (session.cancelled)
@@ -138,10 +168,17 @@ async function runCase(entry, example, ai, timeoutMs, session, onFailure) {
             else {
                 active = session.current ??= new RuleTestWorkerSession();
                 const dependencies = getRuleDependencies(entry.ruleFile);
-                actual = await active.run({
+                const outcome = await active.run({
                     root, ruleFile: entry.ruleFile, files: example.files, ai,
+                    ...(includeDisabled ? { includeDisabled: true } : {}),
                     ...(dependencies === undefined ? {} : { dependencies }),
                 }, deadline, failCase);
+                if (typeof outcome === 'string')
+                    actual = outcome;
+                else {
+                    actual = outcome.actual;
+                    aiScores = outcome.aiScores;
+                }
             }
         }
         catch (error) {
@@ -164,6 +201,7 @@ async function runCase(entry, example, ai, timeoutMs, session, onFailure) {
             expected: example.expected,
             actual,
             durationMs: performance.now() - started,
+            ...(aiScores === undefined ? {} : { aiScores }),
         };
     }
     catch (error) {
@@ -172,7 +210,7 @@ async function runCase(entry, example, ai, timeoutMs, session, onFailure) {
         throw cause;
     }
 }
-export async function runRuleTests(rules, onResult, timeoutMs = 10_000, concurrency = 1, includeAI = false) {
+export async function runRuleTests(rules, onResult, timeoutMs = 10_000, concurrency = 1, includeAI = false, includeDisabled = false) {
     if (!Number.isSafeInteger(concurrency) || concurrency < 1) {
         throw new RangeError(`--concurrency must be a positive safe integer, received ${String(concurrency)}`);
     }
@@ -196,22 +234,28 @@ export async function runRuleTests(rules, onResult, timeoutMs = 10_000, concurre
         for (const rule of rules) {
             if (failureObserved)
                 throw failure;
+            if (!includeDisabled && !rule.rule.enabled)
+                continue;
             // Discovery selects the rule module path at runtime.
-            const { tests, aiTests } = await import(pathToFileURL(rule.ruleFile).href);
+            const ruleModule = await import(pathToFileURL(rule.ruleFile).href);
+            const testFile = rule.ruleFile.replace(/\.rule\.(ts|mts|js|mjs)$/, '.test.$1');
+            const externalModule = await loadExternalTests(rule.ruleFile, testFile);
+            const { tests, aiTests } = ruleModule;
             if (failureObserved)
                 throw failure;
-            if (!includeAI && aiTests !== undefined)
+            if (!includeAI && (aiTests !== undefined || externalModule?.aiTests !== undefined)) {
                 hasExcludedAITests = true;
-            const selectedAI = includeAI ? aiTests : undefined;
-            const label = `Rule "${rule.name}"`;
-            if (tests !== undefined && !Array.isArray(tests)) {
-                throw new Error(`${label} tests: expected an array of test cases`);
             }
-            if (selectedAI !== undefined && !Array.isArray(selectedAI)) {
-                throw new Error(`${label} aiTests: expected an array of test cases`);
+            const label = `Rule "${rule.name}"`;
+            const externalLabel = `${label} test module ${testFile}`;
+            const groups = [];
+            addTestGroup(groups, tests, label, 'tests', false);
+            addTestGroup(groups, externalModule?.tests, externalLabel, 'tests', false);
+            if (includeAI) {
+                addTestGroup(groups, aiTests, label, 'aiTests', true);
+                addTestGroup(groups, externalModule?.aiTests, externalLabel, 'aiTests', true);
             }
-            const regularCount = tests?.length ?? 0;
-            const count = regularCount + (selectedAI?.length ?? 0);
+            const count = groups.reduce((total, group) => total + group.values.length, 0);
             const completed = new Array(count);
             let nextIndex = 0;
             let nextResult = 0;
@@ -221,11 +265,15 @@ export async function runRuleTests(rules, onResult, timeoutMs = 10_000, concurre
                     if (index >= count)
                         return;
                     try {
-                        const ai = index >= regularCount;
-                        const caseIndex = ai ? index - regularCount : index;
-                        const value = ai ? selectedAI[caseIndex] : tests[caseIndex];
-                        const example = validateCase(value, `${label} ${ai ? 'aiTests' : 'tests'}[${caseIndex}]`);
-                        completed[index] = await runCase(rule, example, ai, timeoutMs, session, fail);
+                        let groupIndex = 0;
+                        let caseIndex = index;
+                        while (caseIndex >= groups[groupIndex].values.length) {
+                            caseIndex -= groups[groupIndex].values.length;
+                            groupIndex += 1;
+                        }
+                        const group = groups[groupIndex];
+                        const example = validateCase(group.values[caseIndex], `${group.label}[${caseIndex}]`);
+                        completed[index] = await runCase(rule, example, group.ai, timeoutMs, session, fail, includeDisabled);
                         if (failureObserved)
                             return;
                         while (completed[nextResult] !== undefined) {

package/dist/adapter/git/changes.d.ts

@@ -1 +1,2 @@
-export declare function changedFiles(root: string, base: string, env?: Readonly<Record<string, string | undefined>>): Promise<ReadonlySet<string>>;
+import type { DiffChanges } from '../../app/ports.js';
+export declare function collectChanges(root: string, base: string, env?: Readonly<Record<string, string | undefined>>): Promise<DiffChanges>;

package/dist/adapter/git/changes.js

@@ -1,23 +1,310 @@
 import { spawn } from 'node:child_process';
+import { createReadStream } from 'node:fs';
+import { lstat } from 'node:fs/promises';
+import { join } from 'node:path';
 import { traversablePath } from '../filesystem/project.js';
-async function git(root, args, consume, env) {
-    await new Promise((resolve, reject) => {
-        const child = spawn('git', [...args], { cwd: root, env, stdio: ['ignore', 'pipe', 'pipe'] });
-        let stderr = '';
-        child.stdout.setEncoding('utf8');
-        child.stderr.setEncoding('utf8');
-        child.stdout.on('data', consume);
-        child.stderr.on('data', (chunk) => { stderr += chunk; });
-        child.on('error', error => reject(new Error(`Cannot run Git: ${error.message}`, { cause: error })));
-        child.on('close', (code, signal) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`Git ${args[0]} failed: ${stderr.trim() || signal || `exit ${code}`}`));
-        });
+const INVALID_DIFF = 'Cannot collect changed lines: invalid Git diff output.';
+const CONFLICTS = 'Cannot collect changed lines: resolve Git conflicts first.';
+async function git(root, args, consume, env, stdin) {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    const child = spawn('git', [...args], {
+        cwd: root,
+        env,
+        stdio: [stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'],
+    });
+    let stderr = '';
+    let parserError;
+    let stdinError;
+    let settled = false;
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+        if (parserError !== undefined)
+            return;
+        try {
+            consume(chunk);
+        }
+        catch (error) {
+            parserError = error;
+        }
+    });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.stdin?.on('error', error => { stdinError = error; });
+    child.on('error', error => {
+        if (settled)
+            return;
+        settled = true;
+        reject(new Error(`Cannot run Git: ${error.message}`, { cause: error }));
     });
+    child.on('close', (code, signal) => {
+        if (settled)
+            return;
+        settled = true;
+        if (parserError !== undefined)
+            reject(parserError);
+        else if (stdinError !== undefined)
+            reject(new Error(`Cannot write to Git stdin: ${stdinError.message}`, { cause: stdinError }));
+        else if (code === 0)
+            resolve();
+        else
+            reject(new Error(`Git ${args[0]} failed: ${stderr.trim() || signal || `exit ${code}`}`));
+    });
+    if (stdin !== undefined)
+        child.stdin.end(stdin);
+    return promise;
+}
+function invalidDiff() {
+    return new Error(INVALID_DIFF);
 }
-export async function changedFiles(root, base, env) {
+class DiffParser {
+    phase = 'metadata';
+    records = [];
+    pendingMode;
+    nulPending = '';
+    patchPending = '';
+    expectedBlocks = 0;
+    currentBlock;
+    selectedBlocks = [];
+    rawIndex = 0;
+    blockIndex = 0;
+    typeDelete = false;
+    consume(chunk) {
+        let rest = chunk;
+        if (this.phase !== 'patch') {
+            const patch = this.consumeRaw(rest);
+            if (patch === undefined)
+                return;
+            rest = patch;
+        }
+        const text = this.patchPending + rest;
+        let lineStart = 0;
+        let newline;
+        while ((newline = text.indexOf('\n', lineStart)) !== -1) {
+            this.consumePatchLine(text.slice(lineStart, newline).replace(/\r$/, ''));
+            lineStart = newline + 1;
+        }
+        this.patchPending = text.slice(lineStart);
+    }
+    finish() {
+        if (this.phase === 'metadata' && this.nulPending !== '' || this.phase === 'path')
+            throw invalidDiff();
+        if (this.phase === 'metadata' && this.records.length === 0 && this.nulPending === '')
+            return [];
+        if (this.phase !== 'patch')
+            throw invalidDiff();
+        if (this.patchPending !== '') {
+            this.consumePatchLine(this.patchPending.replace(/\r$/, ''));
+            this.patchPending = '';
+        }
+        this.finishBlock();
+        if (this.blockIndex !== this.expectedBlocks) {
+            throw invalidDiff();
+        }
+        if (this.rawIndex !== this.records.length || this.typeDelete)
+            throw invalidDiff();
+        return this.selectedBlocks;
+    }
+    get rawRecords() { return this.records; }
+    consumeRaw(chunk) {
+        this.nulPending += chunk;
+        let nul;
+        while ((nul = this.nulPending.indexOf('\0')) !== -1) {
+            const value = this.nulPending.slice(0, nul);
+            this.nulPending = this.nulPending.slice(nul + 1);
+            if (this.phase === 'metadata') {
+                if (value === '') {
+                    this.expectedBlocks = this.records.reduce((count, record) => count + (record.status === 'T' ? 2 : 1), 0);
+                    this.phase = 'patch';
+                    const patch = this.nulPending;
+                    this.nulPending = '';
+                    return patch;
+                }
+                const match = /^:([0-7]{6}) ([0-7]{6}) ([0-9a-f]+) ([0-9a-f]+) ([A-Z])(?:[0-9]+)?$/.exec(value);
+                if (match === null)
+                    throw invalidDiff();
+                this.pendingMode = { oldMode: match[1], newMode: match[2], status: match[5] };
+                this.phase = 'path';
+            }
+            else if (this.phase === 'path') {
+                if (value === '' || this.pendingMode === undefined)
+                    throw invalidDiff();
+                this.records.push({ ...this.pendingMode, path: value });
+                this.pendingMode = undefined;
+                this.phase = 'metadata';
+            }
+            else
+                throw invalidDiff();
+        }
+        return undefined;
+    }
+    consumePatchLine(line) {
+        if (line.startsWith('diff --git ')) {
+            this.finishBlock();
+            if (this.blockIndex >= this.expectedBlocks)
+                throw invalidDiff();
+            this.currentBlock = { ranges: [], binary: false, hunk: undefined };
+            return;
+        }
+        if (this.currentBlock === undefined) {
+            if (line !== '')
+                throw invalidDiff();
+            return;
+        }
+        if (line.startsWith('Binary files ') && line.endsWith(' differ') || line === 'GIT binary patch') {
+            this.currentBlock.binary = true;
+            return;
+        }
+        const hunk = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?:.*)$/.exec(line);
+        if (hunk === null && line.startsWith('@@'))
+            throw invalidDiff();
+        if (hunk !== null) {
+            const newStart = Number(hunk[3]);
+            const newCount = hunk[4] === undefined ? 1 : Number(hunk[4]);
+            this.currentBlock.hunk = {
+                oldExpected: hunk[2] === undefined ? 1 : Number(hunk[2]),
+                newExpected: newCount,
+                oldSeen: 0,
+                newSeen: 0,
+            };
+            if (newCount > 0) {
+                const range = { start: newStart, end: newStart + newCount - 1 };
+                const previous = this.currentBlock.ranges.at(-1);
+                if (previous !== undefined && range.start <= previous.end + 1) {
+                    this.currentBlock.ranges[this.currentBlock.ranges.length - 1] = {
+                        start: previous.start,
+                        end: Math.max(previous.end, range.end),
+                    };
+                }
+                else
+                    this.currentBlock.ranges.push(range);
+            }
+            this.finishHunkIfComplete();
+            return;
+        }
+        if (line.startsWith('\'))
+            return;
+        const active = this.currentBlock.hunk;
+        if (active !== undefined) {
+            const marker = line[0];
+            if (marker === ' ') {
+                active.oldSeen++;
+                active.newSeen++;
+            }
+            else if (marker === '+')
+                active.newSeen++;
+            else if (marker === '-')
+                active.oldSeen++;
+            else
+                throw invalidDiff();
+            if (active.oldSeen > active.oldExpected || active.newSeen > active.newExpected)
+                throw invalidDiff();
+            this.finishHunkIfComplete();
+        }
+    }
+    finishHunk() {
+        const hunk = this.currentBlock?.hunk;
+        if (hunk !== undefined && (hunk.oldSeen !== hunk.oldExpected || hunk.newSeen !== hunk.newExpected)) {
+            throw invalidDiff();
+        }
+        if (this.currentBlock !== undefined)
+            this.currentBlock.hunk = undefined;
+    }
+    finishHunkIfComplete() {
+        const hunk = this.currentBlock?.hunk;
+        if (hunk !== undefined && hunk.oldSeen === hunk.oldExpected && hunk.newSeen === hunk.newExpected) {
+            this.currentBlock.hunk = undefined;
+        }
+    }
+    finishBlock() {
+        if (this.currentBlock === undefined)
+            return;
+        this.finishHunk();
+        const record = this.records[this.rawIndex];
+        if (record === undefined)
+            throw invalidDiff();
+        if (record.status === 'T') {
+            if (this.typeDelete) {
+                this.selectedBlocks.push(this.currentBlock);
+                this.typeDelete = false;
+                this.rawIndex++;
+            }
+            else
+                this.typeDelete = true;
+        }
+        else {
+            this.selectedBlocks.push(this.currentBlock);
+            this.rawIndex++;
+        }
+        this.blockIndex++;
+        this.currentBlock = undefined;
+    }
+}
+async function collectNulPaths(root, args, env) {
+    let pending = '';
+    const paths = [];
+    await git(root, args, chunk => {
+        const records = (pending + chunk).split('\0');
+        pending = records.pop();
+        for (const path of records)
+            if (path !== '')
+                paths.push(path);
+    }, env);
+    if (pending !== '')
+        throw invalidDiff();
+    return paths;
+}
+async function readAttributes(root, paths, env) {
+    const attributed = new Map();
+    if (paths.length === 0)
+        return attributed;
+    let pending = '';
+    const fields = [];
+    await git(root, ['check-attr', '-z', '--stdin', 'filter', 'working-tree-encoding'], chunk => {
+        const records = (pending + chunk).split('\0');
+        pending = records.pop();
+        fields.push(...records);
+    }, env, `${paths.join('\0')}\0`);
+    if (pending !== '' || fields.length % 3 !== 0)
+        throw invalidDiff();
+    for (let index = 0; index < fields.length; index += 3) {
+        const path = fields[index];
+        const attribute = fields[index + 1];
+        const value = fields[index + 2];
+        if (attribute !== 'filter' && attribute !== 'working-tree-encoding')
+            throw invalidDiff();
+        if (value !== 'unspecified' && value !== 'unset')
+            attributed.set(path, true);
+    }
+    return attributed;
+}
+async function untrackedLines(absolute) {
+    const stats = await lstat(absolute);
+    if (!stats.isFile())
+        return undefined;
+    let prefixBytes = 0;
+    let binary = false;
+    let byteCount = 0;
+    let lfCount = 0;
+    let lastByte = -1;
+    for await (const chunk of createReadStream(absolute)) {
+        const bytes = chunk;
+        const inspectCount = Math.min(bytes.length, Math.max(0, 8000 - prefixBytes));
+        if (!binary && bytes.subarray(0, inspectCount).includes(0))
+            binary = true;
+        prefixBytes += inspectCount;
+        byteCount += bytes.length;
+        for (const byte of bytes)
+            if (byte === 0x0a)
+                lfCount++;
+        if (bytes.length > 0)
+            lastByte = bytes[bytes.length - 1];
+    }
+    if (binary)
+        return undefined;
+    const lineCount = byteCount === 0 ? 0 : lfCount + (lastByte === 0x0a ? 0 : 1);
+    return lineCount === 0 ? [] : [{ start: 1, end: lineCount }];
+}
+export async function collectChanges(root, base, env) {
     let tree = '';
     try {
         await git(root, ['rev-parse', '--verify', '--end-of-options', `${base}^{tree}`], chunk => {
@@ -29,26 +316,73 @@ export async function changedFiles(root, base, env) {
             cause: error,
         });
     }
-    const paths = new Set();
-    const collectPaths = async (args) => {
-        let pending = '';
-        await git(root, args, chunk => {
-            const records = (pending + chunk).split('\0');
-            pending = records.pop();
-            for (const path of records)
-                paths.add(path);
-        }, env);
-    };
-    await collectPaths([
-        'diff', '--relative', '--name-only', '-z', '--no-renames', '--no-ext-diff', '--no-textconv',
+    let conflicts = false;
+    await git(root, ['ls-files', '--unmerged', '-z', '--', '.'], () => { conflicts = true; }, env);
+    if (conflicts)
+        throw new Error(CONFLICTS);
+    const inherited = env ?? process.env;
+    const diffEnv = { ...inherited };
+    delete diffEnv.GIT_DIFF_OPTS;
+    const parser = new DiffParser();
+    await git(root, [
+        'diff', '--relative', '--raw', '-z', '--patch', '--unified=0', '--inter-hunk-context=0',
+        '--no-renames', '--no-ext-diff', '--no-textconv', '--no-color', '--submodule=short', '-O/dev/null',
+        '--output-indicator-new=+', '--output-indicator-old=-', '--output-indicator-context= ',
         tree.trim(), '--', '.',
-    ]);
-    await collectPaths(['ls-files', '--others', '--exclude-standard', '-z', '--', '.']);
-    const changed = new Set();
-    for (const path of paths) {
+    ], chunk => parser.consume(chunk), diffEnv);
+    const blocks = parser.finish();
+    const records = parser.rawRecords;
+    const trackedPaths = records.filter(record => record.newMode.startsWith('100')).map(record => record.path);
+    const attributes = await readAttributes(root, trackedPaths, env);
+    const changedFiles = new Set();
+    const lineResults = new Map();
+    let selectedBlock = 0;
+    for (const record of records) {
+        const physical = await traversablePath(root, record.path);
+        const currentBlock = blocks[selectedBlock++];
+        if (physical === undefined)
+            continue;
+        changedFiles.add(physical);
+        const isCurrent = record.newMode !== '000000';
+        if (!isCurrent) {
+            if (!lineResults.has(physical))
+                lineResults.set(physical, []);
+            continue;
+        }
+        if (!record.newMode.startsWith('100')) {
+            lineResults.set(physical, undefined);
+        }
+        else if (currentBlock === undefined || currentBlock.binary) {
+            lineResults.set(physical, undefined);
+        }
+        else if (currentBlock.ranges.length === 0) {
+            lineResults.set(physical, []);
+        }
+        else if (attributes.get(record.path) === true) {
+            lineResults.set(physical, undefined);
+        }
+        else {
+            lineResults.set(physical, currentBlock.ranges);
+        }
+    }
+    const untracked = await collectNulPaths(root, ['ls-files', '--others', '--exclude-standard', '-z', '--', '.'], env);
+    for (const path of untracked) {
         const physical = await traversablePath(root, path);
-        if (physical !== undefined)
-            changed.add(physical);
+        if (physical === undefined)
+            continue;
+        const lines = await untrackedLines(join(root, ...path.split('/')));
+        changedFiles.add(physical);
+        if (lines === undefined) {
+            lineResults.set(physical, undefined);
+        }
+        else {
+            lineResults.set(physical, lines);
+        }
+    }
+    const changedLines = new Map();
+    for (const [path, ranges] of lineResults) {
+        if (ranges !== undefined)
+            changedLines.set(path, ranges);
     }
-    return changed;
+    return { changedFiles, changedLines };
 }

package/dist/adapter/git/rules.d.ts

@@ -0,0 +1,5 @@
+export interface RuleRepositoryCheckout {
+    readonly root: string;
+    cleanup(): Promise<void>;
+}
+export declare function createRuleRepositoryCheckout(env: Readonly<Record<string, string | undefined>>): (selector: string) => Promise<RuleRepositoryCheckout | undefined>;