@wafflebase/cli 0.4.8 → 0.5.0

package/dist/slides/import.d.ts

@@ -1,82 +0,0 @@
-import type { SlidesDocument, UploadImage } from '@wafflebase/slides/node';
-import { type CliPptxImportOptions } from './pptx-import.js';
-import type { ImportReport } from '@wafflebase/slides/node';
-/**
- * Parsing surface — split out so tests can inject a stub that returns
- * a synthetic `SlidesDocument` without building a real `.pptx` byte
- * buffer. Production callers use the default (`importPptx` from
- * `./pptx-import.js`).
- */
-export type SlidesImportParser = (buf: Uint8Array, opts?: CliPptxImportOptions) => Promise<{
-    document: SlidesDocument;
-    report: ImportReport;
-}>;
-/**
- * Minimal HTTP surface `runSlidesImport` needs from the CLI's
- * `HttpClient`. Spelled out so tests can pass a stub without depending
- * on the full client. Mirrors `ImportClient` in `../docs/import.ts`.
- */
-export interface SlidesImportClient {
-    createDocument: (title: string, type?: 'doc' | 'sheet' | 'slides') => Promise<{
-        ok: boolean;
-        status: number;
-        data: unknown;
-    }>;
-    putSlidesContent: (docId: string, deck: SlidesDocument) => Promise<{
-        ok: boolean;
-        status: number;
-        data: unknown;
-    }>;
-}
-export interface SlidesImportIO {
-    /** Final structured payload — written to stdout as JSON. */
-    stdout: (line: string) => void;
-    stderr: (line: string) => void;
-    /**
-     * Read the pptx bytes for `path`. `'-'` reads from stdin.
-     *
-     * Split out so tests can inject in-memory buffers without juggling
-     * tmp files; the default reads `process.stdin` (or the file
-     * synchronously) at the action site.
-     */
-    readBytes: (path: string) => Promise<Uint8Array>;
-    /**
-     * Prompt the user for a yes/no answer when running interactively.
-     * Returns `true` for affirmative responses (case-insensitive `y` /
-     * `yes`); anything else (including end-of-stream) → `false`.
-     */
-    confirm: (prompt: string) => Promise<boolean>;
-    /** Whether the current process is interactive (a TTY on stdin). */
-    isTTY: boolean;
-}
-export declare const defaultSlidesImportIO: SlidesImportIO;
-export interface RunSlidesImportArgs {
-    /** Source path. `'-'` reads from stdin. */
-    file: string;
-    /** Override the deck title. Falls back to the file basename. */
-    title?: string;
-    /** Existing document ID to overwrite. Pairs with `--yes`. */
-    replace?: string;
-    /** Skip the interactive `--replace` confirmation. */
-    yes?: boolean;
-    /** Override the default base64 image uploader. Tests pass a no-op. */
-    uploadImage?: UploadImage;
-    /** Suppress informational stderr output (errors still reported). */
-    quiet?: boolean;
-    /** Print the request that *would* fire instead of issuing it. */
-    dryRun?: boolean;
-    /** Override the .pptx parser — primarily for tests. */
-    parser?: SlidesImportParser;
-}
-export interface RunSlidesImportResult {
-    /** Process exit code. The action sets `process.exitCode` accordingly. */
-    exitCode: number;
-}
-/**
- * Pure orchestration for `slides import`. Reads the source `.pptx`,
- * parses it into a `SlidesDocument`, then either creates a new deck
- * (default) or overwrites an existing one (`--replace`). Mirrors
- * `runDocsImport` — see that file for the rationale behind the split
- * between this function and the Commander action.
- */
-export declare function runSlidesImport(args: RunSlidesImportArgs, client: SlidesImportClient, io?: SlidesImportIO): Promise<RunSlidesImportResult>;

package/dist/slides/import.js

@@ -1,170 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { basename, extname } from 'node:path';
-import { createInterface } from 'node:readline';
-import { importPptx as defaultImportPptx, InvalidPptxError, } from './pptx-import.js';
-export const defaultSlidesImportIO = {
-    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 `slides import`. Reads the source `.pptx`,
- * parses it into a `SlidesDocument`, then either creates a new deck
- * (default) or overwrites an existing one (`--replace`). Mirrors
- * `runDocsImport` — see that file for the rationale behind the split
- * between this function and the Commander action.
- */
-export async function runSlidesImport(args, client, io = defaultSlidesImportIO) {
-    const { file, replace, yes = false, uploadImage, quiet = false, dryRun = false, parser = defaultImportPptx, } = 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 deck "${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 safeImportPptx(buf, uploadImage, io, parser);
-        if (parsed === null)
-            return { exitCode: 1 };
-        const { document: deck, report } = parsed;
-        if (dryRun) {
-            io.stdout(JSON.stringify({
-                method: 'PUT',
-                path: `/documents/${replace}/content`,
-                body: deck,
-                report: summariseReport(report),
-            }, null, 2));
-            return { exitCode: 0 };
-        }
-        const res = await client.putSlidesContent(replace, deck);
-        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, report: summariseReport(report) }, null, 2));
-        return { exitCode: 0 };
-    }
-    // Default flow: POST + PUT.
-    const buf = await io.readBytes(file);
-    const parsedNew = await safeImportPptx(buf, uploadImage, io, parser);
-    if (parsedNew === null)
-        return { exitCode: 1 };
-    const { document: deck, report } = parsedNew;
-    // The parser fills `meta.title` with whatever string the .pptx carries
-    // (often "PowerPoint Presentation" or "Imported deck"). The user's
-    // `--title` flag is the source of truth for the deck name — keep the
-    // Yorkie root's title in lock-step with the Document row so the deck
-    // list, editor header, and GET /content all agree.
-    deck.meta.title = inferredTitle;
-    if (dryRun) {
-        io.stdout(JSON.stringify({
-            method: 'POST',
-            path: '/documents',
-            body: { title: inferredTitle, type: 'slides' },
-            followUp: { method: 'PUT', path: '/documents/<new-id>/content' },
-            report: summariseReport(report),
-        }, null, 2));
-        return { exitCode: 0 };
-    }
-    const created = await client.createDocument(inferredTitle, 'slides');
-    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.putSlidesContent(newId, deck);
-    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, report: summariseReport(report) }, null, 2));
-    return { exitCode: 0 };
-}
-function defaultTitleFor(file) {
-    if (file === '-')
-        return 'Untitled';
-    return basename(file, extname(file)) || 'Untitled';
-}
-/**
- * Collect the parser's `ImportReport` counters into a plain object so
- * the CLI can print them as JSON. We surface every counter rather than
- * the `.summary()` string so agentic callers can parse without
- * regex-matching prose.
- */
-function summariseReport(report) {
-    // `tablesFlattened` / `tableMergesIgnored` / `tableBordersApproximated`
-    // were retired when the structured-TableElement importer landed
-    // (slides-tables P2). Tables now round-trip without lossy fallbacks,
-    // so there's no per-table counter to surface — a clean import shows
-    // empty parts and the standard "no fallbacks" line.
-    return {
-        groupsFlattened: report.groupsFlattened,
-        textBoxesPreScaled: report.textBoxesPreScaled,
-        unknownShapes: report.unknownShapes,
-        unknownLayoutTypes: report.unknownLayoutTypes,
-        skippedImages: report.skippedImages,
-    };
-}
-/**
- * Run `importPptx` and turn `InvalidPptxError` 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.
- */
-async function safeImportPptx(buf, uploadImage, io, parser) {
-    try {
-        return await parser(buf, { uploadImage });
-    }
-    catch (e) {
-        if (e instanceof InvalidPptxError) {
-            io.stderr(JSON.stringify({ error: { code: e.code, message: e.message } }, null, 2));
-            return null;
-        }
-        throw e;
-    }
-}

package/dist/slides/pptx-export.d.ts

@@ -1,6 +0,0 @@
-import { type SlidesDocument } from '@wafflebase/slides/node';
-export interface CliPptxExportOptions {
-    /** Blob-returning fetcher (the CLI's shared image fetcher). */
-    imageFetcher?: (url: string) => Promise<Blob>;
-}
-export declare function exportPptxCli(deck: SlidesDocument, opts?: CliPptxExportOptions): Promise<Uint8Array>;

package/dist/slides/pptx-export.js

@@ -1,10 +0,0 @@
-import { exportPptx } from '@wafflebase/slides/node';
-export async function exportPptxCli(deck, opts = {}) {
-    const fetchImage = opts.imageFetcher
-        ? async (src) => {
-            const blob = await opts.imageFetcher(src);
-            return { bytes: new Uint8Array(await blob.arrayBuffer()), mime: blob.type || 'image/png' };
-        }
-        : undefined;
-    return exportPptx(deck, { fetchImage });
-}

package/dist/slides/pptx-import.d.ts

@@ -1,35 +0,0 @@
-import '../docs/dom-polyfill.js';
-import { type ImportPptxResult, type UploadImage } from '@wafflebase/slides/node';
-/**
- * Default `UploadImage` for the CLI: encodes each embedded image as a
- * `data:` URL. Matches the docs CLI's `inlineBase64Uploader` — the
- * frontend treats slide image `src` values as opaque strings, so a
- * self-contained data URL round-trips cleanly through the API and
- * renders without needing the workspace's `/images` endpoint.
- *
- * The trade-off is payload size: a benchmark deck with 25 unique
- * images and 63 references gains roughly the image-byte total to the
- * Yorkie document. Acceptable for a v1 CLI import — power users who
- * want hosted URLs can pass a custom uploader.
- */
-export declare const inlineBase64SlidesUploader: UploadImage;
-export interface CliPptxImportOptions {
-    /** Override the default base64 uploader — primarily for tests. */
-    uploadImage?: UploadImage;
-}
-/**
- * Parse a .pptx byte buffer into a `SlidesDocument` via the slides
- * parser. The DOM polyfill side-effect import installs xmldom's
- * `DOMParser` globally so the parser's browser-targeted XML reads work
- * in Node.
- *
- * Throws a wrapped `INVALID_PPTX` error when the underlying parser
- * cannot make sense of the buffer. The CLI command translates that
- * into the documented `{ error.code: 'INVALID_PPTX' }` exit body
- * without leaking implementation details.
- */
-export declare function importPptx(buf: Uint8Array, opts?: CliPptxImportOptions): Promise<ImportPptxResult>;
-export declare class InvalidPptxError extends Error {
-    readonly code = "INVALID_PPTX";
-    constructor(message: string);
-}

package/dist/slides/pptx-import.js

@@ -1,49 +0,0 @@
-import '../docs/dom-polyfill.js';
-import { importPptx as importPptxFromSlides, } from '@wafflebase/slides/node';
-/**
- * Default `UploadImage` for the CLI: encodes each embedded image as a
- * `data:` URL. Matches the docs CLI's `inlineBase64Uploader` — the
- * frontend treats slide image `src` values as opaque strings, so a
- * self-contained data URL round-trips cleanly through the API and
- * renders without needing the workspace's `/images` endpoint.
- *
- * The trade-off is payload size: a benchmark deck with 25 unique
- * images and 63 references gains roughly the image-byte total to the
- * Yorkie document. Acceptable for a v1 CLI import — power users who
- * want hosted URLs can pass a custom uploader.
- */
-export const inlineBase64SlidesUploader = async (bytes, mime) => {
-    const base64 = Buffer.from(bytes).toString('base64');
-    const mediaType = mime || 'application/octet-stream';
-    return `data:${mediaType};base64,${base64}`;
-};
-/**
- * Parse a .pptx byte buffer into a `SlidesDocument` via the slides
- * parser. The DOM polyfill side-effect import installs xmldom's
- * `DOMParser` globally so the parser's browser-targeted XML reads work
- * in Node.
- *
- * Throws a wrapped `INVALID_PPTX` error when the underlying parser
- * cannot make sense of the buffer. The CLI command translates that
- * into the documented `{ error.code: 'INVALID_PPTX' }` exit body
- * without leaking implementation details.
- */
-export async function importPptx(buf, opts = {}) {
-    const arrayBuf = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-    try {
-        return await importPptxFromSlides(arrayBuf, {
-            uploadImage: opts.uploadImage ?? inlineBase64SlidesUploader,
-        });
-    }
-    catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        throw new InvalidPptxError(message);
-    }
-}
-export class InvalidPptxError extends Error {
-    code = 'INVALID_PPTX';
-    constructor(message) {
-        super(message);
-        this.name = 'InvalidPptxError';
-    }
-}

package/dist/util/csv-parse.d.ts

@@ -1,21 +0,0 @@
-/**
- * Parse CSV text into a 2D array of strings.
- */
-export declare function parseCsv(text: string): string[][];
-/**
- * Convert a 1-based column number to a column label (1→A, 2→B, 27→AA).
- */
-export declare function toColumnLabel(col: number): string;
-/**
- * Parse a cell reference like "A1" into 1-based row and column numbers.
- */
-export declare function parseStartRef(ref: string): {
-    row: number;
-    col: number;
-};
-/**
- * Build a cell map from a 2D array for batch API.
- */
-export declare function buildCellMap(data: string[][], startRow: number, startCol: number): Record<string, {
-    value: string;
-}>;

package/dist/util/csv-parse.js

@@ -1,99 +0,0 @@
-/**
- * Parse CSV text into a 2D array of strings.
- */
-export function parseCsv(text) {
-    const rows = [];
-    let current = '';
-    let inQuotes = false;
-    let row = [];
-    for (let i = 0; i < text.length; i++) {
-        const ch = text[i];
-        if (inQuotes) {
-            if (ch === '"') {
-                if (i + 1 < text.length && text[i + 1] === '"') {
-                    current += '"';
-                    i++;
-                }
-                else {
-                    inQuotes = false;
-                }
-            }
-            else {
-                current += ch;
-            }
-        }
-        else if (ch === '"') {
-            inQuotes = true;
-        }
-        else if (ch === ',') {
-            row.push(current);
-            current = '';
-        }
-        else if (ch === '\n' || ch === '\r') {
-            if (ch === '\r' && i + 1 < text.length && text[i + 1] === '\n') {
-                i++;
-            }
-            row.push(current);
-            current = '';
-            if (row.length > 0)
-                rows.push(row);
-            row = [];
-        }
-        else {
-            current += ch;
-        }
-    }
-    // last field/row
-    row.push(current);
-    if (row.some((cell) => cell !== ''))
-        rows.push(row);
-    return rows;
-}
-/**
- * Convert a 1-based column number to a column label (1→A, 2→B, 27→AA).
- */
-export function toColumnLabel(col) {
-    let label = '';
-    while (col > 0) {
-        const rem = col % 26;
-        if (rem === 0) {
-            label = 'Z' + label;
-            col = Math.floor(col / 26) - 1;
-        }
-        else {
-            label = String.fromCharCode(rem + 64) + label;
-            col = Math.floor(col / 26);
-        }
-    }
-    return label;
-}
-/**
- * Parse a cell reference like "A1" into 1-based row and column numbers.
- */
-export function parseStartRef(ref) {
-    const match = ref.match(/^([A-Z]+)(\d+)$/i);
-    if (!match)
-        return { row: 1, col: 1 };
-    const letters = match[1].toUpperCase();
-    let col = 0;
-    for (const ch of letters) {
-        col = col * 26 + (ch.charCodeAt(0) - 64);
-    }
-    return { row: parseInt(match[2], 10), col };
-}
-/**
- * Build a cell map from a 2D array for batch API.
- */
-export function buildCellMap(data, startRow, startCol) {
-    const cells = {};
-    for (let r = 0; r < data.length; r++) {
-        for (let c = 0; c < data[r].length; c++) {
-            const value = data[r][c];
-            if (value === '')
-                continue;
-            const ref = toColumnLabel(startCol + c) + (startRow + r);
-            cells[ref] = { value };
-        }
-    }
-    return cells;
-}