@mafdet/cli 0.3.0

package/dist/filesystem/workspace.d.ts

@@ -0,0 +1,92 @@
+/** Plan §7.4. */
+export declare const MAX_FILE_BYTES: number;
+export declare const MAX_TOOL_OUTPUT_BYTES: number;
+export declare class WorkspaceError extends Error {
+    readonly exitCode: 5;
+    constructor(message: string);
+}
+export interface ResolvedPath {
+    /** Absolute path on disk, with every symlink already followed. */
+    absolute: string;
+    /** POSIX-separated path relative to the workspace root. */
+    relative: string;
+    exists: boolean;
+}
+export interface FileRead {
+    content: string;
+    /** Content hash at read time; an edit must re-check it before writing. */
+    hash: string;
+    bytes: number;
+}
+/**
+ * The boundary every filesystem tool goes through.
+ *
+ * Containment is decided on *real* paths - the root and the target are both
+ * resolved through `realpath` first - so a symlink or a Windows junction
+ * pointing outside cannot smuggle a path past a string comparison. For a file
+ * that does not exist yet, the nearest existing ancestor is resolved instead,
+ * which is what stops `create_file` from following a symlinked directory out
+ * of the workspace.
+ *
+ * Two Windows behaviours this leans on, verified by reading rather than by
+ * running (no Windows machine here, see the E2.7 note in the plan):
+ * `realpath` resolves junctions and 8.3 short names such as PROGRA~1 to their
+ * long form, and `path.relative` compares case-insensitively on win32, so a
+ * differently-cased path inside the workspace is not mistaken for an escape.
+ */
+export declare class Workspace {
+    readonly root: string;
+    private constructor();
+    static open(root: string): Workspace;
+    /**
+     * Validate a model-supplied path. Throws unless it lands inside the
+     * workspace and is not on the sensitive list.
+     */
+    resolvePath(input: string): ResolvedPath;
+    /** Read a text file, refusing binaries and anything oversized. */
+    readTextFile(input: string): FileRead;
+    /** True when the path is inside and allowed; never throws. */
+    allows(input: string): boolean;
+    private assertInside;
+    /**
+     * realpath the deepest part of the path that exists. A path whose leaf is
+     * missing is normal (creating a file); a path whose *parent* is a symlink
+     * out of the tree is not, and only resolving the ancestor reveals it.
+     */
+    private realpathOfNearestExisting;
+}
+export declare function hashOf(content: Buffer | string): string;
+export interface PlannedEdit {
+    /** Workspace-relative path. */
+    path: string;
+    /** Unified diff of what would change, for the approval prompt. */
+    diff: string;
+    /** Applied only after approval. */
+    apply: () => void;
+}
+/**
+ * Plan an exact-match replacement (plan §7.2).
+ *
+ * The edit is only prepared here; nothing touches the disk until `apply()` is
+ * called, which is what lets an approval prompt sit between the two with no
+ * side effect if the user says no.
+ *
+ * Three conditions, all of which produce a structured error the model can act
+ * on rather than a silent overwrite:
+ *   - the file's content still hashes to what the model read
+ *   - `oldText` occurs exactly once
+ *   - the result actually differs
+ */
+export declare function planEdit(workspace: Workspace, input: {
+    path: string;
+    oldText: string;
+    newText: string;
+    /** Hash from the read that produced `oldText`, when the caller has one. */
+    expectedHash?: string;
+}): PlannedEdit;
+/** Plan a new file. Refuses to touch anything that already exists. */
+export declare function planCreate(workspace: Workspace, input: {
+    path: string;
+    content: string;
+}): PlannedEdit;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/filesystem/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/filesystem/workspace.ts"],"names":[],"mappings":"AAkBA,iBAAiB;AACjB,eAAO,MAAM,cAAc,QAAa,CAAC;AACzC,eAAO,MAAM,qBAAqB,QAAc,CAAC;AAEjD,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,QAAQ,IAAwB;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED,MAAM,WAAW,YAAY;IAC3B,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,SAAS;IACA,QAAQ,CAAC,IAAI,EAAE,MAAM;IAAzC,OAAO;IAEP,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS;IAapC;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY;IAmCxC,kEAAkE;IAClE,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ;IA8BrC,8DAA8D;IAC9D,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAS9B,OAAO,CAAC,YAAY;IAYpB;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;CAuBlC;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAEvD;AAMD,MAAM,WAAW,WAAW;IAC1B,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE;IACL,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GACA,WAAW,CA0Db;AAED,sEAAsE;AACtE,wBAAgB,UAAU,CACxB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACvC,WAAW,CAsBb"}

package/dist/filesystem/workspace.js

@@ -0,0 +1,264 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { unifiedDiff } from "./diff.js";
+import { ExitCode } from "../output/exit-codes.js";
+import { classifySensitivePath } from "./sensitive-files.js";
+/** Plan §7.4. */
+export const MAX_FILE_BYTES = 512 * 1024;
+export const MAX_TOOL_OUTPUT_BYTES = 1024 * 1024;
+export class WorkspaceError extends Error {
+    exitCode = ExitCode.LocalDenied;
+    constructor(message) {
+        super(message);
+        this.name = "WorkspaceError";
+    }
+}
+/**
+ * The boundary every filesystem tool goes through.
+ *
+ * Containment is decided on *real* paths - the root and the target are both
+ * resolved through `realpath` first - so a symlink or a Windows junction
+ * pointing outside cannot smuggle a path past a string comparison. For a file
+ * that does not exist yet, the nearest existing ancestor is resolved instead,
+ * which is what stops `create_file` from following a symlinked directory out
+ * of the workspace.
+ *
+ * Two Windows behaviours this leans on, verified by reading rather than by
+ * running (no Windows machine here, see the E2.7 note in the plan):
+ * `realpath` resolves junctions and 8.3 short names such as PROGRA~1 to their
+ * long form, and `path.relative` compares case-insensitively on win32, so a
+ * differently-cased path inside the workspace is not mistaken for an escape.
+ */
+export class Workspace {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    static open(root) {
+        let real;
+        try {
+            real = realpathSync(resolve(root));
+        }
+        catch {
+            throw new WorkspaceError(`workspace root does not exist: ${root}`);
+        }
+        if (!statSync(real).isDirectory()) {
+            throw new WorkspaceError(`workspace root is not a directory: ${root}`);
+        }
+        return new Workspace(real);
+    }
+    /**
+     * Validate a model-supplied path. Throws unless it lands inside the
+     * workspace and is not on the sensitive list.
+     */
+    resolvePath(input) {
+        if (input.length === 0)
+            throw new WorkspaceError("empty path");
+        // A NUL truncates the path in the OS layer: "a\0/../../etc" opens "a".
+        if (input.includes("\0"))
+            throw new WorkspaceError("path contains a NUL byte");
+        const candidate = isAbsolute(input)
+            ? resolve(input)
+            : resolve(this.root, input);
+        // First pass on the lexical path. Cheap, and rejects the obvious `../..`.
+        this.assertInside(candidate, input);
+        // Second pass on the real path: this is the one that catches symlinks and
+        // junctions, including a link created after the first check would have
+        // passed.
+        const real = this.realpathOfNearestExisting(candidate);
+        this.assertInside(real.path, input);
+        const rel = toPosix(relative(this.root, real.exists ? real.path : candidate));
+        const verdict = classifySensitivePath(rel);
+        if (verdict.denied) {
+            throw new WorkspaceError(`refusing to touch ${rel}: ${verdict.reason}. Authorise that exact path if you really need it.`);
+        }
+        return {
+            absolute: real.exists ? real.path : candidate,
+            relative: rel,
+            exists: real.exists,
+        };
+    }
+    /** Read a text file, refusing binaries and anything oversized. */
+    readTextFile(input) {
+        const target = this.resolvePath(input);
+        if (!target.exists) {
+            throw new WorkspaceError(`no such file: ${target.relative}`);
+        }
+        const stats = statSync(target.absolute);
+        if (stats.isDirectory()) {
+            throw new WorkspaceError(`${target.relative} is a directory`);
+        }
+        if (stats.size > MAX_FILE_BYTES) {
+            throw new WorkspaceError(`${target.relative} is ${stats.size} bytes, over the ${MAX_FILE_BYTES} byte limit`);
+        }
+        const buffer = readFileSync(target.absolute);
+        // A NUL in the first block is the usual signal for a binary; sending one
+        // to a model wastes context and produces nonsense.
+        if (buffer.subarray(0, 8000).includes(0)) {
+            throw new WorkspaceError(`${target.relative} looks like a binary file`);
+        }
+        return {
+            content: buffer.toString("utf8"),
+            hash: hashOf(buffer),
+            bytes: buffer.byteLength,
+        };
+    }
+    /** True when the path is inside and allowed; never throws. */
+    allows(input) {
+        try {
+            this.resolvePath(input);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    assertInside(candidate, original) {
+        const rel = relative(this.root, candidate);
+        const escapes = rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel);
+        // rel === "" means the path IS the root, which is inside.
+        if (escapes) {
+            throw new WorkspaceError(`${original} is outside the workspace (${this.root})`);
+        }
+    }
+    /**
+     * realpath the deepest part of the path that exists. A path whose leaf is
+     * missing is normal (creating a file); a path whose *parent* is a symlink
+     * out of the tree is not, and only resolving the ancestor reveals it.
+     */
+    realpathOfNearestExisting(candidate) {
+        if (existsSync(candidate)) {
+            return { path: realpathSync(candidate), exists: true };
+        }
+        let parent = dirname(candidate);
+        const seen = new Set();
+        while (!existsSync(parent)) {
+            if (seen.has(parent))
+                break;
+            seen.add(parent);
+            const next = dirname(parent);
+            if (next === parent)
+                break;
+            parent = next;
+        }
+        if (!existsSync(parent))
+            return { path: candidate, exists: false };
+        // Re-attach the missing tail to the resolved ancestor.
+        const tail = relative(parent, candidate);
+        return { path: resolve(realpathSync(parent), tail), exists: false };
+    }
+}
+export function hashOf(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function toPosix(value) {
+    return sep === "/" ? value : value.split(sep).join("/");
+}
+/**
+ * Plan an exact-match replacement (plan §7.2).
+ *
+ * The edit is only prepared here; nothing touches the disk until `apply()` is
+ * called, which is what lets an approval prompt sit between the two with no
+ * side effect if the user says no.
+ *
+ * Three conditions, all of which produce a structured error the model can act
+ * on rather than a silent overwrite:
+ *   - the file's content still hashes to what the model read
+ *   - `oldText` occurs exactly once
+ *   - the result actually differs
+ */
+export function planEdit(workspace, input) {
+    const target = workspace.resolvePath(input.path);
+    if (!target.exists)
+        throw new WorkspaceError(`no such file: ${target.relative}`);
+    const current = workspace.readTextFile(input.path);
+    if (input.expectedHash && input.expectedHash !== current.hash) {
+        throw new WorkspaceError(`${target.relative} changed since it was read - read it again before editing`);
+    }
+    // Match against LF text so a model that only ever emits \n still works on a
+    // CRLF file; the original ending is restored on write.
+    const eol = detectEol(current.content);
+    const normalised = eol === "\r\n" ? current.content.split("\r\n").join("\n") : current.content;
+    const oldText = normaliseEol(input.oldText);
+    const newText = normaliseEol(input.newText);
+    if (oldText.length === 0)
+        throw new WorkspaceError("old_text must not be empty");
+    const occurrences = countOccurrences(normalised, oldText);
+    if (occurrences === 0) {
+        throw new WorkspaceError(`old_text was not found in ${target.relative} - read the file again and quote it exactly`);
+    }
+    if (occurrences > 1) {
+        throw new WorkspaceError(`old_text appears ${occurrences} times in ${target.relative} - include enough surrounding lines to make it unique`);
+    }
+    const updated = normalised.replace(oldText, () => newText);
+    if (updated === normalised)
+        throw new WorkspaceError("the edit would change nothing");
+    const diff = unifiedDiff(normalised, updated, { path: target.relative });
+    const onDisk = eol === "\r\n" ? updated.split("\n").join("\r\n") : updated;
+    const mode = statSync(target.absolute).mode;
+    return {
+        path: target.relative,
+        diff,
+        apply: () => {
+            // Re-check immediately before writing: the approval prompt is a window
+            // in which something else could have touched the file.
+            const latest = workspace.readTextFile(input.path);
+            if (latest.hash !== current.hash) {
+                throw new WorkspaceError(`${target.relative} changed while waiting for approval - nothing was written`);
+            }
+            atomicWrite(target.absolute, onDisk, mode);
+        },
+    };
+}
+/** Plan a new file. Refuses to touch anything that already exists. */
+export function planCreate(workspace, input) {
+    const target = workspace.resolvePath(input.path);
+    if (target.exists) {
+        throw new WorkspaceError(`${target.relative} already exists - use edit_file to change it`);
+    }
+    const diff = unifiedDiff("", input.content, { path: target.relative });
+    return {
+        path: target.relative,
+        diff,
+        apply: () => {
+            if (existsSync(target.absolute)) {
+                throw new WorkspaceError(`${target.relative} appeared while waiting for approval - nothing was written`);
+            }
+            mkdirSync(dirname(target.absolute), { recursive: true });
+            atomicWrite(target.absolute, input.content);
+        },
+    };
+}
+/** Same-directory temp file plus rename, so a reader never sees a half file. */
+function atomicWrite(absolute, content, mode) {
+    const temp = join(dirname(absolute), `.mafdet-${process.pid}-${Date.now()}.tmp`);
+    try {
+        writeFileSync(temp, content, mode === undefined ? undefined : { mode });
+        renameSync(temp, absolute);
+    }
+    catch (error) {
+        try {
+            unlinkSync(temp);
+        }
+        catch {
+            // Never created; nothing to remove.
+        }
+        throw new WorkspaceError(`cannot write ${absolute}: ${error.message}`);
+    }
+}
+function detectEol(content) {
+    return content.includes("\r\n") ? "\r\n" : "\n";
+}
+function normaliseEol(value) {
+    return value.includes("\r\n") ? value.split("\r\n").join("\n") : value;
+}
+function countOccurrences(haystack, needle) {
+    let count = 0;
+    let index = haystack.indexOf(needle);
+    while (index !== -1) {
+        count += 1;
+        index = haystack.indexOf(needle, index + needle.length);
+    }
+    return count;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { ExitCode } from "./output/exit-codes.js";
+export declare function run(argv: readonly string[]): Promise<ExitCode>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAcA,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AA+ClD,wBAAsB,GAAG,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CA4DpE"}

package/dist/index.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { accountCommand } from "./commands/account.js";
+import { agentCommand } from "./commands/agent.js";
+import { chatCommand } from "./commands/chat.js";
+import { configCommand } from "./commands/config.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { embedCommand } from "./commands/embed.js";
+import { speechCommand } from "./commands/speech.js";
+import { modelsCommand } from "./commands/models.js";
+import { ExitCode } from "./output/exit-codes.js";
+// Read from the installed package rather than baking a literal in at build
+// time, so `mafdet --version` can never disagree with what npm installed.
+function version() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(join(here, "..", "package.json"), "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+}
+// Only commands that actually work are listed. The CLI never advertises a
+// surface it cannot serve — a user copying from --help must not hit a stub.
+const HELP = `mafdet - Mafdet AI command line
+
+Usage:
+  mafdet <command> [options]
+
+Commands:
+  agent             Inspect the workspace with a model (read-only)
+  chat              Send a prompt to a model
+  embed             Turn text into a vector
+  speech            Turn text into an audio file
+  models list       List the models this key can call
+  models show       Describe one model
+  account balance   Wallet balance and bonus
+  account usage     Requests, tokens and spend over a window
+  account subscription  Current plan and Playground allowance
+  config list       Show the resolved settings and where each came from
+  doctor            Check key, endpoints, model, balance and workspace
+  help              Show this help
+  version           Print the version
+
+Options:
+  -h, --help        Show this help
+  -v, --version     Print the version
+
+Docs: https://docs.mafdet.ai
+`;
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+}
+export async function run(argv) {
+    const [command] = argv;
+    if (command === undefined) {
+        // Not an error the user asked for, but not a result either: usage goes to
+        // stderr so a bare `mafdet` in a pipeline never pollutes stdout.
+        process.stderr.write(HELP);
+        return ExitCode.Usage;
+    }
+    if (command === "help" || command === "--help" || command === "-h") {
+        process.stdout.write(HELP);
+        return ExitCode.Ok;
+    }
+    if (command === "version" || command === "--version" || command === "-v") {
+        process.stdout.write(`${version()}\n`);
+        return ExitCode.Ok;
+    }
+    const io = {
+        stdout: (text) => process.stdout.write(text),
+        stderr: (text) => process.stderr.write(text),
+        version: version(),
+    };
+    if (command === "agent") {
+        const controller = new AbortController();
+        process.on("SIGINT", () => controller.abort());
+        return agentCommand(argv.slice(1), { ...io, signal: controller.signal });
+    }
+    if (command === "chat") {
+        // Ctrl+C must close the connection, not just stop printing: closing it is
+        // what tells the gateway to stop generating.
+        const controller = new AbortController();
+        process.on("SIGINT", () => controller.abort());
+        return chatCommand(argv.slice(1), {
+            ...io,
+            signal: controller.signal,
+            readStdin: readStdin,
+        });
+    }
+    if (command === "embed") {
+        return embedCommand(argv.slice(1), { ...io, readStdin });
+    }
+    if (command === "speech") {
+        return speechCommand(argv.slice(1), { ...io, readStdin });
+    }
+    if (command === "doctor")
+        return doctorCommand(argv.slice(1), io);
+    if (command === "config")
+        return configCommand(argv.slice(1), io);
+    if (command === "models")
+        return modelsCommand(argv.slice(1), io);
+    if (command === "account")
+        return accountCommand(argv.slice(1), io);
+    process.stderr.write(`mafdet: unknown command '${command}'\nRun 'mafdet help' to see available commands.\n`);
+    return ExitCode.Usage;
+}
+process.exitCode = await run(process.argv.slice(2));

package/dist/output/exit-codes.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Process exit codes. Published contract (plan §4.5): scripts branch on these,
+ * so a value never changes meaning once released — new failure kinds get a new
+ * code or reuse the closest existing one.
+ */
+export declare const ExitCode: {
+    /** Completed. */
+    readonly Ok: 0;
+    /** Something failed that has no more specific code. */
+    readonly General: 1;
+    /** The command line or the configuration is wrong. */
+    readonly Usage: 2;
+    /** The key is missing, invalid, or not permitted to do this. */
+    readonly Auth: 3;
+    /** The model or the API could not serve the request. */
+    readonly Unavailable: 4;
+    /** A local file or command was refused by the permission model. */
+    readonly LocalDenied: 5;
+    /** The user cancelled (Ctrl+C, or declined an approval). */
+    readonly Cancelled: 6;
+    /** A cost, time, or loop ceiling stopped the run. */
+    readonly LimitReached: 7;
+};
+export type ExitCode = (typeof ExitCode)[keyof typeof ExitCode];
+//# sourceMappingURL=exit-codes.d.ts.map

package/dist/output/exit-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit-codes.d.ts","sourceRoot":"","sources":["../../src/output/exit-codes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,QAAQ;IACnB,iBAAiB;;IAEjB,uDAAuD;;IAEvD,sDAAsD;;IAEtD,gEAAgE;;IAEhE,wDAAwD;;IAExD,mEAAmE;;IAEnE,4DAA4D;;IAE5D,qDAAqD;;CAE7C,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAC"}

package/dist/output/exit-codes.js

@@ -0,0 +1,23 @@
+/**
+ * Process exit codes. Published contract (plan §4.5): scripts branch on these,
+ * so a value never changes meaning once released — new failure kinds get a new
+ * code or reuse the closest existing one.
+ */
+export const ExitCode = {
+    /** Completed. */
+    Ok: 0,
+    /** Something failed that has no more specific code. */
+    General: 1,
+    /** The command line or the configuration is wrong. */
+    Usage: 2,
+    /** The key is missing, invalid, or not permitted to do this. */
+    Auth: 3,
+    /** The model or the API could not serve the request. */
+    Unavailable: 4,
+    /** A local file or command was refused by the permission model. */
+    LocalDenied: 5,
+    /** The user cancelled (Ctrl+C, or declined an approval). */
+    Cancelled: 6,
+    /** A cost, time, or loop ceiling stopped the run. */
+    LimitReached: 7,
+};

package/dist/output/format.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Rendering for query commands. Three shapes, one rule: stdout carries the
+ * result and nothing else, so `mafdet ... --json | jq` is always valid.
+ */
+export type OutputFormat = "table" | "plain" | "json";
+export interface FormatFlags {
+    format: OutputFormat;
+    /** Arguments left over after the known flags were consumed. */
+    rest: string[];
+}
+/** `--json` and `--plain` are mutually exclusive; table is the default. */
+export declare function parseFormatFlags(argv: readonly string[]): FormatFlags;
+/** One complete JSON document, newline-terminated. */
+export declare function renderJson(value: unknown): string;
+export interface Column<T> {
+    header: string;
+    value: (row: T) => string;
+    /** Right-align numeric columns so they can be scanned down. */
+    align?: "left" | "right";
+}
+export declare function renderTable<T>(rows: readonly T[], columns: readonly Column<T>[]): string;
+/**
+ * Tab-separated, no header, no padding: the shape `cut`, `awk` and `while read`
+ * expect. Stable across releases, unlike the table.
+ */
+export declare function renderPlain<T>(rows: readonly T[], columns: readonly Column<T>[]): string;
+export declare function renderRecord(entries: readonly (readonly [string, string])[]): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/output/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/output/format.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,YAAY,CAAC;IACrB,+DAA+D;IAC/D,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CAiBrE;AAED,sDAAsD;AACtD,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEjD;AAED,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B;AAED,wBAAgB,WAAW,CAAC,CAAC,EAC3B,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,OAAO,EAAE,SAAS,MAAM,CAAC,CAAC,CAAC,EAAE,GAC5B,MAAM,CAoBR;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,OAAO,EAAE,SAAS,MAAM,CAAC,CAAC,CAAC,EAAE,GAC5B,MAAM,CAOR;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,GAC9C,MAAM,CAOR"}

package/dist/output/format.js

@@ -0,0 +1,56 @@
+/**
+ * Rendering for query commands. Three shapes, one rule: stdout carries the
+ * result and nothing else, so `mafdet ... --json | jq` is always valid.
+ */
+/** `--json` and `--plain` are mutually exclusive; table is the default. */
+export function parseFormatFlags(argv) {
+    const rest = [];
+    let format = "table";
+    let chosen;
+    for (const arg of argv) {
+        if (arg === "--json" || arg === "--plain") {
+            if (chosen && chosen !== arg) {
+                throw new Error(`${chosen} and ${arg} cannot be combined`);
+            }
+            chosen = arg;
+            format = arg === "--json" ? "json" : "plain";
+            continue;
+        }
+        rest.push(arg);
+    }
+    return { format, rest };
+}
+/** One complete JSON document, newline-terminated. */
+export function renderJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+export function renderTable(rows, columns) {
+    if (rows.length === 0)
+        return "";
+    const cells = rows.map((row) => columns.map((column) => column.value(row)));
+    const widths = columns.map((column, i) => Math.max(column.header.length, ...cells.map((row) => row[i].length)));
+    const line = (values) => values
+        .map((value, i) => columns[i].align === "right"
+        ? value.padStart(widths[i])
+        : value.padEnd(widths[i]))
+        .join("  ")
+        .trimEnd();
+    return ([line(columns.map((c) => c.header)), ...cells.map(line)].join("\n") + "\n");
+}
+/**
+ * Tab-separated, no header, no padding: the shape `cut`, `awk` and `while read`
+ * expect. Stable across releases, unlike the table.
+ */
+export function renderPlain(rows, columns) {
+    if (rows.length === 0)
+        return "";
+    return (rows
+        .map((row) => columns.map((column) => column.value(row)).join("\t"))
+        .join("\n") + "\n");
+}
+export function renderRecord(entries) {
+    const width = Math.max(...entries.map(([label]) => label.length));
+    return (entries
+        .map(([label, value]) => `${label.padEnd(width)}  ${value}`)
+        .join("\n") + "\n");
+}

package/dist/output/money.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Money never becomes a JavaScript number.
+ *
+ * The API speaks integer micro-USD as decimal strings, and 0.1 + 0.2 is the
+ * reason: a float round-trip can turn a balance into a number that does not
+ * match the invoice. Everything here is BigInt in, string out.
+ */
+export declare function parseMicroUsd(value: string | number | bigint): bigint;
+/**
+ * Render micro-USD as dollars. `minimumFractionDigits` keeps small amounts
+ * readable ($0.00 is wrong for 1 µ$, so tiny values keep their precision).
+ */
+export declare function formatUsd(microUsd: string | number | bigint, options?: {
+    minFractionDigits?: number;
+}): string;
+//# sourceMappingURL=money.d.ts.map

package/dist/output/money.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"money.d.ts","sourceRoot":"","sources":["../../src/output/money.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAOrE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,GAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAO,GAC3C,MAAM,CAeR"}