@bergetai/odoo-cli 0.1.0

package/dist/mutation.js

@@ -0,0 +1,605 @@
+/**
+ * Mutation machinery (SPEC §4.4, §4.2, §5.4, §9): building, validating, and
+ * previewing `create`/`update`/`delete` values — and, since Phase 4, applying
+ * them via `create`/`write`/`unlink`. `--dry-run` replaces the final call with
+ * a printed plan.
+ *
+ * The shared engine is module-agnostic: a {@link MutationConfig} declares the
+ * first-class flag→field mapping, resolution references, and exclusions; the
+ * module surface wires it onto `ResourceConfig.mutation`. The CLI registers
+ * the flags and dispatches here.
+ */
+import { readFile } from "node:fs/promises";
+import { conflictError, networkError, notFoundError, usageError, } from "./errors.js";
+import { parseFilterScalar } from "./filter.js";
+import { ModelFields, resolveReference, stageScopeDomain, } from "./model.js";
+import { colorEnabled, printJson, verbose as logVerbose } from "./output.js";
+import { parseId, authenticatedClient, } from "./resource.js";
+import { XmlRpcFaultError } from "./xmlrpc.js";
+const kebab = (option) => option.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+/** read all of stdin as utf8 */
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on("data", (c) => chunks.push(c));
+        process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        process.stdin.on("error", reject);
+    });
+}
+/**
+ * Build the wire-format values dict from first-class flags + --set + --values,
+ * resolving references and validating every field client-side (§9) before any
+ * mutation. `mode === "create"` applies pinned values and checks required flags.
+ */
+export async function buildValues(client, config, spec, opts, mode, globals) {
+    const fieldsMeta = await ModelFields.load(client, config.model);
+    const values = {};
+    const resolved = {};
+    const sourceOf = {};
+    /** option name → resolved record id, for stage scoping lookups */
+    const resolvedByOption = {};
+    const claim = (field, source) => {
+        const prev = sourceOf[field];
+        if (prev === undefined) {
+            sourceOf[field] = source;
+            return;
+        }
+        if (prev === "pinned") {
+            throw usageError(`field "${field}" is pinned by this collection and cannot be overridden`, `remove --${kebab(/* context only */ "")}: the ${config.model.split(".")[0]} surface fixes ${field}`);
+        }
+        throw usageError(`field "${field}" given by both ${prev} and ${source}`, "pass each field exactly once (SPEC §4.2)");
+    };
+    // 1. Pinned create values first (e.g. type=lead). They cannot be overridden
+    //    by any other source — claiming them again is a usage error.
+    if (mode === "create") {
+        for (const [k, v] of Object.entries(spec.createPinnedValues ?? {})) {
+            values[k] = v;
+            sourceOf[k] = "pinned";
+        }
+    }
+    // 2. Exclusive groups (--partner vs --customer-*/--customer-name, §6.3).
+    for (const group of spec.exclusiveGroups ?? []) {
+        const present = group.options.filter((o) => opts[o] !== undefined);
+        if (present.length > 1) {
+            throw usageError(`--${kebab(present[0])} and --${kebab(present[1])} are mutually exclusive`, group.hint ?? "pass at most one");
+        }
+    }
+    // 3. First-class flags in declared order (team before stage so stage scoping
+    //    can reuse the resolved team id, mirrors list filtering, §4.3).
+    for (const flag of spec.flags) {
+        const raw = opts[flag.option];
+        if (raw === undefined)
+            continue;
+        if (flag.multi && (!Array.isArray(raw) || raw.length === 0))
+            continue;
+        // Per-flag mutual exclusions (e.g. --customer-email conflicts with --partner).
+        const pair = (flag.conflictsWith ?? []).find((o) => opts[o] !== undefined);
+        if (pair !== undefined) {
+            throw usageError(`--${kebab(flag.option)} and --${kebab(pair)} are mutually exclusive`, "pass at most one");
+        }
+        const meta = fieldsMeta.get(flag.field);
+        if (!meta) {
+            const flagName = `--${kebab(flag.option)}`;
+            const msg = `${config.model} has no field '${flag.field}' on this instance`;
+            if (flag.reference?.mayBeAbsent) {
+                // §6.3: edition/version-dependent field missing → exit 4 naming the field
+                throw notFoundError("field_not_found", `${msg} — ${flagName} is not available`, `the field is edition/version-dependent (SPEC §6.3)`);
+            }
+            throw usageError(`${msg} — ${flagName} is not available`);
+        }
+        const flagName = `--${kebab(flag.option)}`;
+        if (flag.reference) {
+            const ref = flag.reference;
+            let domain = [];
+            if (ref.scopedBy && ref.scope) {
+                const depId = resolvedByOption[ref.scopedBy];
+                if (depId !== undefined) {
+                    domain = await stageScopeDomain(client, ref.model, ref.scope, depId);
+                }
+            }
+            if (flag.multi) {
+                const pairs = [];
+                for (const input of raw) {
+                    const r = await resolveReference(client, ref.model, input, {
+                        label: ref.label,
+                        domain,
+                        searchFields: ref.searchFields,
+                        exactFields: ref.exactFields,
+                    });
+                    pairs.push([r.id, r.name]);
+                    logVerbose(`resolved ${flagName} "${input}" -> [${r.id}, "${r.name}"]`, globals.verbose);
+                }
+                const ids = pairs.map(([id]) => id);
+                values[flag.field] = [[6, 0, ids]]; // replace-all command
+                resolved[flag.field] = pairs;
+            }
+            else {
+                const r = await resolveReference(client, ref.model, raw, {
+                    label: ref.label,
+                    domain,
+                    searchFields: ref.searchFields,
+                    exactFields: ref.exactFields,
+                });
+                values[flag.field] = r.id;
+                // single m2o: flat [id, name] in the resolved map (x2many stays a list)
+                resolved[flag.field] = [r.id, r.name];
+                resolvedByOption[flag.option] = r.id;
+                logVerbose(`resolved ${flagName} "${raw}" -> [${r.id}, "${r.name}"]`, globals.verbose);
+            }
+        }
+        else {
+            values[flag.field] = flag.parse
+                ? flag.parse(raw, flagName)
+                : raw;
+        }
+        claim(flag.field, flagName);
+    }
+    // 4. --set f=v (repeatable, JSON-scalar values; any field of the model).
+    for (const entry of opts.set ?? []) {
+        const eq = entry.indexOf("=");
+        if (eq <= 0) {
+            throw usageError(`invalid --set ${JSON.stringify(entry)}`, "expected the form field=value");
+        }
+        const field = entry.slice(0, eq);
+        if (!fieldsMeta.get(field)) {
+            // §8: unknown field on the target model → exit 5
+            throw conflictError("unknown_field", `unknown field ${JSON.stringify(field)} on ${config.model}`, `run \`${config.showCommand} <id> --all-fields\` to see available fields`);
+        }
+        if (sourceOf[field] !== undefined) {
+            throw usageError(`field "${field}" given by both ${sourceOf[field]} and --set`, "pass each field exactly once (SPEC §4.2)");
+        }
+        values[field] = parseFilterScalar(entry.slice(eq + 1));
+        sourceOf[field] = "--set";
+    }
+    // 5. --values <file> (JSON object; complex values pass through verbatim).
+    const valuesFile = opts.values;
+    if (valuesFile !== undefined) {
+        const obj = await readValuesFile(valuesFile);
+        for (const [field, v] of Object.entries(obj)) {
+            if (!fieldsMeta.get(field)) {
+                throw conflictError("unknown_field", `unknown field ${JSON.stringify(field)} on ${config.model}`, `run \`${config.showCommand} <id> --all-fields\` to see available fields`);
+            }
+            if (sourceOf[field] !== undefined) {
+                throw usageError(`field "${field}" given by both ${sourceOf[field]} and --values`, "pass each field exactly once (SPEC §4.2)");
+            }
+            values[field] = v;
+            sourceOf[field] = "--values";
+        }
+    }
+    // 6. Required flags on create (checked against the union of all sources).
+    if (mode === "create") {
+        for (const flag of spec.flags) {
+            if (flag.requiredOnCreate && values[flag.field] === undefined) {
+                throw usageError(`missing required --${kebab(flag.option)}`, `--${kebab(flag.option)} (field "${flag.field}") is required to create a ${config.model} record`);
+            }
+        }
+    }
+    return { values, resolved };
+}
+async function readValuesFile(path) {
+    let raw;
+    if (path === "-") {
+        if (process.stdin.isTTY) {
+            throw usageError("--values - expects a JSON object on stdin, but stdin is a TTY", "pipe a JSON object on stdin, e.g. echo '{\"field\": value}' | odoo ... --values -");
+        }
+        raw = await readStdin();
+    }
+    else {
+        try {
+            raw = await readFile(path, "utf8");
+        }
+        catch (cause) {
+            throw usageError(`could not read --values file ${path}: ${cause.code ?? cause.message}`);
+        }
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw usageError(`--values ${path === "-" ? "stdin" : path} is not valid JSON`, "expected a JSON object of field=value pairs");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw usageError("--values must be a JSON object of field=value pairs");
+    }
+    return parsed;
+}
+// ---------------------------------------------------------------------------
+// create
+// ---------------------------------------------------------------------------
+/**
+ * A server-side fault on a mutation (e.g. a constraint violation) is a
+ * conflict (exit 5, SPEC §8); other transport/fault classes stay exit 6.
+ */
+function mutationFault(error, verb) {
+    if (error instanceof XmlRpcFaultError) {
+        throw conflictError("server_fault", `the server rejected the ${verb} (fault ${error.faultCode})`, "retry with --verbose to see the full server response");
+    }
+    throw error;
+}
+/** `odoo <module> <resource> create` (§5.3, §6.3). */
+export async function createCommand(config, opts, globals) {
+    const spec = config.mutation;
+    if (!spec)
+        throw usageError(`${config.model} has no mutation support configured`);
+    const client = await authenticatedClient(globals);
+    const built = await buildValues(client, config, spec, opts, "create", globals);
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({
+                model: config.model,
+                action: "create",
+                dry_run: true,
+                values: built.values,
+                ...(hasResolved(built) ? { resolved: built.resolved } : {}),
+            });
+            return;
+        }
+        process.stdout.write(renderCreatePlan(config, built));
+        return;
+    }
+    let id;
+    try {
+        id = await client.executeKw(config.model, "create", [built.values]);
+    }
+    catch (error) {
+        // §9: the request may have been sent before a transport failure, and the
+        // server does not guarantee idempotent create — tell the caller to
+        // verify before blindly retrying.
+        if (!(error instanceof XmlRpcFaultError) &&
+            error.exitCode === 6) {
+            throw networkError(error.message, "the request reached the server; the record may have been created — verify with list before retrying");
+        }
+        mutationFault(error, "create");
+    }
+    if (typeof id !== "number" || !Number.isInteger(id)) {
+        throw networkError(`unexpected create() response from the server: ${JSON.stringify(id)}`);
+    }
+    if (globals.json) {
+        printJson({
+            model: config.model,
+            action: "create",
+            dry_run: false,
+            id,
+            ...(hasResolved(built) ? { resolved: built.resolved } : {}),
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const line = `Created ${config.model} ${id}`;
+    process.stdout.write((color ? `\x1b[32m${line}\x1b[0m` : line) + "\n");
+}
+// ---------------------------------------------------------------------------
+// update
+// ---------------------------------------------------------------------------
+export async function updateCommand(config, idArgs, opts, globals) {
+    const spec = config.mutation;
+    if (!spec)
+        throw usageError(`${config.model} has no mutation support configured`);
+    const ids = idArgs.map(parseId);
+    const client = await authenticatedClient(globals);
+    const built = await buildValues(client, config, spec, opts, "update", globals);
+    if (Object.keys(built.values).length === 0) {
+        throw usageError("nothing to update", "pass at least one field flag, --set, or --values");
+    }
+    // Read-first pass (§5.4): powers existence check, diff, and no-op detection.
+    const readFields = [
+        ...new Set([...Object.keys(built.values), "display_name"]),
+    ];
+    const rows = (await client.executeKw(config.model, "read", [ids], {
+        fields: readFields,
+    }));
+    const byId = new Map(rows.map((r) => [r.id, r]));
+    const missing = ids.filter((id) => !byId.has(id));
+    if (missing.length > 0) {
+        throw notFoundError("record_not_found", `no ${config.model} record(s) with id(s): ${missing.join(", ")}`, "no records were modified — update aborts the whole batch when any id is missing (SPEC §5.4)");
+    }
+    const fieldsMeta = await ModelFields.load(client, config.model);
+    const diffs = ids.map((id) => {
+        const rec = byId.get(id);
+        const changes = {};
+        for (const [field, after] of Object.entries(built.values)) {
+            const before = rec[field];
+            if (!fieldValuesEqual(fieldsMeta.get(field)?.type, before, after)) {
+                changes[field] = { before, after };
+            }
+        }
+        return { id, display_name: String(rec.display_name ?? id), changes };
+    });
+    if (globals.dryRun) {
+        if (globals.json) {
+            const changes = {};
+            for (const d of diffs)
+                changes[String(d.id)] = d.changes;
+            printJson({
+                model: config.model,
+                action: "update",
+                dry_run: true,
+                ...(hasResolved(built) ? { resolved: built.resolved } : {}),
+                changes,
+            });
+            return;
+        }
+        process.stdout.write(renderUpdatePlan(config, diffs, built));
+        return;
+    }
+    // §5.4: same values on every record are already a no-op per record; only
+    // records with an actual change go into the single atomic write call.
+    const toWrite = diffs.filter((d) => Object.keys(d.changes).length > 0);
+    if (toWrite.length > 0) {
+        const writeIds = toWrite.map((d) => d.id);
+        try {
+            await client.executeKw(config.model, "write", [writeIds, built.values]);
+        }
+        catch (error) {
+            mutationFault(error, "update");
+        }
+    }
+    if (globals.json) {
+        const changes = {};
+        for (const d of diffs)
+            changes[String(d.id)] = d.changes;
+        printJson({
+            model: config.model,
+            action: "update",
+            dry_run: false,
+            ...(hasResolved(built) ? { resolved: built.resolved } : {}),
+            changes,
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const lines = [];
+    for (const d of diffs) {
+        if (Object.keys(d.changes).length === 0) {
+            lines.push(`Unchanged ${config.model} ${d.id}`);
+        }
+        else {
+            const line = `Updated ${config.model} ${d.id}`;
+            lines.push(color ? `\x1b[33m${line}\x1b[0m` : line);
+        }
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+}
+/**
+ * Does the requested value equal the current value? Client-side diff used for
+ * no-op detection (§5.4) — Odoo's `write` returns True whether or not anything
+ * changed, so this diffing is client-side only.
+ */
+function fieldValuesEqual(type, before, after) {
+    if (type === "many2one") {
+        const beforeId = Array.isArray(before) ? before[0] : before;
+        return beforeId === after;
+    }
+    if (type === "many2many" || type === "one2many") {
+        // after is the replace-all command [[6, 0, [ids]]]
+        const afterIds = extractReplaceIds(after);
+        if (afterIds !== undefined) {
+            return setsEqual(before, afterIds);
+        }
+        return JSON.stringify(before) === JSON.stringify(after);
+    }
+    if (before === false && after === false)
+        return true;
+    return before === after;
+}
+function extractReplaceIds(after) {
+    if (Array.isArray(after) &&
+        after.length === 1 &&
+        Array.isArray(after[0]) &&
+        after[0][0] === 6) {
+        return after[0][2];
+    }
+    return undefined;
+}
+function setsEqual(a, b) {
+    const sa = [...(a ?? [])].sort((x, y) => x - y);
+    const sb = [...b].sort((x, y) => x - y);
+    return JSON.stringify(sa) === JSON.stringify(sb);
+}
+// ---------------------------------------------------------------------------
+// delete
+// ---------------------------------------------------------------------------
+export async function deleteCommand(config, idArgs, globals) {
+    const ids = idArgs.map(parseId);
+    // fields_get first: doubles as the module-installed check (§1) so delete on
+    // a Community-only instance reports the model-missing hint, not a raw fault.
+    const client = await authenticatedClient(globals);
+    await ModelFields.load(client, config.model);
+    const rows = (await client.executeKw(config.model, "read", [ids], {
+        fields: ["display_name"],
+    }));
+    const byId = new Map(rows.map((r) => [r.id, r]));
+    const records = ids
+        .filter((id) => byId.has(id))
+        .map((id) => ({
+        id,
+        display_name: String(byId.get(id).display_name ?? id),
+    }));
+    const skipped = ids.filter((id) => !byId.has(id));
+    if (globals.dryRun) {
+        if (globals.json) {
+            printJson({
+                model: config.model,
+                action: "delete",
+                dry_run: true,
+                records,
+                skipped,
+            });
+            return;
+        }
+        process.stdout.write(renderDeletePlan(config, records, skipped));
+        return;
+    }
+    // §4.1: unknown ids are reported as skipped, not errors — delete converges
+    // on retry (the end state "these ids do not exist" is already reached).
+    if (records.length > 0) {
+        try {
+            await client.executeKw(config.model, "unlink", [
+                records.map((r) => r.id),
+            ]);
+        }
+        catch (error) {
+            mutationFault(error, "delete");
+        }
+    }
+    if (globals.json) {
+        printJson({
+            model: config.model,
+            action: "delete",
+            dry_run: false,
+            deleted: records.map((r) => r.id),
+            skipped,
+        });
+        return;
+    }
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const lines = records.map((r) => {
+        const line = `Deleted ${config.model} ${r.id} (${r.display_name})`;
+        return color ? `\x1b[31m${line}\x1b[0m` : line;
+    });
+    if (skipped.length > 0) {
+        lines.push(`Skipped (not found): ${skipped.join(", ")}`);
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+}
+// ---------------------------------------------------------------------------
+// scalar parsers (§9 input validation)
+// ---------------------------------------------------------------------------
+import { parsePriority as priorityParser } from "./resource.js";
+/** Parse a decimal number flag (e.g. --expected-revenue). */
+export function parseDecimal(raw, flagName) {
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        throw usageError(`invalid ${flagName} value ${JSON.stringify(raw)}`, "expected a number");
+    }
+    return n;
+}
+/** Parse a probability in the closed range 0–100 (e.g. --probability). */
+export function parseProbability(raw, flagName) {
+    const n = parseDecimal(raw, flagName);
+    if (n < 0 || n > 100) {
+        throw usageError(`invalid ${flagName} value ${JSON.stringify(raw)}`, "expected a number between 0 and 100");
+    }
+    return n;
+}
+/** Parse a YYYY-MM-DD date flag (e.g. --deadline). */
+export function parseDate(raw, flagName) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+        throw usageError(`invalid ${flagName} value ${JSON.stringify(raw)}`, "expected a date in YYYY-MM-DD format");
+    }
+    return raw;
+}
+/** Parse a --priority flag (§4.5 friendly name → raw Odoo selection value). */
+export const parsePriorityFlag = (raw, flagName) => priorityParser(raw, flagName);
+// ---------------------------------------------------------------------------
+// rendering
+// ---------------------------------------------------------------------------
+function hasResolved(built) {
+    return Object.keys(built.resolved).length > 0;
+}
+/** Render a wire value, annotating resolved references inline (§12). */
+function wire(value) {
+    if (Array.isArray(value))
+        return `[${value.map(wire).join(", ")}]`;
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (value === false || value === null)
+        return String(value);
+    return JSON.stringify(value) ?? String(value);
+}
+function renderCreatePlan(config, built) {
+    const keys = Object.keys(built.values);
+    const width = Math.max(1, ...keys.map((k) => k.length));
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const lines = [
+        `Would create ${config.model}:`,
+        ...keys.map((field) => {
+            const label = `${field}:`.padEnd(width + 2);
+            const annotation = annotationFor(field, built);
+            return `  ${label}${wire(valueWithResolved(field, built))}${annotation}`;
+        }),
+    ];
+    if (color) {
+        lines[0] = `\x1b[32m${lines[0]}\x1b[0m`;
+    }
+    return lines.join("\n") + "\n";
+}
+/** True for a single m2o resolved pair [id, "name"] stored flat. */
+function isFlatPair(x) {
+    return (Array.isArray(x) &&
+        x.length === 2 &&
+        typeof x[0] === "number" &&
+        typeof x[1] === "string");
+}
+/** Normalize a resolved entry to a list of pairs (flat m2o → one pair). */
+function asPairs(entry) {
+    if (entry === undefined)
+        return undefined;
+    if (isFlatPair(entry))
+        return [entry];
+    return entry;
+}
+/**
+ * For rendering, prefer the resolved `[id, "name"]` pair over a bare id (§12).
+ */
+function valueWithResolved(field, built) {
+    const entry = built.resolved[field];
+    const v = built.values[field];
+    if (entry && isFlatPair(entry))
+        return entry;
+    return v;
+}
+function annotationFor(field, built) {
+    const pairs = asPairs(built.resolved[field]);
+    if (!pairs || pairs.length === 0)
+        return "";
+    // only x2many commands get the inline `# [id] = "name"` comment (§12);
+    // a flat m2o pair is rendered inline by valueWithResolved.
+    if (!isTagCommand(built.values[field]))
+        return "";
+    const comment = pairs
+        .map(([id, name]) => `[${id}] = ${JSON.stringify(name)}`)
+        .join(", ");
+    return `   # ${comment}`;
+}
+function isTagCommand(value) {
+    return (Array.isArray(value) &&
+        value.length === 1 &&
+        Array.isArray(value[0]) &&
+        value[0][0] === 6);
+}
+function renderUpdatePlan(config, diffs, built) {
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const lines = [];
+    for (const d of diffs) {
+        if (Object.keys(d.changes).length === 0) {
+            lines.push(`Unchanged ${config.model} ${d.id} (${d.display_name}) — nothing to change`);
+            continue;
+        }
+        const header = `Would update ${config.model} ${d.id} (${d.display_name}):`;
+        lines.push(color ? `\x1b[33m${header}\x1b[0m` : header);
+        for (const [field, change] of Object.entries(d.changes)) {
+            const entry = built.resolved[field];
+            const after = entry && isFlatPair(entry) && !isTagCommand(change.after)
+                ? entry
+                : change.after;
+            lines.push(`  ${field}: ${wire(change.before)} -> ${wire(after)}`);
+        }
+    }
+    return lines.join("\n") + "\n";
+}
+function renderDeletePlan(config, records, skipped) {
+    const color = colorEnabled(false) && process.stdout.isTTY === true;
+    const lines = [];
+    for (const r of records) {
+        const line = `Would delete ${config.model} ${r.id} (${r.display_name})`;
+        lines.push(color ? `\x1b[31m${line}\x1b[0m` : line);
+    }
+    if (skipped.length > 0) {
+        lines.push(`Skipped (not found): ${skipped.join(", ")}`);
+    }
+    return lines.join("\n") + "\n";
+}
+// re-exports of shared helpers the CLI wiring needs
+// (parseId + authenticatedClient imported above)

package/dist/output.js

@@ -0,0 +1,39 @@
+/** True when stdout is a TTY and color is allowed (SPEC §3, §7.2). */
+export function colorEnabled(noColorFlag) {
+    if (noColorFlag)
+        return false;
+    if (process.env.NO_COLOR !== undefined)
+        return false;
+    if (process.env.TERM === "dumb")
+        return false;
+    return process.stdout.isTTY === true;
+}
+/**
+ * Print exactly one JSON object on stdout (SPEC §7.3): pretty-printed when
+ * stdout is a TTY, compact otherwise.
+ */
+export function printJson(value) {
+    const pretty = process.stdout.isTTY === true;
+    process.stdout.write(JSON.stringify(value, null, pretty ? 2 : 0) + "\n");
+}
+export function printError(error, opts) {
+    if (opts.json) {
+        const envelope = {
+            error: {
+                code: error.code,
+                message: error.message,
+                ...(error.hint ? { hint: error.hint } : {}),
+            },
+        };
+        process.stderr.write(JSON.stringify(envelope) + "\n");
+        return;
+    }
+    process.stderr.write(`Error: ${error.message}\n`);
+    if (error.hint) {
+        process.stderr.write(`Hint: ${error.hint}\n`);
+    }
+}
+export function verbose(message, enabled) {
+    if (enabled)
+        process.stderr.write(`${message}\n`);
+}