@alex-dbs/coderuler 0.0.0-stage → 1.3.0

package/dist/app/validate.js

@@ -0,0 +1,415 @@
+import { RULE_BRAND } from './rule.js';
+function invalid(label, detail) {
+    throw new Error(`${label}: ${detail}`);
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isLineNumber(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 1;
+}
+function isStringList(value, allowEmpty) {
+    if (!Array.isArray(value))
+        return false;
+    if (!allowEmpty && value.length === 0)
+        return false;
+    for (let index = 0; index < value.length; index += 1) {
+        if (!Object.hasOwn(value, index))
+            return false;
+        const entry = value[index];
+        if (typeof entry !== 'string' || entry.length === 0)
+            return false;
+    }
+    return true;
+}
+function validateSettings(settings, at) {
+    const backend = settings['backend'];
+    if (backend !== undefined && backend !== 'jev')
+        invalid(at, 'settings.backend must be "jev"');
+    const model = settings['model'];
+    if (model !== undefined && (typeof model !== 'string' || model.trim() === '')) {
+        invalid(at, 'settings.model must be a non-blank string');
+    }
+    const threshold = settings['threshold'];
+    if (threshold !== undefined &&
+        (typeof threshold !== 'number' || !Number.isFinite(threshold) || threshold < 0 || threshold > 1)) {
+        invalid(at, 'settings.threshold must be a finite number between 0 and 1');
+    }
+    for (const key of ['inputCostPerMillion', 'outputCostPerMillion']) {
+        const value = settings[key];
+        if (value !== undefined && (typeof value !== 'number' || !Number.isFinite(value) || value < 0)) {
+            invalid(at, `settings.${key} must be a finite nonnegative number`);
+        }
+    }
+}
+function isGrouping(value) {
+    if (value === 'scope' || value === 'file' || value === 'folder' || value === 'project')
+        return true;
+    if (!isRecord(value) || value['by'] !== 'folder')
+        return false;
+    const level = value['level'];
+    return typeof level === 'number' && Number.isInteger(level) && level <= 0;
+}
+export function isRuleBranded(value) {
+    const target = typeof value === 'function' ? value.prototype : value;
+    if (target === null || (typeof target !== 'object' && typeof target !== 'function'))
+        return false;
+    return Reflect.get(target, RULE_BRAND) === true;
+}
+export function validateRule(value, ruleFile) {
+    const at = `Invalid rule at ${ruleFile}`;
+    if (!isRecord(value))
+        invalid(at, 'expected a rule object');
+    if (typeof value['enabled'] !== 'boolean')
+        invalid(at, 'enabled must be a boolean');
+    if (!isStringList(value['files'], false)) {
+        invalid(at, 'files must be a non-empty array of non-empty glob strings');
+    }
+    if (!isStringList(value['exclude'], true)) {
+        invalid(at, 'exclude must be an array of non-empty glob strings');
+    }
+    const tags = value['tags'];
+    if (tags !== undefined && !isStringList(tags, true)) {
+        invalid(at, 'tags must be an array of non-empty strings');
+    }
+    const scope = value['scope'];
+    if (scope !== undefined && typeof scope !== 'function')
+        invalid(at, 'scope must be a function');
+    const settings = value['settings'];
+    if (!isRecord(settings))
+        invalid(at, 'settings must be an object');
+    validateSettings(settings, at);
+    const comment = value['comment'];
+    if (comment !== undefined && (typeof comment !== 'string' || comment.trim() === '')) {
+        invalid(at, 'comment must be a non-blank string');
+    }
+    if (!isGrouping(value['group'])) {
+        invalid(at, 'group must be "scope", "file", "folder", "project", or { by: "folder", level: integer <= 0 }');
+    }
+    for (const hook of ['when', 'filter', 'select', 'check']) {
+        if (typeof value[hook] !== 'function')
+            invalid(at, `${hook} must be a function`);
+    }
+    return value;
+}
+export function validateJsonValue(value, label) {
+    assertJsonCompatible(value, label, new Set());
+    return value;
+}
+function assertJsonCompatible(value, label, ancestors) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string')
+        return;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            invalid(label, 'numbers must be finite');
+        return;
+    }
+    if (typeof value !== 'object') {
+        invalid(label, `expected JSON-compatible data, received ${typeof value}`);
+    }
+    const container = value;
+    if (ancestors.has(container))
+        invalid(label, 'cyclic data is not supported');
+    ancestors.add(container);
+    if ('toJSON' in value && typeof value.toJSON === 'function') {
+        invalid(label, 'expected plain JSON data without a toJSON serialization hook');
+    }
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            if (!Object.hasOwn(value, index))
+                invalid(label, `arrays must not be sparse (missing index ${index})`);
+            assertJsonCompatible(value[index], `${label}[${index}]`, ancestors);
+        }
+    }
+    else if (!isRecord(value)) {
+        invalid(label, 'expected a plain JSON object or array');
+    }
+    else {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== null && prototype !== Object.prototype) {
+            invalid(label, 'expected a plain JSON object or array');
+        }
+        for (const key of Object.keys(value))
+            assertJsonCompatible(value[key], `${label}.${key}`, ancestors);
+    }
+    ancestors.delete(container);
+}
+function plainCaptures(value, label) {
+    if (!isRecord(value))
+        invalid(label, 'captures must be an object of strings or string arrays');
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== null && prototype !== Object.prototype) {
+        invalid(label, 'captures must be a plain object of strings or string arrays');
+    }
+    const captures = {};
+    for (const key of Object.keys(value)) {
+        const capture = value[key];
+        const entry = typeof capture === 'string'
+            ? capture
+            : Array.isArray(capture) && isDenseStringArray(capture)
+                ? [...capture]
+                : undefined;
+        if (entry === undefined)
+            invalid(label, `capture "${key}" must be a string or an array of strings`);
+        Object.defineProperty(captures, key, { value: entry, enumerable: true, writable: true, configurable: true });
+    }
+    return captures;
+}
+function isDenseStringArray(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        if (!Object.hasOwn(value, index) || typeof value[index] !== 'string')
+            return false;
+    }
+    return true;
+}
+function plainLines(value, label) {
+    if (!isRecord(value))
+        invalid(label, 'lines must be an object with start and end');
+    const { start, end } = value;
+    if (!isLineNumber(start) || !isLineNumber(end) || start > end) {
+        invalid(label, 'lines must be an increasing 1-based inclusive range');
+    }
+    return { start, end };
+}
+export function validateScopeMatch(value, label) {
+    if (!isRecord(value))
+        invalid(label, 'expected a scope match object');
+    const id = value['id'];
+    if (typeof id !== 'string' || id === '')
+        invalid(label, 'scope id must be a non-empty string');
+    const source = value['source'];
+    if (typeof source !== 'string')
+        invalid(label, 'scope source must be a string');
+    const rawData = value['data'];
+    const data = rawData === undefined ? undefined : validateJsonValue(rawData, `${label}.data`);
+    const rawCaptures = value['captures'];
+    const captures = rawCaptures === undefined ? undefined : plainCaptures(rawCaptures, `${label}.captures`);
+    const rawLines = value['lines'];
+    const lines = rawLines === undefined ? undefined : plainLines(rawLines, `${label}.lines`);
+    return {
+        id,
+        source,
+        ...(data === undefined ? {} : { data }),
+        ...(captures === undefined ? {} : { captures }),
+        ...(lines === undefined ? {} : { lines }),
+    };
+}
+export function validateScopeSubject(value, label) {
+    if (!isRecord(value))
+        invalid(label, 'expected a scope subject object');
+    if (value['kind'] !== 'scope')
+        invalid(label, 'kind must be "scope"');
+    const filepath = value['filepath'];
+    if (typeof filepath !== 'string' || filepath === '') {
+        invalid(label, 'filepath must be a non-empty working-root-relative string');
+    }
+    return { kind: 'scope', filepath, ...validateScopeMatch(value, label) };
+}
+export function validateScopeSubjects(value, label) {
+    if (!Array.isArray(value))
+        invalid(label, 'selection must be an array of scope subjects');
+    const subjects = value.map((entry, index) => validateScopeSubject(entry, `${label}[${index}]`));
+    const seen = new Set();
+    for (const subject of subjects) {
+        const key = `${subject.filepath}\u0000${subject.id}`;
+        if (seen.has(key))
+            invalid(label, `duplicate scope id "${subject.id}" for ${subject.filepath}`);
+        seen.add(key);
+    }
+    return subjects;
+}
+export function validatePredicateResult(value, label) {
+    if (typeof value === 'boolean')
+        return value;
+    if (isRecord(value) && typeof value['applies'] === 'boolean') {
+        const reason = value['reason'];
+        if (reason !== undefined && typeof reason !== 'string')
+            invalid(label, 'predicate reason must be a string');
+        return value;
+    }
+    invalid(label, 'predicate must return a boolean or { applies, reason? }');
+}
+export function validateAiUsage(value, label) {
+    if (!isRecord(value))
+        invalid(label, 'usage must be an object');
+    for (const key of ['calls', 'unreportedCalls', 'inputTokens', 'outputTokens']) {
+        const count = value[key];
+        if (typeof count !== 'number' || !Number.isSafeInteger(count) || count < 0) {
+            invalid(label, `usage.${key} must be a nonnegative safe integer`);
+        }
+    }
+    if (value['unreportedCalls'] > value['calls']) {
+        invalid(label, 'usage.unreportedCalls must not exceed usage.calls');
+    }
+    for (const key of ['inputCost', 'outputCost']) {
+        const cost = value[key];
+        if (typeof cost !== 'number' || !Number.isFinite(cost) || cost < 0) {
+            invalid(label, `usage.${key} must be a finite nonnegative number`);
+        }
+    }
+    return value;
+}
+function indexLocationMembers(subject) {
+    const byFilepath = new Map();
+    const members = subject.kind === 'group' ? subject.members : [subject];
+    for (const member of members) {
+        const { filepath, id } = member;
+        let file = byFilepath.get(filepath);
+        if (file === undefined) {
+            file = { all: [], byId: new Map() };
+            byFilepath.set(filepath, file);
+        }
+        file.all.push(member);
+        const matches = file.byId.get(id);
+        if (matches === undefined)
+            file.byId.set(id, [member]);
+        else
+            matches.push(member);
+    }
+    return byFilepath;
+}
+function indexLocationRanges(members) {
+    const ranges = [];
+    for (const member of members) {
+        const lines = member.lines;
+        if (lines === undefined)
+            return { unbounded: true, ranges };
+        ranges.push({ start: lines.start, maxEnd: lines.end });
+    }
+    ranges.sort((left, right) => left.start - right.start);
+    let maxEnd = 0;
+    for (const range of ranges) {
+        maxEnd = Math.max(maxEnd, range.maxEnd);
+        range.maxEnd = maxEnd;
+    }
+    return { unbounded: false, ranges };
+}
+function containsLocationRange(file, lines) {
+    const { unbounded, ranges } = file.rangeIndex ??= indexLocationRanges(file.all);
+    if (unbounded)
+        return true;
+    let low = 0;
+    let high = ranges.length;
+    while (low < high) {
+        const middle = low + Math.floor((high - low) / 2);
+        if (ranges[middle].start <= lines.start)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low > 0 && ranges[low - 1].maxEnd >= lines.end;
+}
+function plainViolationLocations(value, label, subject) {
+    if (!Array.isArray(value))
+        invalid(label, 'check locations must be an array');
+    const locations = [];
+    let membersByFilepath;
+    for (let index = 0; index < value.length; index += 1) {
+        const at = `${label} locations[${index}]`;
+        if (!Object.hasOwn(value, index))
+            invalid(at, 'missing location entry');
+        const location = value[index];
+        if (!isRecord(location))
+            invalid(at, 'location must be an object');
+        const { filepath, scopeId, lines: rawLines } = location;
+        if (typeof filepath !== 'string' || filepath === '') {
+            invalid(at, 'location filepath must be a non-empty string');
+        }
+        if (scopeId !== undefined && (typeof scopeId !== 'string' || scopeId === '')) {
+            invalid(at, 'location scopeId must be a non-empty string');
+        }
+        let lines = rawLines === undefined ? undefined : plainLines(rawLines, at);
+        if (scopeId === undefined && lines === undefined) {
+            invalid(at, 'location must specify scopeId or lines');
+        }
+        if (subject !== undefined) {
+            const file = (membersByFilepath ??= indexLocationMembers(subject)).get(filepath);
+            if (file === undefined)
+                invalid(at, 'location must reference an evaluated scope or group member');
+            const members = scopeId === undefined ? file.all : file.byId.get(scopeId);
+            if (members === undefined)
+                invalid(at, 'location must reference an evaluated scope or group member');
+            let contained = false;
+            let resolvedLines;
+            if (scopeId === undefined && lines !== undefined) {
+                contained = containsLocationRange(file, lines);
+            }
+            else {
+                for (const member of members) {
+                    const memberLines = member.lines;
+                    if (lines !== undefined) {
+                        if (memberLines === undefined ||
+                            (lines.start >= memberLines.start && lines.end <= memberLines.end)) {
+                            contained = true;
+                        }
+                    }
+                    else if (memberLines !== undefined) {
+                        if (resolvedLines !== undefined &&
+                            (resolvedLines.start !== memberLines.start || resolvedLines.end !== memberLines.end)) {
+                            invalid(at, 'location scopeId identifies multiple line ranges');
+                        }
+                        resolvedLines = { start: memberLines.start, end: memberLines.end };
+                    }
+                }
+            }
+            if (lines !== undefined && !contained) {
+                invalid(at, 'location lines must be contained in an evaluated scope or group member');
+            }
+            lines ??= resolvedLines;
+        }
+        locations.push({
+            filepath,
+            ...(scopeId === undefined ? {} : { scopeId }),
+            ...(lines === undefined ? {} : { lines }),
+        });
+    }
+    return locations;
+}
+export function validateCheckResult(value, label, subject) {
+    if (!isRecord(value))
+        invalid(label, 'check must return a check result object');
+    const status = value['status'];
+    if (status !== 'pass' && status !== 'violation') {
+        invalid(label, 'check status must be "pass" or "violation"');
+    }
+    const message = value['message'];
+    if (message !== undefined && typeof message !== 'string') {
+        invalid(label, 'check message must be a string');
+    }
+    const model = value['model'];
+    if (model !== undefined && (typeof model !== 'string' || model.trim() === '')) {
+        invalid(label, 'check model must be a non-blank string');
+    }
+    const probability = value['probability'];
+    if (probability !== undefined &&
+        (typeof probability !== 'number' ||
+            !Number.isFinite(probability) ||
+            probability < 0 ||
+            probability > 1)) {
+        invalid(label, 'check probability must be a finite number between 0 and 1');
+    }
+    const threshold = value['threshold'];
+    if (threshold !== undefined &&
+        (typeof threshold !== 'number' ||
+            !Number.isFinite(threshold) ||
+            threshold < 0 ||
+            threshold > 1)) {
+        invalid(label, 'check threshold must be a finite number between 0 and 1');
+    }
+    const rawUsage = value['usage'];
+    const usage = rawUsage === undefined ? undefined : validateAiUsage(rawUsage, label);
+    const rawLocations = value['locations'];
+    if (rawLocations !== undefined && status !== 'violation') {
+        invalid(label, 'check locations are only allowed on violation results');
+    }
+    const locations = rawLocations === undefined ? undefined : plainViolationLocations(rawLocations, label, subject);
+    return {
+        status,
+        ...(message === undefined ? {} : { message }),
+        ...(probability === undefined ? {} : { probability }),
+        ...(threshold === undefined ? {} : { threshold }),
+        ...(model === undefined ? {} : { model }),
+        ...(usage === undefined ? {} : { usage }),
+        ...(locations === undefined ? {} : { locations }),
+    };
+}

package/dist/app/violation-comments.d.ts

@@ -0,0 +1,10 @@
+export interface ViolationComment {
+    readonly body: string;
+    readonly locations: readonly {
+        readonly filepath: string;
+        readonly lines: {
+            readonly start: number;
+            readonly end: number;
+        };
+    }[];
+}

package/dist/app/violation-comments.js

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

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runCli } from './infra/runtime.js';
+process.exitCode = await runCli(process.argv.slice(2));

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { Rule } from './app/rule.js';
+export { test } from './app/rule-tests.js';
+export type { RuleTestCase } from './app/rule-tests.js';
+export type { AiExamples, AiOptions, AiUsage, Awaitable, CheckContext, CheckResult, Evaluator, Grouping, GroupSubject, JsonValue, PredicateResult, ProjectContext, RuleSettings, ScopeMatch, ScopeSelector, ScopeSubject, Selection, SelectionContext, SourceFile, Subject, TokenPricing, TokenUsage, ViolationLocation, } from './app/rule.js';
+export { ai, pass, regex, violation } from './app/evaluators.js';
+export type { RegexOptions } from './app/evaluators.js';
+export type { CsvOptions, CsvRow, DecisionBackend, DecisionExchange, DecisionInstructions, DecisionObserver, DecisionOutcome, DecisionRequest, DecisionRuntime, LoadedRule, Project, RuleEvaluation, RuleLoader, RuleReport, RuleSelection, RunContext, RunEvent, } from './app/ports.js';
+import { astGrep } from './adapter/scope/astgrep.js';
+import { csv } from './adapter/scope/csv.js';
+import { file } from './adapter/scope/file.js';
+import { json } from './adapter/scope/json.js';
+import { protobuf } from './adapter/scope/protobuf.js';
+import { yaml } from './adapter/scope/yaml.js';
+export { createAstGrepLanguageRegistrations } from './adapter/scope/astgrep-languages.js';
+export declare const scopes: {
+    file: typeof file;
+    json: typeof json;
+    yaml: typeof yaml;
+    csv: typeof csv;
+    astGrep: typeof astGrep;
+    protobuf: typeof protobuf;
+};

package/dist/index.js

@@ -0,0 +1,11 @@
+export { Rule } from './app/rule.js';
+export { test } from './app/rule-tests.js';
+export { ai, pass, regex, violation } from './app/evaluators.js';
+import { astGrep } from './adapter/scope/astgrep.js';
+import { csv } from './adapter/scope/csv.js';
+import { file } from './adapter/scope/file.js';
+import { json } from './adapter/scope/json.js';
+import { protobuf } from './adapter/scope/protobuf.js';
+import { yaml } from './adapter/scope/yaml.js';
+export { createAstGrepLanguageRegistrations } from './adapter/scope/astgrep-languages.js';
+export const scopes = { file, json, yaml, csv, astGrep, protobuf };

package/dist/infra/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { CliServices } from '../adapter/cli/services.js';
+export declare function createServices(cwd: string, env: Readonly<Record<string, string | undefined>>): CliServices;
+export declare function runCli(argv: readonly string[]): Promise<number>;

package/dist/infra/runtime.js

@@ -0,0 +1,168 @@
+import { stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { runProgram } from '../adapter/cli/program.js';
+import { terminalCapabilities } from '../adapter/cli/progress.js';
+import { createRedactor, escapeDiagnostic } from '../adapter/cli/text.js';
+import { installedVersion } from '../adapter/cli/version.js';
+const EXIT_FAILURE = 2;
+const ENVIRONMENT_FILE = '.env';
+function loadEnvironment(cwd) {
+    try {
+        process.loadEnvFile(resolve(cwd, ENVIRONMENT_FILE));
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+export function createServices(cwd, env) {
+    const redact = createRedactor([env.TYPESAFE_API_KEY, env.GITHUB_TOKEN]);
+    let dependenciesPromise;
+    let ruleServicesPromise;
+    const getDependencies = (context) => dependenciesPromise ??= (async () => {
+        const { createRuleDependencyManager } = await import('../adapter/filesystem/dependencies.js');
+        return createRuleDependencyManager({
+            ...(env.RK_DEPENDENCY_CACHE === undefined ? {} : { cacheRoot: resolve(cwd, env.RK_DEPENDENCY_CACHE) }),
+            onWarning: message => context.writeError(`coderuler: ${context.redact(escapeDiagnostic(message))}\n`),
+        });
+    })();
+    const getRuleServices = (context) => ruleServicesPromise ??= (async () => {
+        const dependencies = await getDependencies(context);
+        const { createRuleLoader, resolveRuleSelector } = await import('../adapter/filesystem/rules.js');
+        const loader = createRuleLoader({ dependencies });
+        return {
+            loadRules: selection => loader.load(selection),
+            resolveRuleSelector,
+        };
+    })();
+    const services = {
+        cwd,
+        version: installedVersion,
+        redact,
+        terminal: terminalCapabilities({
+            stdoutIsTTY: process.stdout.isTTY === true,
+            stderrIsTTY: process.stderr.isTTY === true,
+            get columns() { return process.stderr.columns; },
+            get stdoutColumns() { return process.stdout.columns; },
+        }, env),
+        write(text) {
+            process.stdout.write(text);
+        },
+        writeError(text) {
+            process.stderr.write(text);
+        },
+        load: {
+            async validate(context) {
+                return getRuleServices(context);
+            },
+            async check(context) {
+                const [ruleServices, project, execution, settings] = await Promise.all([
+                    getRuleServices(context),
+                    import('../adapter/filesystem/project.js'),
+                    import('../app/execute.js'),
+                    import('./settings.js'),
+                ]);
+                return {
+                    ...ruleServices,
+                    createProject: project.createProject,
+                    resolveTarget: project.resolveTarget,
+                    runRules: execution.executeRules,
+                    decisionResolver: (thresholdOverride, pricingOverrides) => settings.createDecisionResolver(env, thresholdOverride, pricingOverrides),
+                    async changedFiles(root, base) {
+                        const { changedFiles } = await import('../adapter/git/changes.js');
+                        return changedFiles(root, base);
+                    },
+                    async checkoutPullRequest(selector, baseBranch) {
+                        const { createPullRequestCheckout } = await import('../adapter/github/pull-request.js');
+                        return createPullRequestCheckout(cwd, env)(selector, baseBranch);
+                    },
+                    async commentOnPullRequest(root, comments, pullRequest) {
+                        const { createGithubCommenter } = await import('../adapter/github/comments.js');
+                        return createGithubCommenter(env)(root, comments, pullRequest);
+                    },
+                };
+            },
+            async inspect(context) {
+                const [ruleServices, project, execution, settings] = await Promise.all([
+                    getRuleServices(context),
+                    import('../adapter/filesystem/project.js'),
+                    import('../app/execute.js'),
+                    import('./settings.js'),
+                ]);
+                return {
+                    ...ruleServices,
+                    createProject: project.createProject,
+                    resolveTarget: project.resolveTarget,
+                    runRules: execution.executeRules,
+                    decisionResolver: (thresholdOverride, pricingOverrides) => settings.createDecisionResolver(env, thresholdOverride, pricingOverrides),
+                };
+            },
+            async test(context) {
+                const ruleServices = await getRuleServices(context);
+                const { runRuleTests } = await import('../adapter/filesystem/rule-tests.js');
+                return {
+                    ...ruleServices,
+                    testRules: (rules, onResult, timeoutMs, concurrency, includeAI) => runRuleTests(rules, onResult, timeoutMs, concurrency, includeAI),
+                };
+            },
+            async update(_context) {
+                const { createToolUpdater } = await import('../adapter/cli/self-update.js');
+                return { updateTool: createToolUpdater(cwd, env) };
+            },
+            async skill(_context) {
+                const { createSkillManager } = await import('../adapter/skills/cli.js');
+                return { manageSkill: createSkillManager(cwd, env) };
+            },
+            async deps(context) {
+                const dependencies = await getDependencies(context);
+                const { default: npa } = await import('npm-package-arg');
+                const manageDependencies = async (operation, packages, options) => {
+                    if (options.global === true && options.directory !== undefined) {
+                        throw new Error('--global and --directory are mutually exclusive');
+                    }
+                    const directory = options.global === true
+                        ? resolve(homedir(), '.coderuler')
+                        : resolve(cwd, options.directory ?? '.coderuler');
+                    if (operation !== 'add' && !(await stat(directory)).isDirectory()) {
+                        throw new Error(`Rule dependency directory is not a directory: ${directory}`);
+                    }
+                    if (operation === 'sync') {
+                        const prepared = await dependencies.sync(directory);
+                        context.write(context.redact(escapeDiagnostic(`Rule dependencies ready: ${prepared.directory}`)) + '\n');
+                        return;
+                    }
+                    const prepared = await dependencies.change(directory, operation, packages);
+                    if (operation === 'add') {
+                        for (const specifier of packages) {
+                            const name = npa(specifier).name;
+                            context.write(context.redact(escapeDiagnostic(`Added ${name}@${prepared.directVersions[name]}`)) + '\n');
+                        }
+                    }
+                    else {
+                        for (const name of packages)
+                            context.write(context.redact(escapeDiagnostic(`Removed ${name}`)) + '\n');
+                    }
+                    context.write(context.redact(escapeDiagnostic(join(prepared.directory, 'coderuler.lock'))) + '\n');
+                };
+                return { manageDependencies };
+            },
+        },
+    };
+    return services;
+}
+export async function runCli(argv) {
+    const cwd = process.cwd();
+    try {
+        const versionOnly = argv.length === 1 && (argv[0] === '--version' || argv[0] === '-V');
+        if (!versionOnly)
+            loadEnvironment(cwd);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const redact = createRedactor([process.env.TYPESAFE_API_KEY, process.env.GITHUB_TOKEN]);
+        process.stderr.write(`coderuler: ${redact(escapeDiagnostic(message))}\n`);
+        return EXIT_FAILURE;
+    }
+    return runProgram(argv, createServices(cwd, process.env));
+}

package/dist/infra/settings.d.ts

@@ -0,0 +1,5 @@
+import type { DecisionRuntime } from '../app/ports.js';
+import type { RuleSettings, TokenPricing } from '../app/rule.js';
+type Env = Readonly<Record<string, string | undefined>>;
+export declare function createDecisionResolver(env: Env, thresholdOverride?: number, pricingOverrides?: Partial<TokenPricing>): (settings: RuleSettings) => DecisionRuntime;
+export {};