@wafflebase/cli 0.4.8 → 0.5.0

package/dist/docs/import.js

@@ -1,146 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { basename, extname } from 'node:path';
-import { createInterface } from 'node:readline';
-import { importDocx, InvalidDocxError } from './docx-import.js';
-export const defaultImportIO = {
-    stdout: (line) => {
-        process.stdout.write(line);
-        if (!line.endsWith('\n'))
-            process.stdout.write('\n');
-    },
-    stderr: (line) => {
-        console.error(line);
-    },
-    readBytes: async (path) => {
-        if (path === '-') {
-            return new Promise((resolve, reject) => {
-                const chunks = [];
-                process.stdin.on('data', (c) => chunks.push(c));
-                process.stdin.on('end', () => resolve(new Uint8Array(Buffer.concat(chunks))));
-                process.stdin.on('error', reject);
-            });
-        }
-        return new Uint8Array(readFileSync(path));
-    },
-    confirm: (prompt) => {
-        return new Promise((resolve) => {
-            const rl = createInterface({ input: process.stdin, output: process.stderr });
-            rl.question(prompt, (answer) => {
-                rl.close();
-                const a = answer.trim().toLowerCase();
-                resolve(a === 'y' || a === 'yes');
-            });
-        });
-    },
-    isTTY: process.stdin.isTTY ?? false,
-};
-/**
- * Pure orchestration for `docs import`. Reads the source `.docx`,
- * parses it into a `Document`, then either creates a new document
- * (default) or overwrites an existing one (`--replace`).
- *
- * Why split out from the command action: the action's layered handling
- * of stdin / TTY / interactive prompt is the easiest path to test
- * regressions in. Mocking `process.stdin` at the harness level is
- * fragile; passing in an `ImportIO` lets us drive every branch
- * deterministically.
- */
-export async function runDocsImport(args, client, io = defaultImportIO) {
-    const { file, replace, yes = false, imageUploader, quiet = false, dryRun = false } = args;
-    const inferredTitle = args.title ?? defaultTitleFor(file);
-    if (replace) {
-        // `--replace` is destructive: confirm interactively unless `--yes`.
-        if (!yes) {
-            if (!io.isTTY) {
-                io.stderr(JSON.stringify({
-                    error: {
-                        code: 'CONFIRMATION_REQ',
-                        message: `Pass --yes to confirm replacing document "${replace}".`,
-                    },
-                }, null, 2));
-                return { exitCode: 1 };
-            }
-            const ok = await io.confirm(`This will replace content of ${replace}. Continue? [y/N] `);
-            if (!ok) {
-                if (!quiet)
-                    io.stderr('Aborted.');
-                return { exitCode: 0 };
-            }
-        }
-        const buf = await io.readBytes(file);
-        const parsed = await safeImportDocx(buf, imageUploader, io);
-        if (parsed === null)
-            return { exitCode: 1 };
-        const doc = parsed;
-        if (dryRun) {
-            io.stdout(JSON.stringify({ method: 'PUT', path: `/documents/${replace}/content`, body: doc }, null, 2));
-            return { exitCode: 0 };
-        }
-        const res = await client.putDocContent(replace, doc);
-        if (!res.ok) {
-            io.stderr(JSON.stringify(res.data ?? { error: { code: 'HTTP_ERROR' } }, null, 2));
-            return { exitCode: 1 };
-        }
-        io.stdout(JSON.stringify({ id: replace, replaced: true }, null, 2));
-        return { exitCode: 0 };
-    }
-    // Default flow: POST + PUT.
-    const buf = await io.readBytes(file);
-    const parsedNew = await safeImportDocx(buf, imageUploader, io);
-    if (parsedNew === null)
-        return { exitCode: 1 };
-    const doc = parsedNew;
-    if (dryRun) {
-        io.stdout(JSON.stringify({
-            method: 'POST',
-            path: '/documents',
-            body: { title: inferredTitle, type: 'doc' },
-            followUp: { method: 'PUT', path: '/documents/<new-id>/content' },
-        }, null, 2));
-        return { exitCode: 0 };
-    }
-    const created = await client.createDocument(inferredTitle, 'doc');
-    if (!created.ok) {
-        io.stderr(JSON.stringify(created.data ?? { error: { code: 'HTTP_ERROR' } }, null, 2));
-        return { exitCode: 1 };
-    }
-    const newId = created.data?.id;
-    if (!newId) {
-        io.stderr(JSON.stringify({ error: { code: 'INVALID_RESPONSE', message: 'Server did not return an id' } }, null, 2));
-        return { exitCode: 1 };
-    }
-    const put = await client.putDocContent(newId, doc);
-    if (!put.ok) {
-        io.stderr(JSON.stringify(put.data ?? { error: { code: 'HTTP_ERROR' } }, null, 2));
-        return { exitCode: 1 };
-    }
-    io.stdout(JSON.stringify({ id: newId, title: inferredTitle }, null, 2));
-    return { exitCode: 0 };
-}
-/** Strip the directory and extension to produce a default doc title. */
-function defaultTitleFor(file) {
-    if (file === '-')
-        return 'Untitled';
-    return basename(file, extname(file)) || 'Untitled';
-}
-/**
- * Run `importDocx` and turn `InvalidDocxError` into a structured
- * stderr body + `null` return so callers can short-circuit with
- * `exitCode: 1` while keeping the rest of the error envelope
- * (`HTTP_ERROR`, `INVALID_RESPONSE`, etc.) consistent. The action's
- * `outputError` would technically also surface the error code today
- * (post-B1), but catching here keeps the contract local to this file
- * and matches every other failure path in `runDocsImport`.
- */
-async function safeImportDocx(buf, imageUploader, io) {
-    try {
-        return await importDocx(buf, { imageUploader });
-    }
-    catch (e) {
-        if (e instanceof InvalidDocxError) {
-            io.stderr(JSON.stringify({ error: { code: e.code, message: e.message } }, null, 2));
-            return null;
-        }
-        throw e;
-    }
-}

package/dist/docs/page-range.d.ts

@@ -1,29 +0,0 @@
-/**
- * Resolved page selection produced by {@link parsePageRange}.
- *
- * `pages` is the deduplicated set of 1-based page numbers requested by
- * the user, after clamping to the document's actual page count.
- *
- * `warnings` collects clamp/duplicate notices the caller should emit to
- * stderr (parsing succeeded; the user just asked for pages that don't
- * exist). Hard errors throw instead — see {@link parsePageRange}.
- */
-export interface PageRange {
-    pages: ReadonlySet<number>;
-    warnings: ReadonlyArray<string>;
-}
-/**
- * Parse a `--pages` flag value (e.g., `"1-3,5,7-9"`) against a known
- * page count.
- *
- * Throws `Error` on malformed input — empty strings, non-numeric tokens,
- * a `0` page (1-based), or a reversed range (`"3-1"`). Out-of-range
- * upper bounds are *not* errors: they get clamped to `totalPages` with a
- * stderr-bound warning string in the result. Tokens whose entire range
- * sits past `totalPages` collapse to no pages with a warning, never an
- * error — this lets `--pages 1-99` work on a 3-page doc.
- *
- * `totalPages` of 0 is a valid input (empty doc) and yields an empty set
- * with a single "document has no pages" warning, regardless of input.
- */
-export declare function parsePageRange(input: string, totalPages: number): PageRange;

package/dist/docs/page-range.js

@@ -1,74 +0,0 @@
-const SINGLE = /^\d+$/;
-const RANGE = /^(\d+)-(\d+)$/;
-/**
- * Parse a `--pages` flag value (e.g., `"1-3,5,7-9"`) against a known
- * page count.
- *
- * Throws `Error` on malformed input — empty strings, non-numeric tokens,
- * a `0` page (1-based), or a reversed range (`"3-1"`). Out-of-range
- * upper bounds are *not* errors: they get clamped to `totalPages` with a
- * stderr-bound warning string in the result. Tokens whose entire range
- * sits past `totalPages` collapse to no pages with a warning, never an
- * error — this lets `--pages 1-99` work on a 3-page doc.
- *
- * `totalPages` of 0 is a valid input (empty doc) and yields an empty set
- * with a single "document has no pages" warning, regardless of input.
- */
-export function parsePageRange(input, totalPages) {
-    if (totalPages < 0) {
-        throw new Error(`parsePageRange: totalPages must be ≥ 0, got ${totalPages}`);
-    }
-    const trimmed = input.trim();
-    if (trimmed === '') {
-        throw new Error('Page range is empty.');
-    }
-    const tokens = trimmed.split(',').map((t) => t.trim());
-    for (const tok of tokens) {
-        if (tok === '') {
-            throw new Error(`Empty token in page range "${input}"`);
-        }
-    }
-    const pages = new Set();
-    const warnings = [];
-    if (totalPages === 0) {
-        warnings.push('Document has no pages.');
-        return { pages, warnings };
-    }
-    for (const tok of tokens) {
-        if (SINGLE.test(tok)) {
-            const n = Number(tok);
-            if (n < 1) {
-                throw new Error(`Page numbers are 1-based; got "${tok}"`);
-            }
-            if (n > totalPages) {
-                warnings.push(`Page ${n} is beyond document end (${totalPages}); ignored.`);
-                continue;
-            }
-            pages.add(n);
-            continue;
-        }
-        const m = RANGE.exec(tok);
-        if (!m) {
-            throw new Error(`Invalid page token "${tok}" in "${input}"`);
-        }
-        const lo = Number(m[1]);
-        const hi = Number(m[2]);
-        if (lo < 1 || hi < 1) {
-            throw new Error(`Page numbers are 1-based; got "${tok}"`);
-        }
-        if (lo > hi) {
-            throw new Error(`Reversed range "${tok}" — start must be ≤ end.`);
-        }
-        if (lo > totalPages) {
-            warnings.push(`Range ${tok} starts beyond document end (${totalPages}); ignored.`);
-            continue;
-        }
-        const clampedHi = Math.min(hi, totalPages);
-        if (clampedHi < hi) {
-            warnings.push(`Range ${tok} clamped to ${lo}-${clampedHi} (document has ${totalPages} pages).`);
-        }
-        for (let p = lo; p <= clampedHi; p++)
-            pages.add(p);
-    }
-    return { pages, warnings };
-}

package/dist/docs/page-slice.d.ts

@@ -1,45 +0,0 @@
-import type { Block, BlockPageMeta, Document, PaginatedLayout } from '@wafflebase/docs';
-import type { PageRange } from './page-range.js';
-/**
- * Output formats supported by the CLI's `docs content --pages` flow.
- *
- * `'json'` keeps full structural fidelity and triggers `pageMeta`
- * emission so consumers can recover page boundaries without re-running
- * pagination. `'md'` and `'text'` drop the metadata since the
- * serializers themselves are page-blind — block selection alone is
- * enough.
- */
-export type SliceFormat = 'json' | 'md' | 'text';
-export interface PageSliceResult {
-    /**
-     * Subset of `doc.blocks` whose layout lines intersect the requested
-     * pages, in original document order. A block that spans multiple
-     * requested pages appears exactly once.
-     */
-    blocks: Block[];
-    /**
-     * Per-block 1-based page indices for the included blocks. Present
-     * only when `format === 'json'` so the JSON serializer's `_pageMeta`
-     * field stays accurate after slicing. Always in the same order as
-     * `blocks`.
-     */
-    pageMeta?: BlockPageMeta[];
-}
-/**
- * Select the blocks of `doc` that participate in any of the pages named
- * by `range`, optionally producing per-block page metadata for the JSON
- * format. Block ordering matches `doc.blocks` — the slicer never
- * reorders content, only filters it.
- *
- * Selection rule (per `docs/design/docs-cli.md` §5.2): include any block
- * whose layout has at least one line on a requested page. Blocks emit
- * whole — there is no mid-block cut. A block that straddles the
- * boundary between a requested page and a non-requested one still
- * appears in the result, in full.
- *
- * Blocks with no layout lines (e.g., zero-height collapsed blocks the
- * paginator omitted) drop out entirely; if a future block type needs
- * "always include" semantics, the caller should pre-tag those blocks
- * before calling this function.
- */
-export declare function sliceBlocksByPages(doc: Document, layout: PaginatedLayout, range: PageRange, format: SliceFormat): PageSliceResult;

package/dist/docs/page-slice.js

@@ -1,61 +0,0 @@
-/**
- * Select the blocks of `doc` that participate in any of the pages named
- * by `range`, optionally producing per-block page metadata for the JSON
- * format. Block ordering matches `doc.blocks` — the slicer never
- * reorders content, only filters it.
- *
- * Selection rule (per `docs/design/docs-cli.md` §5.2): include any block
- * whose layout has at least one line on a requested page. Blocks emit
- * whole — there is no mid-block cut. A block that straddles the
- * boundary between a requested page and a non-requested one still
- * appears in the result, in full.
- *
- * Blocks with no layout lines (e.g., zero-height collapsed blocks the
- * paginator omitted) drop out entirely; if a future block type needs
- * "always include" semantics, the caller should pre-tag those blocks
- * before calling this function.
- */
-export function sliceBlocksByPages(doc, layout, range, format) {
-    const wantedPages = range.pages;
-    // Group all line pageIndices by blockIndex so we can both decide
-    // inclusion and reuse the lookup for `pageMeta`. Walking pages in
-    // order keeps the per-block `lines` list in document order.
-    //
-    // Duplicates are intentional: `BlockPageMeta.lines` is contractually
-    // "one entry per layout line, in order" — a block with three lines
-    // all on page 1 yields `[1, 1, 1]`. See `serialize/json.ts` for the
-    // canonical contract; the consumer is meant to count entries to
-    // recover the per-block line count, not treat the array as a set.
-    const linesByBlock = new Map();
-    for (const page of layout.pages) {
-        for (const pl of page.lines) {
-            const bucket = linesByBlock.get(pl.blockIndex);
-            if (bucket)
-                bucket.push(pl.pageIndex);
-            else
-                linesByBlock.set(pl.blockIndex, [pl.pageIndex]);
-        }
-    }
-    const blocks = [];
-    const pageMeta = [];
-    for (let i = 0; i < doc.blocks.length; i++) {
-        const lines = linesByBlock.get(i);
-        if (!lines || lines.length === 0)
-            continue;
-        let intersects = false;
-        for (const p of lines) {
-            if (wantedPages.has(p)) {
-                intersects = true;
-                break;
-            }
-        }
-        if (!intersects)
-            continue;
-        const block = doc.blocks[i];
-        blocks.push(block);
-        if (format === 'json') {
-            pageMeta.push({ blockId: block.id, lines });
-        }
-    }
-    return format === 'json' ? { blocks, pageMeta } : { blocks };
-}

package/dist/docs/paginate.d.ts

@@ -1,13 +0,0 @@
-import { type Document, type PaginatedLayout, type TextMeasurer } from '@wafflebase/docs';
-/**
- * Run `computeLayout` + `paginateLayout` for a fetched `Document` using
- * the supplied measurer. The CLI calls this only when `--pages` is set
- * (or any other flag that needs page boundaries) — the bare `docs
- * content` JSON path skips pagination entirely.
- *
- * Page setup falls back to `DEFAULT_PAGE_SETUP` (US Letter portrait, 1in
- * margins) when the document doesn't carry one. Content width is the
- * effective page width minus left/right margins, matching what the
- * editor's `DocCanvas` computes.
- */
-export declare function paginateForCli(doc: Document, measurer: TextMeasurer): PaginatedLayout;

package/dist/docs/paginate.js

@@ -1,19 +0,0 @@
-import { computeLayout, paginateLayout, resolvePageSetup, getEffectiveDimensions, } from '@wafflebase/docs';
-/**
- * Run `computeLayout` + `paginateLayout` for a fetched `Document` using
- * the supplied measurer. The CLI calls this only when `--pages` is set
- * (or any other flag that needs page boundaries) — the bare `docs
- * content` JSON path skips pagination entirely.
- *
- * Page setup falls back to `DEFAULT_PAGE_SETUP` (US Letter portrait, 1in
- * margins) when the document doesn't carry one. Content width is the
- * effective page width minus left/right margins, matching what the
- * editor's `DocCanvas` computes.
- */
-export function paginateForCli(doc, measurer) {
-    const pageSetup = resolvePageSetup(doc.pageSetup);
-    const { width: paperWidth } = getEffectiveDimensions(pageSetup);
-    const contentWidth = paperWidth - pageSetup.margins.left - pageSetup.margins.right;
-    const { layout } = computeLayout(doc.blocks, measurer, contentWidth);
-    return paginateLayout(layout, pageSetup);
-}

package/dist/docs/pdf-export.d.ts

@@ -1,47 +0,0 @@
-import { type Document, type DocxImageFetcher, type PdfFontsOptions } from '@wafflebase/docs';
-import type { PageRange } from './page-range.js';
-/**
- * Options for the CLI PDF export pipeline.
- *
- * `pages` is the resolved selection from `parsePageRange`; when present
- * we render the full PDF first and then strip non-selected pages via
- * `pdf-lib` (cheaper than re-implementing a partial paint path inside
- * `PdfExporter`). The future plan is to push a `pageIndices` option
- * down into `PdfExporter` itself; for now the post-process is correct
- * but pays for layout/paint work it then throws away.
- *
- * `fontSources` lets tests inject in-memory buffers via `PdfFonts` so
- * `exportPdf` can run without hitting jsdelivr.
- */
-export interface CliPdfExportOptions {
-    pages?: PageRange;
-    /** Currently informational — `PdfExporter` always paints
-     *  header/footer when `doc.header`/`doc.footer` are present. The CLI
-     *  surfaces the flag for parity with `docs export --include-header-footer`
-     *  and to leave room for a future "strip header/footer" mode. */
-    includeHeaderFooter?: boolean;
-    fontSources?: PdfFontsOptions['sources'];
-    /** Resolve and download image inlines so they can be embedded in the
-     *  PDF. Required when the document contains image inlines —
-     *  `PdfExporter` throws otherwise to avoid silently dropping content.
-     *  The CLI command builds one via `createImageFetcher` from the
-     *  configured server base; tests inject a stub that returns
-     *  in-memory bytes. Typed as `DocxImageFetcher` (a structural
-     *  `(url) => Promise<Blob>` alias) since the bare `ImageFetcher`
-     *  symbol from `pdf-image-painter` isn't re-exported. */
-    imageFetcher?: DocxImageFetcher;
-}
-/**
- * Render `doc` to a PDF byte buffer using the same `PdfExporter` the
- * editor uses, with a `fontkit`-backed measurer in place of the browser
- * Canvas measurer. Korean fonts referenced by the document are
- * pre-loaded through `PdfFonts` and registered with the measurer so
- * pagination matches what the painter then draws.
- *
- * Latin text falls back to the measurer's coarse 0.5em estimate
- * (Helvetica/Times metrics aren't bundled). Pure-ASCII docs may
- * therefore line-break differently in the CLI than in the browser; the
- * paint output stays correct because `PdfPainter` uses pdf-lib's
- * StandardFonts at draw time.
- */
-export declare function exportPdf(doc: Document, opts?: CliPdfExportOptions): Promise<Uint8Array>;

package/dist/docs/pdf-export.js

@@ -1,95 +0,0 @@
-import { PDFDocument } from 'pdf-lib';
-import { PdfExporter, PdfFonts, scanFontsUsed, } from '@wafflebase/docs';
-import { FontkitMeasurer } from './fontkit-measurer.js';
-/**
- * Render `doc` to a PDF byte buffer using the same `PdfExporter` the
- * editor uses, with a `fontkit`-backed measurer in place of the browser
- * Canvas measurer. Korean fonts referenced by the document are
- * pre-loaded through `PdfFonts` and registered with the measurer so
- * pagination matches what the painter then draws.
- *
- * Latin text falls back to the measurer's coarse 0.5em estimate
- * (Helvetica/Times metrics aren't bundled). Pure-ASCII docs may
- * therefore line-break differently in the CLI than in the browser; the
- * paint output stays correct because `PdfPainter` uses pdf-lib's
- * StandardFonts at draw time.
- */
-export async function exportPdf(doc, opts = {}) {
-    const usage = scanFontsUsed(doc);
-    const fonts = new PdfFonts({ sources: opts.fontSources });
-    const measurer = new FontkitMeasurer();
-    await preloadKoreanFonts(fonts, measurer, usage);
-    const blob = await PdfExporter.export(doc, {
-        measurer,
-        fonts,
-        imageFetcher: opts.imageFetcher,
-    });
-    const fullBytes = new Uint8Array(await blob.arrayBuffer());
-    if (!opts.pages || opts.pages.pages.size === 0) {
-        return fullBytes;
-    }
-    return extractPages(fullBytes, opts.pages);
-}
-/**
- * Load every Korean variant `usage` reports as needed and register each
- * loaded buffer with the measurer under both the canonical `'Noto …'`
- * family name and the editor-side aliases (`바탕`, `Batang`) so inline
- * styles that pick a non-canonical family still hit a real font instead
- * of the fallback estimate.
- */
-async function preloadKoreanFonts(fonts, measurer, usage) {
-    const variants = [];
-    if (usage.needsKR) {
-        variants.push({
-            key: 'kr-sans-regular',
-            weight: 'normal',
-            families: ['Noto Sans KR'],
-        });
-    }
-    if (usage.needsKR && usage.needsBold) {
-        variants.push({
-            key: 'kr-sans-bold',
-            weight: 'bold',
-            families: ['Noto Sans KR'],
-        });
-    }
-    if (usage.needsKRSerif) {
-        variants.push({
-            key: 'kr-serif-regular',
-            weight: 'normal',
-            families: ['Noto Serif KR', '바탕', 'Batang'],
-        });
-    }
-    if (usage.needsKRSerif && usage.needsBold) {
-        variants.push({
-            key: 'kr-serif-bold',
-            weight: 'bold',
-            families: ['Noto Serif KR', '바탕', 'Batang'],
-        });
-    }
-    for (const v of variants) {
-        const buf = await fonts.load(v.key);
-        for (const family of v.families) {
-            measurer.register(family, v.weight, 'normal', buf);
-        }
-    }
-}
-/**
- * Keep only the pages named by `range` and return the new PDF bytes.
- *
- * Iterates from the highest index down so each `removePage(idx)` call
- * doesn't shift the indices of pages we haven't visited yet. Pages in
- * `range.pages` are 1-based; pdf-lib indexes from 0.
- */
-async function extractPages(bytes, range) {
-    const pdf = await PDFDocument.load(bytes);
-    const total = pdf.getPageCount();
-    for (let i = total - 1; i >= 0; i--) {
-        const oneBased = i + 1;
-        if (!range.pages.has(oneBased)) {
-            pdf.removePage(i);
-        }
-    }
-    const out = await pdf.save();
-    return out;
-}

package/dist/output/binary.d.ts

@@ -1,37 +0,0 @@
-export interface WriteBinaryOptions {
-    /** Allow overwriting an existing file. Without this flag, `writeBinary`
-     *  refuses to clobber and throws. Mirrors `--force` on the CLI. */
-    force?: boolean;
-    /** Suppress informational stderr output. The bytes themselves still
-     *  reach stdout/the file regardless of this flag. */
-    quiet?: boolean;
-}
-/**
- * Write `bytes` to `target`, where `target` is either a filesystem path
- * or `'-'` for stdout. The default behavior refuses to overwrite an
- * existing file because exports are usually irreversible (the source
- * doc is the canonical store but a stale local copy can still mislead).
- *
- * The function is split out from the command action so binary output
- * paths can be unit-tested without spawning the CLI binary; the action
- * supplies real `process.stdout.write` and the IO surface forwards it.
- *
- * The default `writeFile` honors `force` via the `'w'` (overwrite) /
- * `'wx'` (exclusive create) `fs` flags, folding the existence check
- * and the write into a single syscall — avoids a TOCTOU window where
- * something else could create the file between the check and the
- * write.
- */
-export declare function writeBinary(bytes: Uint8Array, target: string, opts?: WriteBinaryOptions, io?: BinaryIO): void;
-export interface BinaryIO {
-    stdout: (bytes: Uint8Array) => void;
-    stderr: (line: string) => void;
-    /**
-     * Write `bytes` to `path`. When `force` is `false`, the
-     * implementation MUST refuse to overwrite an existing file and
-     * throw — the production `defaultBinaryIO` does this via the
-     * exclusive-create `'wx'` flag.
-     */
-    writeFile: (path: string, bytes: Uint8Array, force: boolean) => void;
-}
-export declare const defaultBinaryIO: BinaryIO;

package/dist/output/binary.js

@@ -1,47 +0,0 @@
-import { writeFileSync } from 'node:fs';
-/**
- * Write `bytes` to `target`, where `target` is either a filesystem path
- * or `'-'` for stdout. The default behavior refuses to overwrite an
- * existing file because exports are usually irreversible (the source
- * doc is the canonical store but a stale local copy can still mislead).
- *
- * The function is split out from the command action so binary output
- * paths can be unit-tested without spawning the CLI binary; the action
- * supplies real `process.stdout.write` and the IO surface forwards it.
- *
- * The default `writeFile` honors `force` via the `'w'` (overwrite) /
- * `'wx'` (exclusive create) `fs` flags, folding the existence check
- * and the write into a single syscall — avoids a TOCTOU window where
- * something else could create the file between the check and the
- * write.
- */
-export function writeBinary(bytes, target, opts = {}, io = defaultBinaryIO) {
-    if (target === '-') {
-        io.stdout(bytes);
-        return;
-    }
-    io.writeFile(target, bytes, opts.force === true);
-    if (!opts.quiet)
-        io.stderr(`Wrote ${bytes.length} bytes to ${target}`);
-}
-export const defaultBinaryIO = {
-    stdout: (bytes) => {
-        process.stdout.write(bytes);
-    },
-    stderr: (line) => {
-        console.error(line);
-    },
-    writeFile: (path, bytes, force) => {
-        try {
-            writeFileSync(path, bytes, { flag: force ? 'w' : 'wx' });
-        }
-        catch (err) {
-            if (err instanceof Error &&
-                'code' in err &&
-                err.code === 'EEXIST') {
-                throw new Error(`Refusing to overwrite "${path}". Pass --force to allow overwrite.`);
-            }
-            throw err;
-        }
-    },
-};

package/dist/output/csv.d.ts

@@ -1,4 +0,0 @@
-/**
- * Format data as CSV. Accepts arrays or single objects.
- */
-export declare function formatCsv(data: unknown): string;

package/dist/output/csv.js

@@ -1,25 +0,0 @@
-/**
- * Format data as CSV. Accepts arrays or single objects.
- */
-export function formatCsv(data) {
-    const rows = Array.isArray(data)
-        ? data
-        : data !== null && typeof data === 'object'
-            ? [data]
-            : [];
-    if (rows.length === 0)
-        return '';
-    const keys = Object.keys(rows[0]);
-    const csvEscape = (val) => {
-        const s = val !== null && typeof val === 'object'
-            ? JSON.stringify(val)
-            : String(val ?? '');
-        if (s.includes(',') || s.includes('"') || s.includes('\n')) {
-            return `"${s.replace(/"/g, '""')}"`;
-        }
-        return s;
-    };
-    const header = keys.map(csvEscape).join(',');
-    const lines = rows.map((row) => keys.map((k) => csvEscape(row[k])).join(','));
-    return [header, ...lines].join('\n');
-}

package/dist/output/formatter.d.ts

@@ -1,4 +0,0 @@
-export type OutputFormat = 'json' | 'table' | 'csv';
-export declare function format(data: unknown, fmt: OutputFormat): string;
-export declare function output(data: unknown, fmt: OutputFormat, quiet: boolean): void;
-export declare function outputError(error: unknown, quiet: boolean): void;