@alex-dbs/coderuler 1.5.0 → 1.6.0

package/dist/adapter/filesystem/rule-test-lsp.d.ts

@@ -0,0 +1,6 @@
+import type { MessagePort } from 'node:worker_threads';
+import type { LspBackend, LspBackendFactory, Project } from '../../app/ports.js';
+export declare function createRuleTestLspHost(port: MessagePort, project: Project, createBackend?: LspBackendFactory): {
+    close(): Promise<void>;
+};
+export declare function createRuleTestLspBackend(port: MessagePort, signal: AbortSignal): LspBackend;

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

@@ -0,0 +1,189 @@
+import { createRunLsp } from '../../app/lsp.js';
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function send(port, response) {
+    try {
+        port.postMessage(response);
+    }
+    catch {
+        // A peer can close its port while an operation is settling.
+    }
+}
+export function createRuleTestLspHost(port, project, createBackend) {
+    const facade = createRunLsp(project, createBackend);
+    let closed = false;
+    let closePromise;
+    const onRequest = (value) => {
+        if (value === null || typeof value !== 'object')
+            return;
+        const candidate = value;
+        if (!Number.isSafeInteger(candidate.id) || !Array.isArray(candidate.args))
+            return;
+        const request = value;
+        void (async () => {
+            try {
+                let result;
+                switch (request.method) {
+                    case 'definitions':
+                        result = await facade.tools.definitions(...request.args);
+                        break;
+                    case 'declarations':
+                        result = await facade.tools.declarations(...request.args);
+                        break;
+                    case 'typeDefinitions':
+                        result = await facade.tools.typeDefinitions(...request.args);
+                        break;
+                    case 'implementations':
+                        result = await facade.tools.implementations(...request.args);
+                        break;
+                    case 'references':
+                        result = await facade.tools.references(...request.args);
+                        break;
+                    case 'hover':
+                        result = await facade.tools.hover(...request.args);
+                        break;
+                    case 'documentSymbols':
+                        result = await facade.tools.documentSymbols(...request.args);
+                        break;
+                    case 'workspaceSymbols':
+                        result = await facade.tools.workspaceSymbols(...request.args);
+                        break;
+                    case 'callers':
+                        result = await facade.tools.callers(...request.args);
+                        break;
+                    case 'callees':
+                        result = await facade.tools.callees(...request.args);
+                        break;
+                    case 'close':
+                        await facade.close();
+                        result = undefined;
+                        break;
+                    default: throw new Error('Unsupported rule-test LSP method');
+                }
+                send(port, { id: request.id, result });
+            }
+            catch (error) {
+                send(port, { id: request.id, error: describe(error) });
+            }
+        })();
+    };
+    const close = () => {
+        if (closePromise !== undefined)
+            return closePromise;
+        closed = true;
+        port.off('message', onRequest);
+        closePromise = (async () => {
+            try {
+                await facade.close();
+            }
+            finally {
+                port.close();
+            }
+        })();
+        return closePromise;
+    };
+    const onPortClose = () => {
+        if (!closed)
+            void close().catch(() => undefined);
+    };
+    port.on('message', onRequest);
+    port.once('close', onPortClose);
+    port.start();
+    return { close };
+}
+export function createRuleTestLspBackend(port, signal) {
+    let nextId = 0;
+    let portClosed = false;
+    let signalAborted = false;
+    let closePromise;
+    const pending = new Map();
+    const rejectPending = (error) => {
+        for (const request of pending.values())
+            request.reject(error);
+        pending.clear();
+    };
+    const onResponse = (value) => {
+        if (value === null || typeof value !== 'object')
+            return;
+        const candidate = value;
+        if (!Number.isSafeInteger(candidate.id))
+            return;
+        const response = value;
+        const request = pending.get(response.id);
+        if (request === undefined)
+            return;
+        pending.delete(response.id);
+        if ('error' in response)
+            request.reject(new Error(response.error));
+        else
+            request.resolve(response.result);
+    };
+    const onPortClose = () => {
+        if (portClosed)
+            return;
+        portClosed = true;
+        rejectPending(new Error('Rule test LSP host closed'));
+    };
+    const onAbort = () => {
+        signalAborted = true;
+        rejectPending(signal.reason instanceof Error ? signal.reason : new Error('Rule test LSP backend aborted'));
+    };
+    port.on('message', onResponse);
+    port.once('close', onPortClose);
+    port.start();
+    signal.addEventListener('abort', onAbort, { once: true });
+    if (signal.aborted)
+        onAbort();
+    const request = (method, args, allowAborted = false) => {
+        if (portClosed)
+            return Promise.reject(new Error('Rule test LSP host closed'));
+        if (signalAborted && !allowAborted) {
+            return Promise.reject(signal.reason instanceof Error ? signal.reason : new Error('Rule test LSP backend aborted'));
+        }
+        const id = nextId++;
+        const deferred = Promise.withResolvers();
+        pending.set(id, {
+            resolve: value => deferred.resolve(value),
+            reject: deferred.reject,
+        });
+        try {
+            port.postMessage({ id, method, args });
+        }
+        catch (error) {
+            pending.delete(id);
+            deferred.reject(error instanceof Error ? error : new Error(describe(error)));
+        }
+        return deferred.promise;
+    };
+    const close = () => {
+        if (closePromise !== undefined)
+            return closePromise;
+        closePromise = (async () => {
+            try {
+                await request('close', [], true);
+            }
+            finally {
+                signal.removeEventListener('abort', onAbort);
+                port.off('message', onResponse);
+                port.off('close', onPortClose);
+                port.close();
+                onPortClose();
+            }
+        })();
+        return closePromise;
+    };
+    return {
+        definitions: (target, options) => request('definitions', [target, options]),
+        declarations: (target, options) => request('declarations', [target, options]),
+        typeDefinitions: (target, options) => request('typeDefinitions', [target, options]),
+        implementations: (target, options) => request('implementations', [target, options]),
+        references: (target, options) => request('references', [target, options]),
+        hover: (target, options) => request('hover', [target, options]),
+        documentSymbols: (filepath, options) => request('documentSymbols', [filepath, options]),
+        workspaceSymbols: (query, options) => request('workspaceSymbols', [query, options]),
+        callers: (target, options) => request('callers', [target, options]),
+        callees: (target, options) => request('callees', [target, options]),
+        close,
+    };
+}

package/dist/adapter/filesystem/rule-test-worker.d.ts

@@ -1,7 +1,11 @@
+import { type MessagePort } from 'node:worker_threads';
 import type { RuleTestCase } from '../../app/rule-tests.js';
 import type { PreparedRuleDependencies } from './dependencies.js';
 export interface RuleTestWorkerRequest {
     readonly id: number;
+    readonly lspPort: MessagePort;
+    readonly rubyLspPort: MessagePort;
+    readonly typescriptLspPort: MessagePort;
     readonly root: string;
     readonly ruleFile: string;
     readonly files: RuleTestCase['files'];

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,37 +13,56 @@ function fixturePath(root, filepath) {
     }
     return target;
 }
-async function runCase({ root, ruleFile, files, ai, dependencies, includeDisabled }) {
-    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');
-    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');
-        },
-    });
-    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, includeDisabled?: 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

@@ -2,8 +2,10 @@ 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 { 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);
@@ -61,6 +63,7 @@ class RuleTestWorkerSession {
     onFailure;
     terminating = false;
     termination;
+    activeLsp;
     onError = (error) => {
         if (this.terminating)
             return;
@@ -83,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)
@@ -112,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) {
@@ -143,7 +240,7 @@ async function stopSession(session) {
     if (session.current === current)
         session.current = undefined;
 }
-async function runCase(entry, example, ai, timeoutMs, session, onFailure, includeDisabled) {
+async function runCase(entry, example, ai, timeoutMs, session, onFailure, includeDisabled, createLspBackend, createRubyLspBackend, createTypescriptLspBackend) {
     const started = performance.now();
     const deadline = started + timeoutMs;
     let failure;
@@ -172,7 +269,7 @@ async function runCase(entry, example, ai, timeoutMs, session, onFailure, includ
                     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 {
@@ -210,7 +307,7 @@ async function runCase(entry, example, ai, timeoutMs, session, onFailure, includ
         throw cause;
     }
 }
-export async function runRuleTests(rules, onResult, timeoutMs = 10_000, concurrency = 1, includeAI = false, includeDisabled = 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)}`);
     }
@@ -273,7 +370,7 @@ export async function runRuleTests(rules, onResult, timeoutMs = 10_000, concurre
                         }
                         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);
+                        completed[index] = await runCase(rule, example, group.ai, timeoutMs, session, fail, includeDisabled, createLspBackend, createRubyLspBackend, createTypescriptLspBackend);
                         if (failureObserved)
                             return;
                         while (completed[nextResult] !== undefined) {
@@ -307,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/lsp/backend.d.ts

@@ -0,0 +1,12 @@
+import type { LspBackend, Project } from '../../app/ports.js';
+export interface LspServerOptions {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly languageId: string;
+    readonly initializationProgressToken?: string | number;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly requestTimeoutMs?: number;
+}
+export declare function createLspBackend(project: Project, signal: AbortSignal, options?: LspServerOptions): Promise<LspBackend>;
+export declare function createRubyLspBackend(project: Project, signal: AbortSignal): Promise<LspBackend>;
+export declare function createTypescriptLspBackend(project: Project, signal: AbortSignal): Promise<LspBackend>;