@alex-dbs/coderuler 1.4.0 → 1.6.0

package/dist/adapter/filesystem/rule-test-worker.js

@@ -3,6 +3,7 @@ import { dirname, isAbsolute, resolve, sep, win32 } from 'node:path';
 import { parentPort } from 'node:worker_threads';
 import { executeRules } from '../../app/execute.js';
 import { createDecisionResolver } from '../../infra/settings.js';
+import { createRuleTestLspBackend } from './rule-test-lsp.js';
 import { createProject } from './project.js';
 import { createRuleLoader } from './rules.js';
 function fixturePath(root, filepath) {
@@ -12,35 +13,56 @@ function fixturePath(root, filepath) {
     }
     return target;
 }
-async function runCase({ root, ruleFile, files, ai, dependencies }) {
-    for (const [filepath, source] of Object.entries(files)) {
-        const target = fixturePath(root, filepath);
-        await mkdir(dirname(target), { recursive: true });
-        await writeFile(target, typeof source === 'string' ? source : JSON.stringify(source, null, 2), 'utf8');
+async function runCase(request) {
+    const { lspPort, rubyLspPort, typescriptLspPort, root, ruleFile, files, ai, dependencies, includeDisabled } = request;
+    try {
+        for (const [filepath, source] of Object.entries(files)) {
+            const target = fixturePath(root, filepath);
+            await mkdir(dirname(target), { recursive: true });
+            await writeFile(target, typeof source === 'string' ? source : JSON.stringify(source, null, 2), 'utf8');
+        }
+        const rules = await createRuleLoader(dependencies === undefined ? {} : { preparedDependencies: dependencies }).load({ root, explicit: ruleFile, invocationCwd: root });
+        if (rules.length !== 1)
+            throw new Error('Expected exactly one freshly loaded rule');
+        if (includeDisabled === true)
+            rules[0].rule.enabled = true;
+        const reports = await executeRules(rules, {
+            project: createProject(root, { excludeFiles: [ruleFile] }),
+            isTarget: () => true,
+            concurrency: 1,
+            resolveDecision: ai ? createDecisionResolver(process.env) : () => {
+                throw new Error('Inline rule tests must not call the decision backend');
+            },
+            createLspBackend: (_project, signal) => createRuleTestLspBackend(lspPort, signal),
+            createRubyLspBackend: (_project, signal) => createRuleTestLspBackend(rubyLspPort, signal),
+            createTypescriptLspBackend: (_project, signal) => createRuleTestLspBackend(typescriptLspPort, signal),
+        });
+        const report = reports[0];
+        if (reports.length !== 1 || report === undefined)
+            throw new Error('Expected exactly one rule report');
+        let aiScores;
+        if (ai) {
+            for (const evaluation of report.evaluations) {
+                const score = evaluation.result.probability;
+                if (score !== undefined)
+                    (aiScores ??= []).push(score);
+            }
+        }
+        return { actual: report.status, ...(aiScores === undefined ? {} : { aiScores }) };
     }
-    const rules = await createRuleLoader(dependencies === undefined ? {} : { preparedDependencies: dependencies }).load({ root, explicit: ruleFile, invocationCwd: root });
-    if (rules.length !== 1)
-        throw new Error('Expected exactly one freshly loaded rule');
-    const reports = await executeRules(rules, {
-        project: createProject(root, { excludeFiles: [ruleFile] }),
-        isTarget: () => true,
-        concurrency: 1,
-        resolveDecision: ai ? createDecisionResolver(process.env) : () => {
-            throw new Error('Inline rule tests must not call the decision backend');
-        },
-    });
-    const report = reports[0];
-    if (reports.length !== 1 || report === undefined)
-        throw new Error('Expected exactly one rule report');
-    let aiScores;
-    if (ai) {
-        for (const evaluation of report.evaluations) {
-            const score = evaluation.result.probability;
-            if (score !== undefined)
-                (aiScores ??= []).push(score);
+    finally {
+        try {
+            lspPort.close();
+        }
+        finally {
+            try {
+                rubyLspPort.close();
+            }
+            finally {
+                typescriptLspPort.close();
+            }
         }
     }
-    return { actual: report.status, ...(aiScores === undefined ? {} : { aiScores }) };
 }
 const port = parentPort;
 if (port === null)

package/dist/adapter/filesystem/rule-tests.d.ts

@@ -1,3 +1,3 @@
-import type { LoadedRule } from '../../app/ports.js';
+import type { LoadedRule, LspBackendFactory } from '../../app/ports.js';
 import type { RuleTestResult } from '../../app/rule-tests.js';
-export declare function runRuleTests(rules: readonly LoadedRule[], onResult?: (result: RuleTestResult, lastInRule: boolean) => void, timeoutMs?: number, concurrency?: number, includeAI?: boolean): Promise<readonly RuleTestResult[]>;
+export declare function runRuleTests(rules: readonly LoadedRule[], onResult?: (result: RuleTestResult, lastInRule: boolean) => void, timeoutMs?: number, concurrency?: number, includeAI?: boolean, includeDisabled?: boolean, createLspBackend?: LspBackendFactory, createRubyLspBackend?: LspBackendFactory, createTypescriptLspBackend?: LspBackendFactory): Promise<readonly RuleTestResult[]>;

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

@@ -1,10 +1,12 @@
-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 { MessageChannel, Worker } from 'node:worker_threads';
 import { isRecord, validateJsonValue } from '../../app/validate.js';
-import { getRuleDependencies } from './rule-resolution.js';
+import { createRuleTestLspHost } from './rule-test-lsp.js';
+import { createProject } from './project.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 +26,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;
@@ -32,6 +63,7 @@ class RuleTestWorkerSession {
     onFailure;
     terminating = false;
     termination;
+    activeLsp;
     onError = (error) => {
         if (this.terminating)
             return;
@@ -54,12 +86,41 @@ class RuleTestWorkerSession {
         if (this.failure !== undefined)
             throw this.failure;
     }
-    async run(request, deadline, onFailure) {
+    closeLsp(active = this.activeLsp) {
+        if (active === undefined)
+            return Promise.resolve();
+        if (active.closePromise !== undefined)
+            return active.closePromise;
+        active.closePromise = (async () => {
+            try {
+                const hosts = [active.go.host, active.ruby.host, active.typescript.host].filter((host) => host !== undefined);
+                const results = await Promise.allSettled(hosts.map(async (host) => host.close()));
+                const rejected = results.find(result => result.status === 'rejected');
+                if (rejected?.status === 'rejected')
+                    throw rejected.reason;
+            }
+            finally {
+                active.go.channel.port1.close();
+                active.ruby.channel.port1.close();
+                active.typescript.channel.port1.close();
+                if (!active.transferred) {
+                    active.go.channel.port2.close();
+                    active.ruby.channel.port2.close();
+                    active.typescript.channel.port2.close();
+                }
+                if (this.activeLsp === active)
+                    this.activeLsp = undefined;
+            }
+        })();
+        return active.closePromise;
+    }
+    async run(request, deadline, onFailure, createBackend, createRubyLspBackend, createTypescriptLspBackend) {
         this.onFailure = onFailure;
         this.assertHealthy();
         const id = this.nextId++;
         const result = Promise.withResolvers();
         let timer;
+        let activeLsp;
         const expire = () => {
             const remaining = deadline - performance.now();
             if (remaining <= 0)
@@ -83,29 +144,94 @@ class RuleTestWorkerSession {
             else
                 result.reject(error);
         };
+        let operationFailed = false;
         this.worker.on('message', onMessage);
         try {
             expire();
             if (performance.now() < deadline) {
-                this.worker.postMessage({ ...request, id });
+                const channels = [];
+                try {
+                    const goChannel = new MessageChannel();
+                    channels.push(goChannel);
+                    const rubyChannel = new MessageChannel();
+                    channels.push(rubyChannel);
+                    const typescriptChannel = new MessageChannel();
+                    channels.push(typescriptChannel);
+                    activeLsp = {
+                        go: { channel: goChannel, host: undefined },
+                        ruby: { channel: rubyChannel, host: undefined },
+                        typescript: { channel: typescriptChannel, host: undefined },
+                        transferred: false,
+                    };
+                    this.activeLsp = activeLsp;
+                    const project = createProject(request.root, { excludeFiles: [request.ruleFile] });
+                    activeLsp.go.host = createRuleTestLspHost(goChannel.port1, project, createBackend);
+                    activeLsp.ruby.host = createRuleTestLspHost(rubyChannel.port1, project, createRubyLspBackend);
+                    activeLsp.typescript.host = createRuleTestLspHost(typescriptChannel.port1, project, createTypescriptLspBackend);
+                    this.worker.postMessage({
+                        ...request, id, lspPort: goChannel.port2, rubyLspPort: rubyChannel.port2,
+                        typescriptLspPort: typescriptChannel.port2,
+                    }, [goChannel.port2, rubyChannel.port2, typescriptChannel.port2]);
+                    activeLsp.transferred = true;
+                }
+                catch (error) {
+                    if (activeLsp === undefined) {
+                        for (const channel of channels) {
+                            channel.port1.close();
+                            channel.port2.close();
+                        }
+                    }
+                    throw error;
+                }
             }
             return await result.promise;
         }
+        catch (error) {
+            operationFailed = true;
+            throw error;
+        }
         finally {
             clearTimeout(timer);
             this.worker.off('message', onMessage);
             this.rejectPending = undefined;
+            try {
+                await this.closeLsp(activeLsp);
+            }
+            catch (error) {
+                if (!operationFailed)
+                    throw error;
+                if (activeLsp !== undefined)
+                    activeLsp.closePromise = Promise.resolve();
+            }
         }
     }
     async stop() {
         if (this.termination === undefined) {
             this.terminating = true;
             this.rejectPending?.(new Error('Rule test worker stopped'));
-            this.termination = this.worker.terminate();
+            this.termination = (async () => {
+                let closeFailed = false;
+                let closeError;
+                try {
+                    await this.closeLsp();
+                }
+                catch (error) {
+                    closeFailed = true;
+                    closeError = error;
+                }
+                const code = await this.worker.terminate();
+                if (closeFailed)
+                    throw closeError;
+                return code;
+            })();
+        }
+        try {
+            await this.termination;
+        }
+        finally {
+            this.worker.off('error', this.onError);
+            this.worker.off('exit', this.onExit);
         }
-        await this.termination;
-        this.worker.off('error', this.onError);
-        this.worker.off('exit', this.onExit);
     }
 }
 async function stopSession(session) {
@@ -114,7 +240,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, createLspBackend, createRubyLspBackend, createTypescriptLspBackend) {
     const started = performance.now();
     const deadline = started + timeoutMs;
     let failure;
@@ -141,8 +267,9 @@ async function runCase(entry, example, ai, timeoutMs, session, onFailure) {
                 const dependencies = getRuleDependencies(entry.ruleFile);
                 const outcome = await active.run({
                     root, ruleFile: entry.ruleFile, files: example.files, ai,
+                    ...(includeDisabled ? { includeDisabled: true } : {}),
                     ...(dependencies === undefined ? {} : { dependencies }),
-                }, deadline, failCase);
+                }, deadline, failCase, createLspBackend, createRubyLspBackend, createTypescriptLspBackend);
                 if (typeof outcome === 'string')
                     actual = outcome;
                 else {
@@ -180,7 +307,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, createLspBackend, createRubyLspBackend, createTypescriptLspBackend) {
     if (!Number.isSafeInteger(concurrency) || concurrency < 1) {
         throw new RangeError(`--concurrency must be a positive safe integer, received ${String(concurrency)}`);
     }
@@ -204,24 +331,28 @@ export async function runRuleTests(rules, onResult, timeoutMs = 10_000, concurre
         for (const rule of rules) {
             if (failureObserved)
                 throw failure;
-            if (!rule.rule.enabled)
+            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;
@@ -231,11 +362,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, createLspBackend, createRubyLspBackend, createTypescriptLspBackend);
                         if (failureObserved)
                             return;
                         while (completed[nextResult] !== undefined) {
@@ -269,6 +404,12 @@ export async function runRuleTests(rules, onResult, timeoutMs = 10_000, concurre
     }
     finally {
         await cancellation;
-        await Promise.all(sessions.map(stopSession));
+        try {
+            await Promise.all(sessions.map(stopSession));
+        }
+        catch (error) {
+            if (!failureObserved)
+                throw error;
+        }
     }
 }

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>;