@clipboard-health/tribunal 1.1.0

package/src/html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.js","sourceRoot":"","sources":["../../../../packages/tribunal/src/html.ts"],"names":[],"mappings":"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"}

package/src/index.d.ts

@@ -0,0 +1,60 @@
+import { type CreateIntermediateOutputRecorderInput } from "./intermediates.ts";
+import { type ModelRole, type ModelSpec } from "./models.ts";
+import { type ReasoningOverrides } from "./reasoning.ts";
+import { type OutputFormat, type TribunalProgressHandler, type TribunalRequest, type TribunalResponse } from "./tribunal.ts";
+export { formatOutput, type FormatOutputInput } from "./format.ts";
+export { createDefaultIntermediateOutputPath, createIntermediateOutputRecorder, type CreateIntermediateOutputRecorderInput, type IntermediateOutputCall, type IntermediateOutputEvent, type IntermediateOutputRecorder, type IntermediateOutputRunStatus, type IntermediateOutputSnapshot, } from "./intermediates.ts";
+export { DEFAULT_MODELS, formatModelSpec, parseModelOverride, parseModelRole, parseModelSpec, resolveLanguageModel, resolveModelSet, } from "./models.ts";
+export { createReasoningProviderOptions, parseReasoningLevel, parseReasoningOverride, type ReasoningLevel, type ReasoningOverride, type ReasoningOverrides, type ReasoningProviderOptions, } from "./reasoning.ts";
+export { type Claim, claimSchema, confidenceSchema, type DeliberationResult, deliberationResultSchema, type PerspectiveResult, perspectiveResultSchema, type Role, roleSchema, } from "./schemas.ts";
+export { type CallMetadata, type CostEstimate, type CostEstimateCall, estimateCostUsd, normalizeUsage, type OutputFormat, type PerspectiveOutput, runStructuredOutput, runTribunal, type StructuredOutputInput, type StructuredOutputResult, type StructuredOutputRunner, sumTokenUsage, type TokenUsage, type TribunalProgressEvent, type TribunalProgressHandler, type TribunalProgressStatus, type TribunalRequest, type TribunalResponse, } from "./tribunal.ts";
+export interface ParsedCliArguments {
+    query: string;
+    context?: string;
+    contextFilePath?: string;
+    models: Partial<Record<ModelRole, ModelSpec>>;
+    reasoning: ReasoningOverrides;
+    intermediateOutputFilePath?: string;
+    htmlReportFilePath?: string;
+    outputFormat: OutputFormat;
+    showPerspectives: boolean;
+    shouldSaveIntermediates: boolean;
+    shouldWriteHtmlReport: boolean;
+    shouldOpenHtmlReport: boolean;
+    verbose: boolean;
+    shouldShowHelp: boolean;
+}
+export interface LoadContextInput {
+    cwd: string;
+    inlineContext?: string;
+    contextFilePath?: string;
+    maxContextChars?: number;
+    readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
+}
+export interface LoadedContext {
+    context?: string;
+    warnings: string[];
+}
+export interface TextWritable {
+    write(chunk: string): void;
+}
+export interface RunCliInput {
+    argv?: readonly string[];
+    cwd?: string;
+    environment?: Record<string, string | undefined>;
+    stdout?: TextWritable;
+    stderr?: TextWritable;
+    readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
+    writeFile?: CreateIntermediateOutputRecorderInput["writeFile"];
+    makeDirectory?: CreateIntermediateOutputRecorderInput["makeDirectory"];
+    writeHtmlReport?: (filePath: string, html: string) => Promise<void>;
+    openHtmlReport?: (filePath: string) => Promise<void>;
+    now?: () => Date;
+    runTribunal?: (request: TribunalRequest, options: {
+        environment: Record<string, string | undefined>;
+        onProgress?: TribunalProgressHandler;
+    }) => Promise<TribunalResponse>;
+}
+export declare function parseCliArguments(argv: readonly string[]): ParsedCliArguments;
+export declare function loadContext(input: LoadContextInput): Promise<LoadedContext>;
+export declare function runCli(input?: RunCliInput): Promise<number>;

package/src/index.js

@@ -0,0 +1,573 @@
+import { spawn } from "node:child_process";
+import { mkdir, readFile as readFileFromDisk, writeFile as writeFileToDisk, } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { formatOutput } from "./format.js";
+import { renderHtmlReport } from "./html.js";
+import { createDefaultIntermediateOutputPath, createIntermediateOutputRecorder, } from "./intermediates.js";
+import { formatModelSpec, parseModelOverride, parseModelSpec, } from "./models.js";
+import { parseReasoningOverride } from "./reasoning.js";
+import { runTribunal as runTribunalDefault, } from "./tribunal.js";
+export { formatOutput } from "./format.js";
+export { createDefaultIntermediateOutputPath, createIntermediateOutputRecorder, } from "./intermediates.js";
+export { DEFAULT_MODELS, formatModelSpec, parseModelOverride, parseModelRole, parseModelSpec, resolveLanguageModel, resolveModelSet, } from "./models.js";
+export { createReasoningProviderOptions, parseReasoningLevel, parseReasoningOverride, } from "./reasoning.js";
+export { claimSchema, confidenceSchema, deliberationResultSchema, perspectiveResultSchema, roleSchema, } from "./schemas.js";
+export { estimateCostUsd, normalizeUsage, runStructuredOutput, runTribunal, sumTokenUsage, } from "./tribunal.js";
+const MAX_CONTEXT_CHARS = 120_000;
+const DEFAULT_PROGRESS_INTERVAL_MS = 5000;
+const USAGE = `Usage:
+  tribunal "Should we use microservices or a monolith?"
+
+Flags:
+  --context <text>                 Inline context string
+  --context-file <path>            Read additional context from a file
+  --model <role=provider:model>    Override advocate, skeptic, or analyst model
+  --deliberator <provider:model>   Override deliberator model
+  --reasoning <role=level>         Override reasoning for advocate, skeptic, analyst, or deliberator
+  --output <text|json|markdown>    Output format; default text
+  --show-perspectives              Include specialist outputs in text/markdown
+  --save-intermediates <path>      Write intermediate run snapshots; default .tribunal/runs/<timestamp>.json
+  --no-save-intermediates          Disable intermediate run snapshots
+  --html <path>                    Write HTML report; default .tribunal/reports/<timestamp>.html
+  --no-html                        Disable HTML report
+  --no-open                        Write the HTML report but skip opening it
+  --verbose                        Print progress, wait dots, and warnings to stderr
+  -h, --help                       Show usage`;
+export function parseCliArguments(argv) {
+    const positionalArguments = [];
+    const models = {};
+    const reasoning = {};
+    let intermediateOutputFilePath;
+    let htmlReportFilePath;
+    let context;
+    let contextFilePath;
+    let outputFormat = "text";
+    let showPerspectives = false;
+    let shouldSaveIntermediates = true;
+    let shouldWriteHtmlReport = true;
+    let shouldOpenHtmlReport = true;
+    let verbose = false;
+    let shouldShowHelp = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (argument === undefined) {
+            continue;
+        }
+        switch (argument) {
+            case "-h":
+            case "--help": {
+                shouldShowHelp = true;
+                break;
+            }
+            case "--context": {
+                context = readFlagValue({ argv, flag: argument, index });
+                index += 1;
+                break;
+            }
+            case "--context-file": {
+                contextFilePath = readFlagValue({ argv, flag: argument, index });
+                index += 1;
+                break;
+            }
+            case "--model": {
+                const override = parseModelOverride(readFlagValue({ argv, flag: argument, index }));
+                models[override.role] = override.model;
+                index += 1;
+                break;
+            }
+            case "--deliberator": {
+                models.deliberator = parseModelSpec(readFlagValue({ argv, flag: argument, index }));
+                index += 1;
+                break;
+            }
+            case "--reasoning": {
+                const override = parseReasoningOverride(readFlagValue({ argv, flag: argument, index }));
+                reasoning[override.role] = override.level;
+                index += 1;
+                break;
+            }
+            case "--output": {
+                outputFormat = parseOutputFormat(readFlagValue({ argv, flag: argument, index }));
+                index += 1;
+                break;
+            }
+            case "--show-perspectives": {
+                showPerspectives = true;
+                break;
+            }
+            case "--save-intermediates": {
+                intermediateOutputFilePath = readFlagValue({ argv, flag: argument, index });
+                shouldSaveIntermediates = true;
+                index += 1;
+                break;
+            }
+            case "--no-save-intermediates": {
+                shouldSaveIntermediates = false;
+                intermediateOutputFilePath = undefined;
+                break;
+            }
+            case "--verbose": {
+                verbose = true;
+                break;
+            }
+            default: {
+                const htmlState = {
+                    htmlReportFilePath,
+                    shouldOpenHtmlReport,
+                    shouldWriteHtmlReport,
+                };
+                const htmlAdvance = tryApplyHtmlFlag({ argv, argument, index, state: htmlState });
+                if (htmlAdvance >= 0) {
+                    ({ htmlReportFilePath, shouldOpenHtmlReport, shouldWriteHtmlReport } = htmlState);
+                    index += htmlAdvance;
+                    break;
+                }
+                if (argument.startsWith("-")) {
+                    throw new Error(`Unknown flag: ${argument}`);
+                }
+                positionalArguments.push(argument);
+                break;
+            }
+        }
+    }
+    const query = positionalArguments.join(" ").trim();
+    if (!shouldShowHelp && query.length === 0) {
+        throw new Error("Query is required. Run tribunal --help for usage.");
+    }
+    const parsedArguments = {
+        query,
+        models,
+        outputFormat,
+        reasoning,
+        shouldOpenHtmlReport,
+        shouldSaveIntermediates,
+        shouldWriteHtmlReport,
+        showPerspectives,
+        verbose,
+        shouldShowHelp,
+    };
+    assignParsedContext(parsedArguments, context);
+    assignParsedContextFilePath(parsedArguments, contextFilePath);
+    assignParsedIntermediateOutputFilePath(parsedArguments, intermediateOutputFilePath);
+    assignParsedHtmlReportFilePath(parsedArguments, htmlReportFilePath);
+    return parsedArguments;
+}
+export async function loadContext(input) {
+    const { contextFilePath, cwd, inlineContext, maxContextChars = MAX_CONTEXT_CHARS, readFile = readFileFromDisk, } = input;
+    const warnings = [];
+    const parts = [];
+    if (inlineContext !== undefined) {
+        parts.push(inlineContext);
+    }
+    if (contextFilePath !== undefined) {
+        let fileContents;
+        try {
+            fileContents = await readFile(resolve(cwd, contextFilePath), "utf8");
+        }
+        catch (error) {
+            throw new Error(`Failed to read context file ${contextFilePath}: ${formatErrorMessage(error)}`, { cause: error });
+        }
+        if (inlineContext !== undefined) {
+            parts.splice(0, 1, `Inline context:\n\n${inlineContext}`);
+        }
+        parts.push(`File context from ${contextFilePath}:\n\n${fileContents}`);
+    }
+    if (parts.length === 0) {
+        return { warnings };
+    }
+    const combinedContext = parts.join("\n\n");
+    if (combinedContext.length <= maxContextChars) {
+        return { context: combinedContext, warnings };
+    }
+    warnings.push(`Context exceeded ${maxContextChars} characters and was truncated.`);
+    return {
+        context: combinedContext.slice(0, maxContextChars),
+        warnings,
+    };
+}
+export async function runCli(input = {}) {
+    const argv = input.argv ?? process.argv.slice(2);
+    const cwd = input.cwd ?? process.cwd();
+    // oxlint-disable-next-line node/no-process-env -- CLI defaults to inherited environment so op run can inject API keys and model override vars at runtime.
+    const environment = input.environment ?? process.env;
+    const stdout = input.stdout ?? process.stdout;
+    const stderr = input.stderr ?? process.stderr;
+    const runTribunal = input.runTribunal ?? runTribunalDefault;
+    let progressReporter;
+    let intermediateOutputRecorder;
+    try {
+        const parsedArguments = parseCliArguments(argv);
+        if (parsedArguments.shouldShowHelp) {
+            stdout.write(`${USAGE}\n`);
+            return 0;
+        }
+        if (parsedArguments.verbose) {
+            stderr.write("Running tribunal...\n");
+            progressReporter = createCliProgressReporter({
+                intervalMs: DEFAULT_PROGRESS_INTERVAL_MS,
+                stderr,
+            });
+        }
+        const loadContextInput = createLoadContextInput({
+            cwd,
+            parsedArguments,
+            readFile: input.readFile,
+        });
+        const loadedContext = await loadContext(loadContextInput);
+        const tribunalRequest = createTribunalRequest(parsedArguments, loadedContext);
+        intermediateOutputRecorder = await createCliIntermediateOutputRecorder({
+            cwd,
+            makeDirectory: input.makeDirectory,
+            now: input.now,
+            parsedArguments,
+            request: tribunalRequest,
+            stderr,
+            writeFile: input.writeFile,
+        });
+        const onProgress = createProgressHandler({
+            intermediateOutputRecorder,
+            progressReporter,
+        });
+        const runTribunalOptions = { environment };
+        if (onProgress !== undefined) {
+            runTribunalOptions.onProgress = onProgress;
+        }
+        const response = await runTribunal(tribunalRequest, runTribunalOptions);
+        const responseWithContextWarnings = appendWarnings(response, loadedContext.warnings);
+        await intermediateOutputRecorder?.markCompleted(responseWithContextWarnings);
+        stdout.write(`${formatOutput(responseWithContextWarnings, {
+            outputFormat: parsedArguments.outputFormat,
+            showPerspectives: parsedArguments.showPerspectives,
+        })}\n`);
+        await writeAndOpenHtmlReport({
+            cwd,
+            now: input.now,
+            openHtmlReport: input.openHtmlReport,
+            parsedArguments,
+            request: tribunalRequest,
+            response: responseWithContextWarnings,
+            stderr,
+            writeHtmlReport: input.writeHtmlReport,
+        });
+        if (parsedArguments.verbose) {
+            writeWarnings(stderr, responseWithContextWarnings.metadata.warnings);
+        }
+        return 0;
+    }
+    catch (error) {
+        try {
+            await intermediateOutputRecorder?.markFailed(error);
+        }
+        catch (recordingError) {
+            stderr.write(`Warning: Failed to persist failure snapshot: ${formatErrorMessage(recordingError)}\n`);
+        }
+        stderr.write(`Error: ${formatErrorMessage(error)}\n`);
+        return 1;
+    }
+    finally {
+        progressReporter?.stop();
+    }
+}
+function tryApplyHtmlFlag(input) {
+    const { argument, argv, index, state } = input;
+    if (argument === "--html") {
+        state.htmlReportFilePath = readFlagValue({ argv, flag: argument, index });
+        state.shouldWriteHtmlReport = true;
+        return 1;
+    }
+    if (argument === "--no-html") {
+        state.shouldWriteHtmlReport = false;
+        state.htmlReportFilePath = undefined;
+        return 0;
+    }
+    if (argument === "--no-open") {
+        state.shouldOpenHtmlReport = false;
+        return 0;
+    }
+    return -1;
+}
+function readFlagValue(input) {
+    const value = input.argv[input.index + 1];
+    if (value === undefined || value.startsWith("--")) {
+        throw new Error(`Missing value for ${input.flag}`);
+    }
+    return value;
+}
+function parseOutputFormat(input) {
+    switch (input) {
+        case "text": {
+            return input;
+        }
+        case "json": {
+            return input;
+        }
+        case "markdown": {
+            return input;
+        }
+        default: {
+            throw new Error(`Unknown output format: ${input}`);
+        }
+    }
+}
+function assignParsedContext(arguments_, context) {
+    if (context === undefined) {
+        return;
+    }
+    arguments_.context = context;
+}
+function assignParsedContextFilePath(arguments_, contextFilePath) {
+    if (contextFilePath === undefined) {
+        return;
+    }
+    arguments_.contextFilePath = contextFilePath;
+}
+function assignParsedIntermediateOutputFilePath(arguments_, intermediateOutputFilePath) {
+    if (intermediateOutputFilePath === undefined) {
+        return;
+    }
+    arguments_.intermediateOutputFilePath = intermediateOutputFilePath;
+}
+function assignParsedHtmlReportFilePath(arguments_, htmlReportFilePath) {
+    if (htmlReportFilePath === undefined) {
+        return;
+    }
+    arguments_.htmlReportFilePath = htmlReportFilePath;
+}
+function createLoadContextInput(input) {
+    const { cwd, parsedArguments, readFile } = input;
+    const loadContextInput = { cwd };
+    if (parsedArguments.contextFilePath !== undefined) {
+        loadContextInput.contextFilePath = parsedArguments.contextFilePath;
+    }
+    if (parsedArguments.context !== undefined) {
+        loadContextInput.inlineContext = parsedArguments.context;
+    }
+    if (readFile !== undefined) {
+        loadContextInput.readFile = readFile;
+    }
+    return loadContextInput;
+}
+function createTribunalRequest(parsedArguments, loadedContext) {
+    const request = {
+        query: parsedArguments.query,
+        models: parsedArguments.models,
+        reasoning: parsedArguments.reasoning,
+        showPerspectives: parsedArguments.showPerspectives,
+    };
+    if (loadedContext.context !== undefined) {
+        request.context = loadedContext.context;
+    }
+    return request;
+}
+function appendWarnings(response, warnings) {
+    if (warnings.length === 0) {
+        return response;
+    }
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            warnings: [...warnings, ...response.metadata.warnings],
+        },
+    };
+}
+function writeWarnings(stderr, warnings) {
+    for (const warning of warnings) {
+        stderr.write(`Warning: ${warning}\n`);
+    }
+}
+async function createCliIntermediateOutputRecorder(input) {
+    const { cwd, makeDirectory, now, parsedArguments, request, stderr, writeFile } = input;
+    if (!parsedArguments.shouldSaveIntermediates) {
+        return undefined;
+    }
+    const filePath = resolveIntermediateOutputFilePath({ cwd, now, parsedArguments });
+    const recorderInput = { filePath, request };
+    if (makeDirectory !== undefined) {
+        recorderInput.makeDirectory = makeDirectory;
+    }
+    if (writeFile !== undefined) {
+        recorderInput.writeFile = writeFile;
+    }
+    if (now !== undefined) {
+        recorderInput.now = now;
+    }
+    const recorder = await createIntermediateOutputRecorder(recorderInput);
+    stderr.write(`Saving intermediate outputs to ${filePath}\n`);
+    return recorder;
+}
+function resolveIntermediateOutputFilePath(input) {
+    const { cwd, now, parsedArguments } = input;
+    if (parsedArguments.intermediateOutputFilePath !== undefined) {
+        return resolve(cwd, parsedArguments.intermediateOutputFilePath);
+    }
+    if (now === undefined) {
+        return createDefaultIntermediateOutputPath({ cwd });
+    }
+    return createDefaultIntermediateOutputPath({ cwd, now });
+}
+const HTML_REPORT_DIRECTORY = ".tribunal/reports";
+async function writeAndOpenHtmlReport(input) {
+    const { cwd, now, openHtmlReport, parsedArguments, request, response, stderr, writeHtmlReport } = input;
+    if (!parsedArguments.shouldWriteHtmlReport) {
+        return;
+    }
+    const generatedAt = now === undefined ? new Date() : now();
+    const filePath = resolveHtmlReportFilePath({ cwd, generatedAt, parsedArguments });
+    const html = renderHtmlReport({
+        generatedAt,
+        query: request.query,
+        response,
+        ...(request.context === undefined ? {} : { context: request.context }),
+    });
+    const writer = writeHtmlReport ?? defaultWriteHtmlReport;
+    try {
+        await writer(filePath, html);
+        stderr.write(`Wrote HTML report to ${filePath}\n`);
+    }
+    catch (error) {
+        stderr.write(`Warning: Failed to write HTML report: ${formatErrorMessage(error)}\n`);
+        return;
+    }
+    if (!parsedArguments.shouldOpenHtmlReport) {
+        return;
+    }
+    const opener = openHtmlReport ?? defaultOpenHtmlReport;
+    try {
+        await opener(filePath);
+    }
+    catch (error) {
+        stderr.write(`Warning: Failed to open HTML report: ${formatErrorMessage(error)}\n`);
+    }
+}
+function resolveHtmlReportFilePath(input) {
+    const { cwd, generatedAt, parsedArguments } = input;
+    if (parsedArguments.htmlReportFilePath !== undefined) {
+        return resolve(cwd, parsedArguments.htmlReportFilePath);
+    }
+    const timestamp = generatedAt.toISOString().replaceAll(":", "-").replaceAll(".", "-");
+    return resolve(cwd, HTML_REPORT_DIRECTORY, `${timestamp}.html`);
+}
+async function defaultWriteHtmlReport(filePath, html) {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFileToDisk(filePath, html, "utf8");
+}
+async function defaultOpenHtmlReport(filePath) {
+    const { command, args } = getOpenCommand(filePath);
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+        // Swallow spawn errors (e.g., open/xdg-open not installed); the file was still written.
+    });
+    child.unref();
+}
+function getOpenCommand(filePath) {
+    if (process.platform === "darwin") {
+        return { command: "open", args: [filePath] };
+    }
+    if (process.platform === "win32") {
+        return { command: "cmd", args: ["/c", "start", "", filePath] };
+    }
+    return { command: "xdg-open", args: [filePath] };
+}
+function createProgressHandler(input) {
+    const { intermediateOutputRecorder, progressReporter } = input;
+    if (progressReporter === undefined && intermediateOutputRecorder === undefined) {
+        return undefined;
+    }
+    return async (event) => {
+        await progressReporter?.onProgress(event);
+        await intermediateOutputRecorder?.onProgress(event);
+    };
+}
+function createCliProgressReporter(input) {
+    const { intervalMs, stderr } = input;
+    const activeRoles = new Set();
+    let interval;
+    let hasOpenDotLine = false;
+    function onProgress(event) {
+        if (event.status === "started") {
+            activeRoles.add(event.role);
+            writeProgressLine(`Starting ${event.role} (${formatModelSpec(event.model)})...`);
+            startTimer();
+            return;
+        }
+        if (event.status === "completed") {
+            activeRoles.delete(event.role);
+            writeProgressLine(`Finished ${event.role} in ${formatProgressDuration(event.latencyMs)}.`);
+            stopTimerIfIdle();
+            return;
+        }
+        activeRoles.delete(event.role);
+        writeProgressLine(`Failed ${event.role} (${formatModelSpec(event.model)}).`);
+        stopTimerIfIdle();
+    }
+    function startTimer() {
+        if (interval !== undefined) {
+            return;
+        }
+        interval = setInterval(writeProgressTick, intervalMs);
+    }
+    function writeProgressTick() {
+        if (activeRoles.size === 0) {
+            return;
+        }
+        stderr.write(".");
+        hasOpenDotLine = true;
+    }
+    function writeProgressLine(line) {
+        if (hasOpenDotLine) {
+            stderr.write("\n");
+            hasOpenDotLine = false;
+        }
+        stderr.write(`${line}\n`);
+    }
+    function stopTimerIfIdle() {
+        if (activeRoles.size > 0) {
+            return;
+        }
+        stop();
+    }
+    function stop() {
+        if (interval !== undefined) {
+            clearInterval(interval);
+            interval = undefined;
+        }
+        if (!hasOpenDotLine) {
+            return;
+        }
+        stderr.write("\n");
+        hasOpenDotLine = false;
+    }
+    return { onProgress, stop };
+}
+function formatProgressDuration(latencyMs) {
+    if (latencyMs === undefined) {
+        return "unknown duration";
+    }
+    if (latencyMs < 1000) {
+        return `${Math.round(latencyMs)}ms`;
+    }
+    return `${formatSeconds(latencyMs / 1000)}s`;
+}
+function formatSeconds(seconds) {
+    if (seconds < 10) {
+        return seconds.toFixed(1);
+    }
+    return `${Math.round(seconds)}`;
+}
+function formatErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isMainModule(argv, moduleUrl) {
+    const [, entryPoint] = argv;
+    if (entryPoint === undefined) {
+        return false;
+    }
+    return pathToFileURL(resolve(entryPoint)).href === moduleUrl;
+}
+/* v8 ignore next @preserve */
+if (isMainModule(process.argv, import.meta.url)) {
+    process.exitCode = await runCli();
+}
+//# sourceMappingURL=index.js.map