@rainy-updates/cli 0.4.0

package/dist/config/policy.js

@@ -0,0 +1,32 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function loadPolicy(cwd, policyFile) {
+    const candidates = policyFile ? [policyFile] : [
+        path.join(cwd, ".rainyupdates-policy.json"),
+        path.join(cwd, "rainy-updates.policy.json"),
+    ];
+    for (const candidate of candidates) {
+        const filePath = path.isAbsolute(candidate) ? candidate : path.resolve(cwd, candidate);
+        try {
+            const content = await fs.readFile(filePath, "utf8");
+            const parsed = JSON.parse(content);
+            return {
+                ignorePatterns: parsed.ignore ?? [],
+                packageRules: new Map(Object.entries(parsed.packageRules ?? {}).map(([pkg, rule]) => [
+                    pkg,
+                    {
+                        maxTarget: rule.maxTarget,
+                        ignore: rule.ignore === true,
+                    },
+                ])),
+            };
+        }
+        catch {
+            // noop
+        }
+    }
+    return {
+        ignorePatterns: [],
+        packageRules: new Map(),
+    };
+}

package/dist/core/check.d.ts

@@ -0,0 +1,2 @@
+import type { CheckOptions, CheckResult } from "../types/index.js";
+export declare function check(options: CheckOptions): Promise<CheckResult>;

package/dist/core/check.js

@@ -0,0 +1,141 @@
+import path from "node:path";
+import { collectDependencies, readManifest } from "../parsers/package-json.js";
+import { matchesPattern } from "../utils/pattern.js";
+import { applyRangeStyle, classifyDiff, clampTarget, pickTargetVersion } from "../utils/semver.js";
+import { VersionCache } from "../cache/cache.js";
+import { NpmRegistryClient } from "../registry/npm.js";
+import { detectPackageManager } from "../pm/detect.js";
+import { discoverPackageDirs } from "../workspace/discover.js";
+import { loadPolicy } from "../config/policy.js";
+export async function check(options) {
+    const packageManager = await detectPackageManager(options.cwd);
+    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
+    const cache = await VersionCache.create();
+    const registryClient = new NpmRegistryClient();
+    const policy = await loadPolicy(options.cwd, options.policyFile);
+    const updates = [];
+    const errors = [];
+    const warnings = [];
+    let totalDependencies = 0;
+    const tasks = [];
+    let skipped = 0;
+    for (const packageDir of packageDirs) {
+        let manifest;
+        try {
+            manifest = await readManifest(packageDir);
+        }
+        catch (error) {
+            errors.push(`Failed to read package.json in ${packageDir}: ${String(error)}`);
+            continue;
+        }
+        const dependencies = collectDependencies(manifest, options.includeKinds);
+        totalDependencies += dependencies.length;
+        for (const dep of dependencies) {
+            if (!matchesPattern(dep.name, options.filter))
+                continue;
+            if (options.reject && matchesPattern(dep.name, options.reject))
+                continue;
+            const rule = policy.packageRules.get(dep.name);
+            if (rule?.ignore === true) {
+                skipped += 1;
+                continue;
+            }
+            if (policy.ignorePatterns.some((pattern) => matchesPattern(dep.name, pattern))) {
+                skipped += 1;
+                continue;
+            }
+            tasks.push({ packageDir, dependency: dep });
+        }
+    }
+    const uniquePackageNames = Array.from(new Set(tasks.map((task) => task.dependency.name)));
+    const resolvedVersions = new Map();
+    const unresolvedPackages = [];
+    for (const packageName of uniquePackageNames) {
+        const cached = await cache.getValid(packageName, options.target);
+        if (cached) {
+            resolvedVersions.set(packageName, cached.latestVersion);
+        }
+        else {
+            unresolvedPackages.push(packageName);
+        }
+    }
+    if (unresolvedPackages.length > 0) {
+        if (options.offline) {
+            for (const packageName of unresolvedPackages) {
+                const stale = await cache.getAny(packageName, options.target);
+                if (stale) {
+                    resolvedVersions.set(packageName, stale.latestVersion);
+                    warnings.push(`Using stale cache for ${packageName} because --offline is enabled.`);
+                }
+                else {
+                    errors.push(`Offline cache miss for ${packageName}. Run once without --offline to warm cache.`);
+                }
+            }
+        }
+        else {
+            const fetched = await registryClient.resolveManyLatestVersions(unresolvedPackages, {
+                concurrency: options.concurrency,
+            });
+            for (const [packageName, version] of fetched.versions) {
+                resolvedVersions.set(packageName, version);
+                if (version) {
+                    await cache.set(packageName, options.target, version, options.cacheTtlSeconds);
+                }
+            }
+            for (const [packageName, error] of fetched.errors) {
+                const stale = await cache.getAny(packageName, options.target);
+                if (stale) {
+                    resolvedVersions.set(packageName, stale.latestVersion);
+                    warnings.push(`Using stale cache for ${packageName} due to registry error: ${error}`);
+                }
+                else {
+                    errors.push(`Unable to resolve ${packageName}: ${error}`);
+                }
+            }
+        }
+    }
+    for (const task of tasks) {
+        const latestVersion = resolvedVersions.get(task.dependency.name);
+        if (!latestVersion)
+            continue;
+        const rule = policy.packageRules.get(task.dependency.name);
+        const effectiveTarget = clampTarget(options.target, rule?.maxTarget);
+        const picked = pickTargetVersion(task.dependency.range, latestVersion, effectiveTarget);
+        if (!picked)
+            continue;
+        const nextRange = applyRangeStyle(task.dependency.range, picked);
+        if (nextRange === task.dependency.range)
+            continue;
+        updates.push({
+            packagePath: path.resolve(task.packageDir),
+            name: task.dependency.name,
+            kind: task.dependency.kind,
+            fromRange: task.dependency.range,
+            toRange: nextRange,
+            toVersionResolved: picked,
+            diffType: classifyDiff(task.dependency.range, picked),
+            filtered: false,
+            reason: rule?.maxTarget ? `policy maxTarget=${rule.maxTarget}` : undefined,
+        });
+    }
+    const summary = {
+        scannedPackages: packageDirs.length,
+        totalDependencies,
+        checkedDependencies: tasks.length,
+        updatesFound: updates.length,
+        upgraded: 0,
+        skipped,
+        warmedPackages: 0,
+    };
+    return {
+        projectPath: options.cwd,
+        packagePaths: packageDirs,
+        packageManager,
+        target: options.target,
+        timestamp: new Date().toISOString(),
+        summary,
+        updates,
+        errors,
+        warnings,
+    };
+}

package/dist/core/init-ci.d.ts

@@ -0,0 +1,4 @@
+export declare function initCiWorkflow(cwd: string, force: boolean): Promise<{
+    path: string;
+    created: boolean;
+}>;

package/dist/core/init-ci.js

@@ -0,0 +1,20 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function initCiWorkflow(cwd, force) {
+    const workflowPath = path.join(cwd, ".github", "workflows", "rainy-updates.yml");
+    try {
+        if (!force) {
+            await fs.access(workflowPath);
+            return { path: workflowPath, created: false };
+        }
+    }
+    catch {
+        // missing file, continue create
+    }
+    await fs.mkdir(path.dirname(workflowPath), { recursive: true });
+    await fs.writeFile(workflowPath, workflowTemplate(), "utf8");
+    return { path: workflowPath, created: true };
+}
+function workflowTemplate() {
+    return `name: Rainy Updates\n\non:\n  schedule:\n    - cron: '0 8 * * 1'\n  workflow_dispatch:\n\njobs:\n  dependency-updates:\n    runs-on: ubuntu-latest\n    steps:\n      - name: Checkout\n        uses: actions/checkout@v4\n\n      - name: Setup Node\n        uses: actions/setup-node@v4\n        with:\n          node-version: '20'\n\n      - name: Run rainy updates\n        run: |\n          npx @rainy-updates/cli check \\\n            --workspace \\\n            --ci \\\n            --concurrency 32 \\\n            --format github \\\n            --json-file .artifacts/deps-report.json \\\n            --sarif-file .artifacts/deps-report.sarif \\\n            --github-output $GITHUB_OUTPUT\n\n      - name: Upload SARIF\n        uses: github/codeql-action/upload-sarif@v3\n        with:\n          sarif_file: .artifacts/deps-report.sarif\n`;
+}

package/dist/core/options.d.ts

@@ -0,0 +1,17 @@
+import type { CheckOptions, UpgradeOptions } from "../types/index.js";
+export type ParsedCliArgs = {
+    command: "check";
+    options: CheckOptions;
+} | {
+    command: "upgrade";
+    options: UpgradeOptions;
+} | {
+    command: "warm-cache";
+    options: CheckOptions;
+} | {
+    command: "init-ci";
+    options: CheckOptions & {
+        force: boolean;
+    };
+};
+export declare function parseCliArgs(argv: string[]): Promise<ParsedCliArgs>;

package/dist/core/options.js

@@ -0,0 +1,238 @@
+import path from "node:path";
+import process from "node:process";
+import { loadConfig } from "../config/loader.js";
+const DEFAULT_INCLUDE_KINDS = [
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+    "peerDependencies",
+];
+const KNOWN_COMMANDS = ["check", "upgrade", "warm-cache", "init-ci"];
+export async function parseCliArgs(argv) {
+    const firstArg = argv[0];
+    const isKnownCommand = KNOWN_COMMANDS.includes(firstArg);
+    if (firstArg && !firstArg.startsWith("-") && !isKnownCommand) {
+        throw new Error(`Unknown command: ${firstArg}`);
+    }
+    const command = isKnownCommand ? argv[0] : "check";
+    const hasExplicitCommand = isKnownCommand;
+    const args = hasExplicitCommand ? argv.slice(1) : argv.slice(0);
+    const base = {
+        cwd: process.cwd(),
+        target: "latest",
+        filter: undefined,
+        reject: undefined,
+        cacheTtlSeconds: 3600,
+        includeKinds: DEFAULT_INCLUDE_KINDS,
+        ci: false,
+        format: "table",
+        workspace: false,
+        jsonFile: undefined,
+        githubOutputFile: undefined,
+        sarifFile: undefined,
+        concurrency: 16,
+        offline: false,
+        policyFile: undefined,
+        prReportFile: undefined,
+    };
+    let force = false;
+    let resolvedConfig = await loadConfig(base.cwd);
+    applyConfig(base, resolvedConfig);
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        const next = args[index + 1];
+        if (current === "--target" && next) {
+            base.target = ensureTarget(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--filter" && next) {
+            base.filter = next;
+            index += 1;
+            continue;
+        }
+        if (current === "--reject" && next) {
+            base.reject = next;
+            index += 1;
+            continue;
+        }
+        if (current === "--cwd" && next) {
+            base.cwd = path.resolve(next);
+            resolvedConfig = await loadConfig(base.cwd);
+            applyConfig(base, resolvedConfig);
+            index += 1;
+            continue;
+        }
+        if (current === "--cache-ttl" && next) {
+            const parsed = Number(next);
+            if (!Number.isFinite(parsed) || parsed < 0) {
+                throw new Error("--cache-ttl must be a positive number");
+            }
+            base.cacheTtlSeconds = parsed;
+            index += 1;
+            continue;
+        }
+        if (current === "--format" && next) {
+            base.format = ensureFormat(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--ci") {
+            base.ci = true;
+            continue;
+        }
+        if (current === "--workspace") {
+            base.workspace = true;
+            continue;
+        }
+        if (current === "--json-file" && next) {
+            base.jsonFile = path.resolve(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--github-output" && next) {
+            base.githubOutputFile = path.resolve(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--sarif-file" && next) {
+            base.sarifFile = path.resolve(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--concurrency" && next) {
+            const parsed = Number(next);
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+                throw new Error("--concurrency must be a positive integer");
+            }
+            base.concurrency = parsed;
+            index += 1;
+            continue;
+        }
+        if (current === "--offline") {
+            base.offline = true;
+            continue;
+        }
+        if (current === "--policy-file" && next) {
+            base.policyFile = path.resolve(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--pr-report-file" && next) {
+            base.prReportFile = path.resolve(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--force") {
+            force = true;
+            continue;
+        }
+        if (current === "--dep-kinds" && next) {
+            base.includeKinds = parseDependencyKinds(next);
+            index += 1;
+            continue;
+        }
+    }
+    if (command === "upgrade") {
+        const configPm = resolvedConfig.packageManager;
+        const cliPm = parsePackageManager(args);
+        const upgradeOptions = {
+            ...base,
+            install: args.includes("--install") || resolvedConfig.install === true,
+            packageManager: cliPm === "auto" ? (configPm ?? "auto") : cliPm,
+            sync: args.includes("--sync") || resolvedConfig.sync === true,
+        };
+        return { command, options: upgradeOptions };
+    }
+    if (command === "warm-cache") {
+        return { command, options: base };
+    }
+    if (command === "init-ci") {
+        return { command, options: { ...base, force } };
+    }
+    return {
+        command: "check",
+        options: base,
+    };
+}
+function applyConfig(base, config) {
+    if (config.target)
+        base.target = config.target;
+    if (config.filter !== undefined)
+        base.filter = config.filter;
+    if (config.reject !== undefined)
+        base.reject = config.reject;
+    if (typeof config.cacheTtlSeconds === "number")
+        base.cacheTtlSeconds = config.cacheTtlSeconds;
+    if (Array.isArray(config.includeKinds) && config.includeKinds.length > 0)
+        base.includeKinds = config.includeKinds;
+    if (typeof config.ci === "boolean")
+        base.ci = config.ci;
+    if (config.format)
+        base.format = config.format;
+    if (typeof config.workspace === "boolean")
+        base.workspace = config.workspace;
+    if (typeof config.jsonFile === "string")
+        base.jsonFile = path.resolve(base.cwd, config.jsonFile);
+    if (typeof config.githubOutputFile === "string") {
+        base.githubOutputFile = path.resolve(base.cwd, config.githubOutputFile);
+    }
+    if (typeof config.sarifFile === "string") {
+        base.sarifFile = path.resolve(base.cwd, config.sarifFile);
+    }
+    if (typeof config.concurrency === "number" && Number.isInteger(config.concurrency) && config.concurrency > 0) {
+        base.concurrency = config.concurrency;
+    }
+    if (typeof config.offline === "boolean") {
+        base.offline = config.offline;
+    }
+    if (typeof config.policyFile === "string") {
+        base.policyFile = path.resolve(base.cwd, config.policyFile);
+    }
+    if (typeof config.prReportFile === "string") {
+        base.prReportFile = path.resolve(base.cwd, config.prReportFile);
+    }
+}
+function parsePackageManager(args) {
+    const index = args.indexOf("--pm");
+    if (index === -1)
+        return "auto";
+    const value = args[index + 1] ?? "auto";
+    if (value === "auto" || value === "npm" || value === "pnpm") {
+        return value;
+    }
+    throw new Error("--pm must be auto, npm or pnpm");
+}
+function ensureTarget(value) {
+    if (value === "patch" || value === "minor" || value === "major" || value === "latest") {
+        return value;
+    }
+    throw new Error("--target must be patch, minor, major, latest");
+}
+function ensureFormat(value) {
+    if (value === "table" || value === "json" || value === "minimal" || value === "github") {
+        return value;
+    }
+    throw new Error("--format must be table, json, minimal or github");
+}
+function parseDependencyKinds(value) {
+    const mapped = value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .map((item) => {
+        if (item === "dependencies" || item === "deps")
+            return "dependencies";
+        if (item === "devDependencies" || item === "dev")
+            return "devDependencies";
+        if (item === "optionalDependencies" || item === "optional")
+            return "optionalDependencies";
+        if (item === "peerDependencies" || item === "peer")
+            return "peerDependencies";
+        throw new Error(`Unknown dependency kind: ${item}`);
+    });
+    if (mapped.length === 0) {
+        throw new Error("--dep-kinds requires at least one value");
+    }
+    return Array.from(new Set(mapped));
+}

package/dist/core/upgrade.d.ts

@@ -0,0 +1,2 @@
+import type { UpgradeOptions, UpgradeResult } from "../types/index.js";
+export declare function upgrade(options: UpgradeOptions): Promise<UpgradeResult>;

package/dist/core/upgrade.js

@@ -0,0 +1,88 @@
+import { check } from "./check.js";
+import { readManifest, writeManifest } from "../parsers/package-json.js";
+import { installDependencies } from "../pm/install.js";
+import { applyRangeStyle, parseVersion, compareVersions } from "../utils/semver.js";
+import { buildWorkspaceGraph } from "../workspace/graph.js";
+export async function upgrade(options) {
+    const checkResult = await check(options);
+    if (checkResult.updates.length === 0) {
+        return {
+            ...checkResult,
+            changed: false,
+        };
+    }
+    const manifestsByPath = new Map();
+    for (const update of checkResult.updates) {
+        const manifestPath = update.packagePath;
+        let manifest = manifestsByPath.get(manifestPath);
+        if (!manifest) {
+            manifest = await readManifest(manifestPath);
+            manifestsByPath.set(manifestPath, manifest);
+        }
+        applyDependencyVersion(manifest, update.kind, update.name, update.toRange);
+    }
+    if (options.sync) {
+        const graph = buildWorkspaceGraph(manifestsByPath, options.includeKinds);
+        if (graph.cycles.length > 0) {
+            checkResult.warnings.push(`Workspace graph contains cycle(s): ${graph.cycles.map((cycle) => cycle.join(" -> ")).join(" | ")}`);
+        }
+        applyWorkspaceSync(manifestsByPath, graph.orderedPaths, graph.localPackageNames, options.includeKinds, checkResult.updates);
+    }
+    for (const [manifestPath, manifest] of manifestsByPath) {
+        await writeManifest(manifestPath, manifest);
+    }
+    if (options.install) {
+        await installDependencies(options.cwd, options.packageManager, checkResult.packageManager);
+    }
+    return {
+        ...checkResult,
+        changed: true,
+        summary: {
+            ...checkResult.summary,
+            upgraded: checkResult.updates.length,
+        },
+    };
+}
+function applyWorkspaceSync(manifestsByPath, orderedPaths, localPackageNames, includeKinds, updates) {
+    const desiredByPackage = new Map();
+    for (const update of updates) {
+        const current = desiredByPackage.get(update.name);
+        if (!current) {
+            desiredByPackage.set(update.name, update.toVersionResolved);
+            continue;
+        }
+        const currentParsed = parseVersion(current);
+        const nextParsed = parseVersion(update.toVersionResolved);
+        if (!currentParsed || !nextParsed) {
+            desiredByPackage.set(update.name, update.toVersionResolved);
+            continue;
+        }
+        if (compareVersions(nextParsed, currentParsed) > 0) {
+            desiredByPackage.set(update.name, update.toVersionResolved);
+        }
+    }
+    for (const manifestPath of orderedPaths) {
+        const manifest = manifestsByPath.get(manifestPath);
+        if (!manifest)
+            continue;
+        for (const kind of includeKinds) {
+            const section = manifest[kind];
+            if (!section)
+                continue;
+            for (const [depName, depRange] of Object.entries(section)) {
+                const desiredVersion = desiredByPackage.get(depName);
+                if (!desiredVersion)
+                    continue;
+                if (localPackageNames.has(depName) && depRange.startsWith("workspace:"))
+                    continue;
+                section[depName] = applyRangeStyle(depRange, desiredVersion);
+            }
+        }
+    }
+}
+function applyDependencyVersion(manifest, kind, depName, nextRange) {
+    const section = manifest[kind];
+    if (!section || !section[depName])
+        return;
+    section[depName] = nextRange;
+}

package/dist/core/warm-cache.d.ts

@@ -0,0 +1,2 @@
+import type { CheckOptions, CheckResult } from "../types/index.js";
+export declare function warmCache(options: CheckOptions): Promise<CheckResult>;

package/dist/core/warm-cache.js

@@ -0,0 +1,89 @@
+import { collectDependencies, readManifest } from "../parsers/package-json.js";
+import { matchesPattern } from "../utils/pattern.js";
+import { VersionCache } from "../cache/cache.js";
+import { NpmRegistryClient } from "../registry/npm.js";
+import { detectPackageManager } from "../pm/detect.js";
+import { discoverPackageDirs } from "../workspace/discover.js";
+export async function warmCache(options) {
+    const packageManager = await detectPackageManager(options.cwd);
+    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
+    const cache = await VersionCache.create();
+    const registryClient = new NpmRegistryClient();
+    const errors = [];
+    const warnings = [];
+    let totalDependencies = 0;
+    const packageNames = new Set();
+    for (const packageDir of packageDirs) {
+        try {
+            const manifest = await readManifest(packageDir);
+            const dependencies = collectDependencies(manifest, options.includeKinds);
+            totalDependencies += dependencies.length;
+            for (const dep of dependencies) {
+                if (!matchesPattern(dep.name, options.filter))
+                    continue;
+                if (options.reject && matchesPattern(dep.name, options.reject))
+                    continue;
+                packageNames.add(dep.name);
+            }
+        }
+        catch (error) {
+            errors.push(`Failed to read package.json in ${packageDir}: ${String(error)}`);
+        }
+    }
+    const names = Array.from(packageNames);
+    const needsFetch = [];
+    for (const pkg of names) {
+        const valid = await cache.getValid(pkg, options.target);
+        if (!valid)
+            needsFetch.push(pkg);
+    }
+    let warmed = 0;
+    if (needsFetch.length > 0) {
+        if (options.offline) {
+            for (const pkg of needsFetch) {
+                const stale = await cache.getAny(pkg, options.target);
+                if (stale) {
+                    warnings.push(`Using stale cache for ${pkg} in offline warm-cache mode.`);
+                    warmed += 1;
+                }
+                else {
+                    errors.push(`Offline cache miss for ${pkg}. Cannot warm cache in --offline mode.`);
+                }
+            }
+        }
+        else {
+            const fetched = await registryClient.resolveManyLatestVersions(needsFetch, {
+                concurrency: options.concurrency,
+            });
+            for (const [pkg, version] of fetched.versions) {
+                if (version) {
+                    await cache.set(pkg, options.target, version, options.cacheTtlSeconds);
+                    warmed += 1;
+                }
+            }
+            for (const [pkg, error] of fetched.errors) {
+                errors.push(`Unable to warm ${pkg}: ${error}`);
+            }
+        }
+    }
+    const summary = {
+        scannedPackages: packageDirs.length,
+        totalDependencies,
+        checkedDependencies: names.length,
+        updatesFound: 0,
+        upgraded: 0,
+        skipped: 0,
+        warmedPackages: warmed,
+    };
+    return {
+        projectPath: options.cwd,
+        packagePaths: packageDirs,
+        packageManager,
+        target: options.target,
+        timestamp: new Date().toISOString(),
+        summary,
+        updates: [],
+        errors,
+        warnings,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { check } from "./core/check.js";
+export { upgrade } from "./core/upgrade.js";
+export { warmCache } from "./core/warm-cache.js";
+export { initCiWorkflow } from "./core/init-ci.js";
+export { createSarifReport } from "./output/sarif.js";
+export { writeGitHubOutput, renderGitHubAnnotations } from "./output/github.js";
+export { renderPrReport } from "./output/pr-report.js";
+export type { CheckOptions, CheckResult, DependencyKind, OutputFormat, PackageUpdate, RunOptions, TargetLevel, UpgradeOptions, UpgradeResult, } from "./types/index.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { check } from "./core/check.js";
+export { upgrade } from "./core/upgrade.js";
+export { warmCache } from "./core/warm-cache.js";
+export { initCiWorkflow } from "./core/init-ci.js";
+export { createSarifReport } from "./output/sarif.js";
+export { writeGitHubOutput, renderGitHubAnnotations } from "./output/github.js";
+export { renderPrReport } from "./output/pr-report.js";

package/dist/output/format.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult, OutputFormat } from "../types/index.js";
+export declare function renderResult(result: CheckResult, format: OutputFormat): string;