@alex-dbs/coderuler 0.0.0-stage → 1.3.0

package/dist/adapter/cli/commands/test.js

@@ -0,0 +1,78 @@
+import { CliExit, EXIT_VIOLATION } from '../exit.js';
+import { createProgress } from '../progress.js';
+import { renderRuleTestHeading, renderRuleTestResult, renderRuleTestSummary, } from '../reports.js';
+import { ruleSelection } from './rules.js';
+async function runTest(rulePath, options, context, services) {
+    const progress = context.terminal?.interactive === true
+        ? createProgress(context.writeError, () => context.terminal?.columns ?? 80)
+        : undefined;
+    const color = context.terminal?.color === true;
+    let passed = 0;
+    let failed = 0;
+    let durationMs = 0;
+    let previousRuleName;
+    const failures = options.failuresOnly ? [] : undefined;
+    let testsStarted = false;
+    const flushFailures = () => {
+        if (failures === undefined || failures.length === 0)
+            return;
+        if (previousRuleName !== undefined)
+            context.write('\n');
+        const ruleName = failures[0].ruleName;
+        context.write(renderRuleTestHeading(ruleName, context.redact, color));
+        previousRuleName = ruleName;
+        for (let index = 0; index < failures.length; index += 1) {
+            context.write(renderRuleTestResult(failures[index], context.redact, color, index === failures.length - 1));
+        }
+        failures.length = 0;
+    };
+    try {
+        const choice = rulePath === undefined
+            ? {}
+            : await services.resolveRuleSelector(rulePath, context.cwd, true);
+        const rules = await services.loadRules(ruleSelection(context.cwd, choice, context.cwd));
+        progress?.message('Running tests');
+        testsStarted = true;
+        await services.testRules(rules, (result, lastInRule) => {
+            progress?.clear();
+            if (result.expected === result.actual)
+                passed += 1;
+            else
+                failed += 1;
+            durationMs += result.durationMs;
+            if (failures !== undefined) {
+                if (result.expected !== result.actual)
+                    failures.push(result);
+                if (lastInRule)
+                    flushFailures();
+            }
+            else {
+                if (result.ruleName !== previousRuleName) {
+                    if (previousRuleName !== undefined)
+                        context.write('\n');
+                    context.write(renderRuleTestHeading(result.ruleName, context.redact, color));
+                    previousRuleName = result.ruleName;
+                }
+                context.write(renderRuleTestResult(result, context.redact, color, lastInRule));
+            }
+            progress?.message(`Running tests (${passed + failed} completed)`);
+        }, options.timeout, options.concurrency, options.ai === true);
+    }
+    finally {
+        progress?.stop();
+        if (failures !== undefined && testsStarted) {
+            flushFailures();
+            if (previousRuleName !== undefined)
+                context.write('\n');
+            context.write(renderRuleTestSummary(passed, failed, durationMs, context.redact, color));
+        }
+    }
+    if (failures === undefined) {
+        if (previousRuleName !== undefined)
+            context.write('\n');
+        context.write(renderRuleTestSummary(passed, failed, durationMs, context.redact, color));
+    }
+    if (failed > 0)
+        throw new CliExit(EXIT_VIOLATION);
+}
+export { runTest };

package/dist/adapter/cli/commands/update.d.ts

@@ -0,0 +1,3 @@
+import type { UpdateServices } from '../services.js';
+declare function runUpdate(services: UpdateServices): Promise<void>;
+export { runUpdate };

package/dist/adapter/cli/commands/update.js

@@ -0,0 +1,7 @@
+import { CliExit, EXIT_OK } from '../exit.js';
+async function runUpdate(services) {
+    const status = await services.updateTool();
+    if (status !== EXIT_OK)
+        throw new CliExit(status);
+}
+export { runUpdate };

package/dist/adapter/cli/commands/validate.d.ts

@@ -0,0 +1,3 @@
+import type { CliContext, ValidateServices } from '../services.js';
+declare function runValidate(rulePath: string | undefined, context: CliContext, services: ValidateServices): Promise<void>;
+export { runValidate };

package/dist/adapter/cli/commands/validate.js

@@ -0,0 +1,12 @@
+import { escapeText } from '../text.js';
+import { ruleSelection } from './rules.js';
+async function runValidate(rulePath, context, services) {
+    const choice = rulePath === undefined
+        ? {}
+        : await services.resolveRuleSelector(rulePath, context.cwd, true);
+    const rules = await services.loadRules(ruleSelection(context.cwd, choice, context.cwd));
+    for (const entry of rules) {
+        context.write(context.redact(`Valid rule: ${escapeText(entry.name)}\n`));
+    }
+}
+export { runValidate };

package/dist/adapter/cli/exit.d.ts

@@ -0,0 +1,7 @@
+export declare const EXIT_OK = 0;
+export declare const EXIT_VIOLATION = 1;
+export declare const EXIT_FAILURE = 2;
+export declare class CliExit extends Error {
+    readonly exitCode: number;
+    constructor(exitCode: number);
+}

package/dist/adapter/cli/exit.js

@@ -0,0 +1,10 @@
+export const EXIT_OK = 0;
+export const EXIT_VIOLATION = 1;
+export const EXIT_FAILURE = 2;
+export class CliExit extends Error {
+    exitCode;
+    constructor(exitCode) {
+        super(`coderuler exit ${exitCode}`);
+        this.exitCode = exitCode;
+    }
+}

package/dist/adapter/cli/inspect-json.d.ts

@@ -0,0 +1,9 @@
+import type { InspectRenderer } from './reports.js';
+import type { TextRedactor, TextWriter } from './text.js';
+interface InspectJsonOptions {
+    readonly write: TextWriter;
+    readonly redact: TextRedactor;
+    readonly format: 'json' | 'jsonl';
+}
+export declare function createInspectJsonRenderer(options: InspectJsonOptions): InspectRenderer;
+export {};

package/dist/adapter/cli/inspect-json.js

@@ -0,0 +1,160 @@
+import { createUsageTracker } from './inspect-usage.js';
+function redactRecord(value, redact, sanitize) {
+    const output = Object.create(null);
+    for (const [key, entry] of Object.entries(value)) {
+        const redacted = redact(key);
+        let unique = redacted;
+        let suffix = 2;
+        while (Object.hasOwn(output, unique))
+            unique = `${redacted}#${suffix++}`;
+        output[unique] = sanitize(entry);
+    }
+    return output;
+}
+function redactJson(value, redact) {
+    if (typeof value === 'string')
+        return redact(value);
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map(entry => redactJson(entry, redact));
+    return redactRecord(value, redact, entry => redactJson(entry, redact));
+}
+function redactScope(subject, redact) {
+    return {
+        ...subject,
+        filepath: redact(subject.filepath),
+        id: redact(subject.id),
+        source: redact(subject.source),
+        ...(subject.lines === undefined ? {} : { lines: { ...subject.lines } }),
+        ...(subject.data === undefined ? {} : { data: redactJson(subject.data, redact) }),
+        ...(subject.captures === undefined ? {} : {
+            captures: redactRecord(subject.captures, redact, value => typeof value === 'string' ? redact(value) : value.map(redact)),
+        }),
+    };
+}
+function redactGroup(subject, redact) {
+    return {
+        ...subject,
+        group: { ...subject.group, path: redact(subject.group.path) },
+        members: subject.members.map(member => redactScope(member, redact)),
+    };
+}
+function redactSubject(subject, redact) {
+    return subject.kind === 'scope' ? redactScope(subject, redact) : redactGroup(subject, redact);
+}
+function redactResult(result, redact) {
+    return {
+        ...result,
+        ...(result.message === undefined ? {} : { message: redact(result.message) }),
+        ...(result.model === undefined ? {} : { model: redact(result.model) }),
+        ...(result.usage === undefined ? {} : { usage: { ...result.usage } }),
+    };
+}
+function redactReport(report, redact) {
+    return {
+        ...report,
+        name: redact(report.name),
+        ruleFile: redact(report.ruleFile),
+        ...(report.reason === undefined ? {} : { reason: redact(report.reason) }),
+        evaluations: report.evaluations.map(evaluation => ({
+            subject: redactSubject(evaluation.subject, redact),
+            result: redactResult(evaluation.result, redact),
+        })),
+    };
+}
+function redactEvent(event, redact) {
+    switch (event.type) {
+        case 'progress':
+            return { ...event };
+        case 'rule':
+            return { ...event, name: redact(event.name), ruleFile: redact(event.ruleFile) };
+        case 'gate':
+        case 'file':
+            return {
+                ...event,
+                name: redact(event.name),
+                ...('filepath' in event ? { filepath: redact(event.filepath) } : {}),
+                ...(event.reason === undefined ? {} : { reason: redact(event.reason) }),
+            };
+        case 'scope':
+            return {
+                ...event,
+                name: redact(event.name),
+                subject: redactScope(event.subject, redact),
+                ...(event.reason === undefined ? {} : { reason: redact(event.reason) }),
+            };
+        case 'group':
+            return { ...event, name: redact(event.name), subject: redactGroup(event.subject, redact) };
+        case 'evaluation':
+            return { ...event, name: redact(event.name), subject: redactSubject(event.subject, redact) };
+        case 'usage':
+            return { ...event, name: redact(event.name), subject: redactSubject(event.subject, redact), usage: { ...event.usage } };
+        case 'request':
+        case 'response':
+            return { ...event, name: redact(event.name), subject: redactSubject(event.subject, redact), body: redact(event.body) };
+        case 'result':
+            return {
+                ...event,
+                name: redact(event.name),
+                subject: redactSubject(event.subject, redact),
+                result: redactResult(event.result, redact),
+            };
+        case 'trace':
+            return {
+                ...event,
+                name: redact(event.name),
+                message: redact(event.message),
+                ...(event.details === undefined ? {} : { details: redactJson(event.details, redact) }),
+            };
+        case 'error':
+            return {
+                ...event,
+                ...(event.name === undefined ? {} : { name: redact(event.name) }),
+                stage: redact(event.stage),
+                message: redact(event.message),
+            };
+    }
+}
+export function createInspectJsonRenderer(options) {
+    const events = [];
+    const usage = createUsageTracker();
+    let finished = false;
+    const record = (value) => options.write(`${JSON.stringify(value)}\n`);
+    return {
+        emit: event => {
+            if (finished)
+                return;
+            const snapshot = redactEvent(event, options.redact);
+            usage.emit(event);
+            if (options.format === 'jsonl')
+                record({ type: 'event', event: snapshot });
+            else
+                events.push(snapshot);
+        },
+        finish: (reports, error) => {
+            if (finished)
+                return;
+            finished = true;
+            const summary = usage.summary();
+            if (options.format === 'jsonl') {
+                if (error === undefined) {
+                    for (const report of reports)
+                        record({ type: 'report', report: redactReport(report, options.redact) });
+                }
+                if (summary !== undefined)
+                    record({ type: 'summary', usage: summary });
+                if (error !== undefined)
+                    record({ type: 'error', message: options.redact(error) });
+            }
+            else {
+                options.write(`${JSON.stringify({
+                    events,
+                    reports: error === undefined ? reports.map(report => redactReport(report, options.redact)) : [],
+                    ...(error === undefined ? {} : { error: options.redact(error) }),
+                    ...(summary === undefined ? {} : { usage: summary }),
+                }, null, 2)}\n`);
+            }
+        },
+    };
+}

package/dist/adapter/cli/inspect-usage.d.ts

@@ -0,0 +1,9 @@
+import type { RunEvent } from '../../app/ports.js';
+import type { AiUsage } from '../../app/rule.js';
+export interface InspectionUsage extends AiUsage {
+    readonly verifications: number;
+}
+export declare function createUsageTracker(): {
+    readonly emit: (event: RunEvent) => void;
+    readonly summary: () => InspectionUsage | undefined;
+};

package/dist/adapter/cli/inspect-usage.js

@@ -0,0 +1,14 @@
+import { addUsage } from '../../app/usage.js';
+export function createUsageTracker() {
+    const verifications = new Set();
+    let total;
+    return {
+        emit: event => {
+            if (event.type !== 'usage' || event.usage.calls === 0)
+                return;
+            verifications.add(event.evaluationId);
+            total = addUsage(total, event.usage);
+        },
+        summary: () => total === undefined ? undefined : { ...total, verifications: verifications.size },
+    };
+}

package/dist/adapter/cli/program.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import type { CliServices } from './services.js';
+export declare function createProgram(services: CliServices): Command;
+export declare function runProgram(argv: readonly string[], services: CliServices): Promise<number>;

package/dist/adapter/cli/program.js

@@ -0,0 +1,216 @@
+import { Command, CommanderError, InvalidArgumentError, Option } from 'commander';
+import { CliExit, EXIT_FAILURE, EXIT_OK } from './exit.js';
+import { escapeDiagnostic } from './text.js';
+const SUCCESSFUL_COMMANDER_CODES = {
+    'commander.help': true,
+    'commander.helpDisplayed': true,
+    'commander.version': true,
+};
+const CONCURRENCY_HINT = 'must be a positive safe integer';
+const THRESHOLD_HINT = 'must be a decimal number between 0 and 1';
+const THRESHOLD_PATTERN = /^(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+)$/;
+const TIMEOUT_HINT = 'must be a positive duration in ms, s, or m, at most 2147483647ms';
+const TIMEOUT_UNITS = { ms: 1, s: 1_000, m: 60_000 };
+function parseConcurrency(value) {
+    const parsed = Number(value);
+    if (!/^[0-9]+$/.test(value) || !Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw new InvalidArgumentError(CONCURRENCY_HINT);
+    }
+    return parsed;
+}
+function parseThreshold(value) {
+    const trimmed = value.trim();
+    const parsed = Number(trimmed);
+    if (!THRESHOLD_PATTERN.test(trimmed) || !Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+        throw new InvalidArgumentError(THRESHOLD_HINT);
+    }
+    return parsed;
+}
+function parseTokenPrice(value) {
+    const trimmed = value.trim();
+    const parsed = Number(trimmed);
+    if (!THRESHOLD_PATTERN.test(trimmed) || !Number.isFinite(parsed) || parsed < 0) {
+        throw new InvalidArgumentError('must be a finite nonnegative decimal number (USD per million tokens)');
+    }
+    return parsed;
+}
+function parseTimeout(value) {
+    const match = /^([0-9]+(?:\.[0-9]+)?|\.[0-9]+)(ms|s|m)$/.exec(value.trim());
+    const durationMs = match === null
+        ? NaN
+        : Number(match[1]) * TIMEOUT_UNITS[match[2]];
+    if (!Number.isFinite(durationMs) || durationMs <= 0 || durationMs > 2_147_483_647) {
+        throw new InvalidArgumentError(TIMEOUT_HINT);
+    }
+    return durationMs;
+}
+export function createProgram(services) {
+    const program = new Command();
+    program
+        .name('coderuler')
+        .description('Evaluate trusted TypeScript rules against the current working tree')
+        .configureOutput({
+        writeOut: text => services.write(text),
+        writeErr: text => services.writeError(`coderuler: ${services.redact(escapeDiagnostic(text))}`),
+    })
+        .version(services.version)
+        .exitOverride();
+    program
+        .command('update')
+        .description('Upgrade the active global npm installation of CodeRuler to the latest version')
+        .action(async () => {
+        const { runUpdate } = await import('./commands/update.js');
+        const commandServices = await services.load.update(services);
+        await runUpdate(commandServices);
+    });
+    const skill = program
+        .command('skill')
+        .description('Install or refresh the bundled coderuler-new-rule Agent Skill');
+    skill
+        .command('install')
+        .description('Install the bundled skill; defaults to the shared universal skills directory')
+        .option('-g, --global', 'install globally instead of prompting for scope')
+        .option('-a, --agent <agents...>', 'target agents (use "*" for all agents)')
+        .option('-y, --yes', 'skip prompts (project scope unless --global)')
+        .option('--copy', 'copy files instead of symlinking agent directories')
+        .action(async (options) => {
+        const { runSkill } = await import('./commands/skill.js');
+        const commandServices = await services.load.skill(services);
+        await runSkill('install', options, commandServices);
+    });
+    skill
+        .command('update')
+        .description('Refresh an existing bundled-skill installation; defaults to the universal target')
+        .addOption(new Option('-g, --global', 'refresh a global installation').conflicts('project'))
+        .addOption(new Option('-p, --project', 'refresh a project installation (default)').conflicts('global'))
+        .option('-a, --agent <agents...>', 'target agents (use "*" for all agents)')
+        .option('--copy', 'copy files instead of symlinking agent directories')
+        .addHelpText('after', '\nUpgrade CodeRuler first to obtain newer skill content. Local sources are refreshed with skills add, not skills update.')
+        .action(async (options) => {
+        const { runSkill } = await import('./commands/skill.js');
+        const commandServices = await services.load.skill(services);
+        await runSkill('update', options, commandServices);
+    });
+    const dependencies = program
+        .command('deps')
+        .description('Manage the public npm packages declared by trusted rules');
+    const dependencyOptions = (command) => command
+        .addOption(new Option('--global', 'manage home rules instead of project rules').conflicts('directory'))
+        .addOption(new Option('--directory <path>', 'manage a rule directory relative to the working directory').conflicts('global'));
+    for (const operation of ['add', 'remove']) {
+        dependencyOptions(dependencies.command(operation))
+            .description(operation === 'add' ? 'Add or update packages and save exact locked versions' : 'Remove declared direct packages')
+            .argument(operation === 'add' ? '<packages...>' : '<names...>', 'public npm packages')
+            .action(async (packages, options) => {
+            const { runDeps } = await import('./commands/deps.js');
+            const commandServices = await services.load.deps(services);
+            await runDeps(operation, packages, options, commandServices);
+        });
+    }
+    dependencyOptions(dependencies.command('sync'))
+        .description('Acquire locked packages and refresh SDK and dependency editor links')
+        .action(async (options) => {
+        const { runDeps } = await import('./commands/deps.js');
+        const commandServices = await services.load.deps(services);
+        await runDeps('sync', [], options, commandServices);
+    });
+    program
+        .command('validate')
+        .description('Load and structurally validate the selected rules without running them')
+        .argument('[rule]', 'rule name, module path, or directory')
+        .action(async (rulePath) => {
+        const { runValidate } = await import('./commands/validate.js');
+        const commandServices = await services.load.validate(services);
+        await runValidate(rulePath, services, commandServices);
+    });
+    program
+        .command('test')
+        .description('Run the declared test cases for the selected rules')
+        .argument('[rule]', 'rule name, module path, or directory')
+        .option('--ai', 'include aiTests that use the configured decision backend')
+        .option('--failures-only', 'show only failed test cases')
+        .addOption(new Option('--timeout <duration>', 'per-test timeout (ms, s, or m)')
+        .argParser(parseTimeout)
+        .default(10_000, '10s'))
+        .option('--concurrency <number>', `bounded in-flight test cases (${CONCURRENCY_HINT})`, parseConcurrency, 1)
+        .action(async (rulePath, options) => {
+        const { runTest } = await import('./commands/test.js');
+        const commandServices = await services.load.test(services);
+        await runTest(rulePath, options, services, commandServices);
+    });
+    program
+        .command('check')
+        .description('Evaluate every selected rule against the working tree')
+        .argument('[path]', 'target file or folder that narrows selection', '.')
+        .option('--rules <rule>', 'rule name, module path, or directory')
+        .option('--tags <tags...>', 'run rules matching any listed tag', [])
+        .option('--exclude-tags <tags...>', 'exclude rules matching any listed tag', [])
+        .option('--json', 'print violations as {durationMs, reports} JSON on stdout')
+        .option('--jsonl', 'print violation rule records as JSON Lines')
+        .option('--output-all', 'include passing and skipped rules and every verification in the output')
+        .option('--debug', 'stream framework metadata and force concurrency 1')
+        .option('--verbose', 'stream the redacted walkthrough at the configured concurrency')
+        .option('--diff, --diff-only', 'evaluate changed files and affected groups against a Git base')
+        .option('--pr <number-or-url>', 'check a GitHub PR in a temporary checkout (implies --diff-only)')
+        .option('--auto-comment', 'post GitHub inline violation comments, with a summary fallback (requires --diff or --pr)')
+        .option('--base <ref>', 'Git base for --diff-only (default: HEAD), or base branch for --pr')
+        .option('--concurrency <number>', `bounded in-flight selection and evaluation tasks (${CONCURRENCY_HINT})`, parseConcurrency, 8)
+        .option('--threshold <number>', `decision threshold override (${THRESHOLD_HINT})`, parseThreshold)
+        .action(async (target, options) => {
+        if (options.json === true && options.jsonl === true) {
+            throw new Error('--json and --jsonl are mutually exclusive');
+        }
+        const diffOnly = options.diffOnly === true || options.pr !== undefined;
+        if (options.base !== undefined && !diffOnly) {
+            throw new Error('--base requires --diff-only or --pr');
+        }
+        if (options.autoComment === true && !diffOnly) {
+            throw new Error('--auto-comment requires --diff (or --diff-only) or --pr');
+        }
+        const { runCheck } = await import('./commands/check.js');
+        const commandServices = await services.load.check(services);
+        await runCheck(target, options, services, commandServices);
+    });
+    program
+        .command('inspect')
+        .description('Walk one rule through selection, filtering, grouping and evaluation')
+        .argument('<rule>', 'rule module path or exact rule name')
+        .argument('[folder]', 'folder to inspect', '.')
+        .option('--json', 'print the complete redacted inspection as one JSON document')
+        .option('--jsonl', 'stream redacted inspection events and reports as JSON Lines')
+        .option('--raw', 'print the complete redacted inspection as undecorated text')
+        .option('--input-cost-per-million <number>', 'input token price override (USD per million tokens)', parseTokenPrice)
+        .option('--output-cost-per-million <number>', 'output token price override (USD per million tokens)', parseTokenPrice)
+        .action(async (rule, folder, options) => {
+        const formats = [
+            ...(options.json === true ? ['--json'] : []),
+            ...(options.jsonl === true ? ['--jsonl'] : []),
+            ...(options.raw === true ? ['--raw'] : []),
+        ];
+        if (formats.length > 1) {
+            throw new Error(`${formats.join(', ')} are mutually exclusive`);
+        }
+        const { runInspect } = await import('./commands/inspect.js');
+        const commandServices = await services.load.inspect(services);
+        await runInspect(rule, folder, options, services, commandServices);
+    });
+    return program;
+}
+export async function runProgram(argv, services) {
+    try {
+        await createProgram(services).parseAsync(argv, { from: 'user' });
+        return EXIT_OK;
+    }
+    catch (error) {
+        if (error instanceof CliExit)
+            return error.exitCode;
+        if (error instanceof CommanderError) {
+            return error.exitCode === EXIT_OK && SUCCESSFUL_COMMANDER_CODES[error.code] === true
+                ? EXIT_OK
+                : EXIT_FAILURE;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        services.writeError(`coderuler: ${services.redact(escapeDiagnostic(message))}\n`);
+        return EXIT_FAILURE;
+    }
+}

package/dist/adapter/cli/progress.d.ts

@@ -0,0 +1,22 @@
+import type { RunEvent } from '../../app/ports.js';
+import type { TextWriter } from './text.js';
+export interface TerminalCapabilities {
+    readonly color: boolean;
+    readonly interactive: boolean;
+    readonly columns?: number;
+    readonly stdoutColumns?: number;
+}
+interface TerminalStreams {
+    readonly stdoutIsTTY: boolean;
+    readonly stderrIsTTY: boolean;
+    readonly columns?: number;
+    readonly stdoutColumns?: number;
+}
+export declare function terminalCapabilities(streams: TerminalStreams, env: Readonly<Record<string, string | undefined>>): TerminalCapabilities;
+export declare function createProgress(write: TextWriter, columns?: () => number): {
+    message(text: string): void;
+    clear: () => void;
+    emit(event: RunEvent): void;
+    stop(): void;
+};
+export {};

package/dist/adapter/cli/progress.js

@@ -0,0 +1,79 @@
+const FRAMES = ['-', '\\', '|', '/'];
+const FRAME_INTERVAL = 80;
+const CLEAR_LINE = '\r\u001b[2K';
+export function terminalCapabilities(streams, env) {
+    const forced = env.FORCE_COLOR?.toLowerCase();
+    const color = forced !== undefined
+        ? forced !== '0' && forced !== 'false'
+        : env.NO_COLOR === undefined && env.TERM !== 'dumb' && streams.stdoutIsTTY;
+    return {
+        color,
+        interactive: streams.stdoutIsTTY && streams.stderrIsTTY && env.TERM !== 'dumb',
+        get columns() { return streams.columns ?? 80; },
+        get stdoutColumns() { return streams.stdoutColumns ?? streams.columns ?? 80; },
+    };
+}
+export function createProgress(write, columns = () => 80) {
+    let frame = 0;
+    let active = true;
+    let drawn = false;
+    let progress;
+    let message = 'Loading rules';
+    const clear = () => {
+        if (drawn)
+            write(CLEAR_LINE);
+        drawn = false;
+    };
+    const draw = () => {
+        const width = Math.max(0, Math.floor(columns()) - 1);
+        if (width === 0) {
+            clear();
+            return;
+        }
+        const spinner = FRAMES[frame % FRAMES.length];
+        frame += 1;
+        let text = `${spinner} ${message}`;
+        if (progress !== undefined) {
+            const label = progress.phase === 'selection' ? 'Scanning' : 'Evaluating';
+            const units = progress.phase === 'selection' ? 'rules' : 'subjects';
+            const counts = `${progress.completed}/${progress.total} ${units}`;
+            const barWidth = Math.min(24, width - label.length - counts.length - 7);
+            if (barWidth >= 3) {
+                const filled = progress.total === 0
+                    ? 0
+                    : Math.min(barWidth, Math.floor(barWidth * progress.completed / progress.total));
+                text = `${spinner} ${label} [${'#'.repeat(filled)}${'-'.repeat(barWidth - filled)}] ${counts}`;
+            }
+            else {
+                text = `${spinner} ${counts}`;
+            }
+        }
+        write(`${CLEAR_LINE}${text.slice(0, width)}`);
+        drawn = true;
+    };
+    draw();
+    const timer = setInterval(draw, FRAME_INTERVAL);
+    return {
+        message(text) {
+            if (!active)
+                return;
+            message = text;
+            progress = undefined;
+            draw();
+        },
+        clear,
+        emit(event) {
+            if (!active || event.type !== 'progress')
+                return;
+            progress = event;
+            draw();
+        },
+        stop() {
+            if (!active)
+                return;
+            active = false;
+            clearInterval(timer);
+            clear();
+        },
+    };
+}