@wafflebase/cli 0.4.7 → 0.4.9

package/dist/client/http-client.d.ts

@@ -30,6 +30,7 @@ export declare class HttpClient {
     deleteDocument(id: string): Promise<ApiResponse<unknown>>;
     getDocContent(docId: string): Promise<ApiResponse<Document>>;
     putDocContent(docId: string, doc: Document): Promise<ApiResponse<Document>>;
+    getSlidesContent(docId: string): Promise<ApiResponse<SlidesDocument>>;
     putSlidesContent(docId: string, deck: SlidesDocument): Promise<ApiResponse<SlidesDocument>>;
     listTabs(docId: string): Promise<ApiResponse<unknown[]>>;
     getCells(docId: string, tabId: string, range?: string): Promise<ApiResponse<unknown>>;

package/dist/client/http-client.js

@@ -119,6 +119,9 @@ export class HttpClient {
     // Slides content — same endpoint as docs; the backend dispatches on
     // the persisted document type, picking the docs writer for `'doc'`
     // and the slides writer for `'slides'`.
+    getSlidesContent(docId) {
+        return this.request('GET', `/documents/${docId}/content`);
+    }
     putSlidesContent(docId, deck) {
         return this.request('PUT', `/documents/${docId}/content`, deck);
     }

package/dist/commands/slides.js

@@ -1,12 +1,201 @@
-import { getGlobalOpts, getClient } from './root.js';
-import { outputError } from '../output/formatter.js';
+import { extname } from 'node:path';
+import { getGlobalOpts, getClient, getConfig } from './root.js';
+import { output, outputError } from '../output/formatter.js';
+import { printDryRun } from '../client/dry-run.js';
 import { runSlidesImport } from '../slides/import.js';
+import { parseSlidesContentFormat, runSlidesContent, } from '../slides/content.js';
+import { writeBinary } from '../output/binary.js';
+import { createImageFetcher } from '../docs/image-fetcher.js';
+import { exportPptxCli } from '../slides/pptx-export.js';
 export function registerSlidesCommand(program) {
     const slides = program
         .command('slides')
         .alias('slide')
         .alias('deck')
         .description('Manage slide decks');
+    slides
+        .command('list')
+        .description('List slide decks in workspace')
+        .action(async function () {
+        const opts = getGlobalOpts(this);
+        try {
+            const res = await getClient(opts).listDocuments();
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            let data = res.data;
+            if (Array.isArray(data)) {
+                data = data.filter((d) => d.type === 'slides');
+            }
+            output(data, opts.format, opts.quiet);
+        }
+        catch (e) {
+            outputError(e, opts.quiet);
+        }
+    });
+    slides
+        .command('create <title>')
+        .description('Create a new slide deck')
+        .action(async function (title) {
+        const opts = getGlobalOpts(this);
+        try {
+            if (opts.dryRun) {
+                printDryRun(getConfig(opts), 'POST', '/documents', {
+                    title,
+                    type: 'slides',
+                });
+                return;
+            }
+            const res = await getClient(opts).createDocument(title, 'slides');
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            output(res.data, opts.format, opts.quiet);
+        }
+        catch (e) {
+            outputError(e, opts.quiet);
+        }
+    });
+    slides
+        .command('get <doc-id>')
+        .description('Show slide deck metadata')
+        .action(async function (docId) {
+        const opts = getGlobalOpts(this);
+        try {
+            const res = await getClient(opts).getDocument(docId);
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            output(res.data, opts.format, opts.quiet);
+        }
+        catch (e) {
+            outputError(e, opts.quiet);
+        }
+    });
+    slides
+        .command('rename <doc-id> <title>')
+        .description('Rename a slide deck')
+        .action(async function (docId, title) {
+        const opts = getGlobalOpts(this);
+        if (opts.dryRun) {
+            printDryRun(getConfig(opts), 'PATCH', `/documents/${docId}`, { title });
+            return;
+        }
+        try {
+            const res = await getClient(opts).updateDocument(docId, title);
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            output(res.data, opts.format, opts.quiet);
+        }
+        catch (e) {
+            outputError(e, opts.quiet);
+        }
+    });
+    slides
+        .command('delete <doc-id>')
+        .description('Delete a slide deck')
+        .action(async function (docId) {
+        const opts = getGlobalOpts(this);
+        if (opts.dryRun) {
+            printDryRun(getConfig(opts), 'DELETE', `/documents/${docId}`);
+            return;
+        }
+        try {
+            const res = await getClient(opts).deleteDocument(docId);
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            output(res.data, opts.format, opts.quiet);
+        }
+        catch (e) {
+            outputError(e, opts.quiet);
+        }
+    });
+    slides
+        .command('content <doc-id>')
+        .description('Read deck content as JSON, Markdown, or plain text')
+        // NOTE: `--format` is intentionally not redeclared here — the global
+        // `--format` option catches the user's value (see the same comment
+        // on `docs content`). We read `opts.format` and validate it through
+        // `parseSlidesContentFormat`.
+        .option('--notes', 'Include speaker notes (md/text)', false)
+        .option('--out <file>', 'Output file (- for stdout)')
+        .option('--force', 'Overwrite existing output file', false)
+        .action(async function (docId) {
+        const opts = getGlobalOpts(this);
+        const local = this.opts();
+        try {
+            const format = parseSlidesContentFormat(opts.format);
+            if (opts.dryRun) {
+                printDryRun(getConfig(opts), 'GET', `/documents/${docId}/content`);
+                return;
+            }
+            const res = await getClient(opts).getSlidesContent(docId);
+            if (!res.ok) {
+                const body = res.data;
+                if (body?.error) {
+                    // Surface backend-shaped errors (e.g., TYPE_MISMATCH) verbatim
+                    // so agents reading stderr can act on the `code` field.
+                    console.error(JSON.stringify(body, null, 2));
+                    process.exitCode = 1;
+                    return;
+                }
+                throw new Error(`HTTP ${res.status}`);
+            }
+            runSlidesContent({
+                deck: res.data,
+                format,
+                notes: local.notes,
+                out: local.out,
+                force: local.force,
+                quiet: opts.quiet,
+            });
+        }
+        catch (e) {
+            outputError(e, opts.quiet);
+        }
+    });
+    slides
+        .command('export <doc-id> <file>')
+        .description('Export a slide deck to PPTX')
+        // NOTE: `--format` is intentionally not redeclared here — the global
+        // `--format` option catches the user's value (see the same comment on
+        // `docs export`). We read `opts.format` via `getOptionValueSourceWithGlobals`
+        // to distinguish an explicit CLI flag from the default, then validate
+        // that only "pptx" is accepted.
+        .option('--force', 'Overwrite existing output file', false)
+        .action(async function (docId, file) {
+        const opts = getGlobalOpts(this);
+        const local = this.opts();
+        try {
+            const formatSource = this.getOptionValueSourceWithGlobals('format');
+            // Widen to `string` — `opts.format` is the global `OutputFormat`
+            // union (json|table|csv|yaml), which has no overlap with the
+            // export-only `pptx` value, so a direct comparison is a tsc error.
+            const fmt = formatSource === 'cli' ? opts.format : undefined;
+            if (fmt && fmt !== 'pptx')
+                throw new Error(`Invalid --format "${fmt}". Only "pptx" is supported.`);
+            if (!fmt && extname(file).toLowerCase() !== '.pptx') {
+                throw new Error(`Cannot infer format from "${file}". Use a .pptx extension or --format pptx.`);
+            }
+            if (opts.dryRun) {
+                printDryRun(getConfig(opts), 'GET', `/documents/${docId}/content`);
+                return;
+            }
+            const res = await getClient(opts).getSlidesContent(docId);
+            if (!res.ok) {
+                const body = res.data;
+                if (body?.error) {
+                    console.error(JSON.stringify(body, null, 2));
+                    process.exitCode = 1;
+                    return;
+                }
+                throw new Error(`HTTP ${res.status}`);
+            }
+            const imageFetcher = createImageFetcher({ serverBase: getConfig(opts).server });
+            const bytes = await exportPptxCli(res.data, { imageFetcher });
+            writeBinary(bytes, file, { force: local.force, quiet: opts.quiet });
+        }
+        catch (e) {
+            outputError(e, opts.quiet);
+        }
+    });
     registerSlidesImportCommand(slides);
 }
 export function registerSlidesImportCommand(slides) {

package/dist/docs/paginate.js

@@ -14,6 +14,6 @@ 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);
+    const { layout } = computeLayout(doc.blocks, measurer, contentWidth, undefined, undefined, undefined, doc.styles);
     return paginateLayout(layout, pageSetup);
 }

package/dist/schema/registry.js

@@ -141,6 +141,102 @@ const registry = [
         ],
         aliases: ['doc.import', 'document.import', 'documents.import'],
     },
+    // Slides (presentation) namespace
+    {
+        name: 'slides.list',
+        description: 'List slide decks in workspace',
+        safety: 'read-only',
+        parameters: {},
+        response: { type: 'array', items: { id: 'string', title: 'string', type: 'string', createdAt: 'string' } },
+        aliases: ['slide.list', 'deck.list', 'decks.list'],
+    },
+    {
+        name: 'slides.create',
+        description: 'Create a new slide deck',
+        safety: 'write',
+        parameters: {
+            title: { type: 'string', required: true, description: 'Deck title' },
+        },
+        response: { id: 'string', title: 'string', type: 'string' },
+        aliases: ['slide.create', 'deck.create', 'decks.create'],
+    },
+    {
+        name: 'slides.get',
+        description: 'Show slide deck metadata',
+        safety: 'read-only',
+        parameters: {
+            'doc-id': { type: 'string', required: true, description: 'Document ID' },
+        },
+        response: { id: 'string', title: 'string', type: 'string', createdAt: 'string' },
+        aliases: ['slide.get', 'deck.get', 'decks.get'],
+    },
+    {
+        name: 'slides.rename',
+        description: 'Rename a slide deck',
+        safety: 'write',
+        parameters: {
+            'doc-id': { type: 'string', required: true, description: 'Document ID' },
+            title: { type: 'string', required: true, description: 'New title' },
+        },
+        response: { id: 'string', title: 'string' },
+        aliases: ['slide.rename', 'deck.rename', 'decks.rename'],
+    },
+    {
+        name: 'slides.delete',
+        description: 'Delete a slide deck',
+        safety: 'destructive',
+        parameters: {
+            'doc-id': { type: 'string', required: true, description: 'Document ID' },
+        },
+        response: { id: 'string' },
+        aliases: ['slide.delete', 'deck.delete', 'decks.delete'],
+    },
+    {
+        name: 'slides.content',
+        description: 'Read deck content as JSON, Markdown, or plain text',
+        safety: 'read-only',
+        parameters: {
+            'doc-id': { type: 'string', required: true, description: 'Document ID' },
+            '--format': { type: 'string', required: false, description: 'Output format (json|md|text)', default: 'json' },
+            '--notes': { type: 'boolean', required: false, description: 'Include speaker notes (md/text)', default: 'false' },
+            '--out': { type: 'string', required: false, description: 'Output file (- for stdout)' },
+            '--force': { type: 'boolean', required: false, description: 'Overwrite existing output file', default: 'false' },
+        },
+        response: { type: 'object', description: 'Deck JSON, Markdown text, or plaintext per --format' },
+        aliases: ['slide.content', 'deck.content', 'decks.content'],
+    },
+    {
+        name: 'slides.import',
+        description: 'Import a .pptx file as a new (or replacement) slide deck',
+        // Default safety is `write` (create new deck); `--replace` flips it
+        // to destructive, mirroring `docs.import`.
+        safety: 'write',
+        parameters: {
+            file: { type: 'string', required: true, description: 'Source .pptx path or - for stdin' },
+            '--title': { type: 'string', required: false, description: 'Deck title (default: file basename)' },
+            '--replace': { type: 'string', required: false, description: 'Existing deck ID to replace' },
+            '--yes': { type: 'boolean', required: false, description: 'Skip --replace confirmation', default: 'false' },
+        },
+        response: { id: 'string', title: 'string', replaced: 'boolean' },
+        variants: [
+            { when: 'default', safety: 'write', creates: 'new slide deck' },
+            { when: '--replace given', safety: 'destructive', modifies: 'existing deck content' },
+        ],
+        aliases: ['slide.import', 'deck.import', 'decks.import'],
+    },
+    {
+        name: 'slides.export',
+        description: 'Export a slide deck to PPTX',
+        safety: 'read-only',
+        parameters: {
+            'doc-id': { type: 'string', required: true, description: 'Document ID' },
+            file: { type: 'string', required: true, description: 'Output path or - for stdout' },
+            '--format': { type: 'string', required: false, description: 'Output format (pptx); default from extension' },
+            '--force': { type: 'boolean', required: false, description: 'Overwrite existing output file', default: 'false' },
+        },
+        response: { type: 'binary', description: 'PPTX bytes' },
+        aliases: ['slide.export', 'deck.export', 'decks.export'],
+    },
     // Sheets namespace — canonical names live under sheets.*
     {
         name: 'sheets.tabs.list',

package/dist/slides/content.d.ts

@@ -0,0 +1,41 @@
+import { type SlidesDocument } from '@wafflebase/slides/node';
+export declare const VALID_SLIDES_CONTENT_FORMATS: readonly ["json", "md", "text"];
+export type SlidesContentFormat = (typeof VALID_SLIDES_CONTENT_FORMATS)[number];
+export declare const SLIDES_LOSSY_NOTICE: string;
+export declare function parseSlidesContentFormat(value: string): SlidesContentFormat;
+/**
+ * Surface for `runSlidesContent` to talk back to the CLI without taking
+ * a direct dependency on `process.stdout` / `process.stderr` / `fs`.
+ * Mirrors `ContentIO` in `../docs/content.ts`; the command wires the
+ * real implementations, tests inject in-memory collectors.
+ */
+export interface SlidesContentIO {
+    stdout: (text: string) => void;
+    stderr: (line: string) => void;
+    /** Write `text` to `path`. Throws if the file exists and `force` is false. */
+    writeFile: (path: string, text: string, force: boolean) => void;
+}
+export declare const defaultSlidesContentIO: SlidesContentIO;
+export interface RunSlidesContentArgs {
+    deck: SlidesDocument;
+    format: SlidesContentFormat;
+    /** Include speaker notes (`Slide.notes`) after each slide's body. */
+    notes?: boolean;
+    out?: string;
+    force?: boolean;
+    quiet?: boolean;
+}
+/**
+ * Pure orchestration for `slides content`: takes an already-fetched
+ * `SlidesDocument` plus user flags, produces the rendered output, and
+ * routes it through the supplied IO surface.
+ *
+ * - `json`: the raw deck JSON (lossless — themes, layouts, geometry,
+ *   styling all preserved).
+ * - `md` / `text`: per-slide text extraction only. Slides have no single
+ *   linear text stream, so we walk each slide's elements in document
+ *   order, pull every `TextBody`'s blocks (text boxes, shape labels,
+ *   table cells), and serialize them with the docs serializers. Shapes,
+ *   images, connectors, positioning and theming are dropped.
+ */
+export declare function runSlidesContent(args: RunSlidesContentArgs, io?: SlidesContentIO): void;

package/dist/slides/content.js

@@ -0,0 +1,122 @@
+import { writeFileSync, existsSync } from 'node:fs';
+import { serializeMarkdown, serializeText, } from '@wafflebase/docs';
+import { flattenElements, } from '@wafflebase/slides/node';
+export const VALID_SLIDES_CONTENT_FORMATS = ['json', 'md', 'text'];
+export const SLIDES_LOSSY_NOTICE = 'Lossy conversion: only text is extracted (shapes, images, connectors, ' +
+    'layout, theming, and positioning are dropped). See cli.md for details.';
+export function parseSlidesContentFormat(value) {
+    if (!VALID_SLIDES_CONTENT_FORMATS.includes(value)) {
+        throw new Error(`Invalid --format "${value}". Use one of: ${VALID_SLIDES_CONTENT_FORMATS.join(', ')}.`);
+    }
+    return value;
+}
+export const defaultSlidesContentIO = {
+    stdout: (text) => {
+        process.stdout.write(text);
+        if (!text.endsWith('\n'))
+            process.stdout.write('\n');
+    },
+    stderr: (line) => {
+        console.error(line);
+    },
+    writeFile: (path, text, force) => {
+        if (existsSync(path) && !force) {
+            throw new Error(`Refusing to overwrite "${path}". Pass --force to allow overwrite.`);
+        }
+        writeFileSync(path, text.endsWith('\n') ? text : text + '\n', 'utf-8');
+    },
+};
+/**
+ * Pure orchestration for `slides content`: takes an already-fetched
+ * `SlidesDocument` plus user flags, produces the rendered output, and
+ * routes it through the supplied IO surface.
+ *
+ * - `json`: the raw deck JSON (lossless — themes, layouts, geometry,
+ *   styling all preserved).
+ * - `md` / `text`: per-slide text extraction only. Slides have no single
+ *   linear text stream, so we walk each slide's elements in document
+ *   order, pull every `TextBody`'s blocks (text boxes, shape labels,
+ *   table cells), and serialize them with the docs serializers. Shapes,
+ *   images, connectors, positioning and theming are dropped.
+ */
+export function runSlidesContent(args, io = defaultSlidesContentIO) {
+    const { deck, format, notes = false, out, force = false, quiet = false } = args;
+    let text;
+    if (format === 'json') {
+        text = JSON.stringify(deck, null, 2);
+    }
+    else {
+        if (!quiet)
+            io.stderr(SLIDES_LOSSY_NOTICE);
+        text = serializeDeck(deck, format, notes);
+    }
+    if (!out || out === '-') {
+        io.stdout(text);
+        return;
+    }
+    io.writeFile(out, text, force);
+    if (!quiet)
+        io.stderr(`Wrote to ${out}`);
+}
+/**
+ * Render every slide as a `## Slide N` (md) / `Slide N` (text) section
+ * followed by the slide's extracted text. Sections are joined with a
+ * blank line so the stream reads as one document.
+ */
+function serializeDeck(deck, format, notes) {
+    const sections = deck.slides.map((slide, i) => serializeSlide(slide, i + 1, format, notes));
+    return sections.join('\n\n');
+}
+function serializeSlide(slide, number, format, notes) {
+    const blocks = collectSlideBlocks(slide);
+    const body = serializeBlocks(blocks, format);
+    const parts = [];
+    parts.push(format === 'md' ? `## Slide ${number}` : `Slide ${number}`);
+    if (body.length > 0)
+        parts.push(body);
+    if (notes && slide.notes.length > 0) {
+        const notesBody = serializeBlocks(slide.notes, format);
+        if (notesBody.length > 0) {
+            parts.push(format === 'md' ? '### Notes' : 'Notes:');
+            parts.push(notesBody);
+        }
+    }
+    return parts.join('\n\n');
+}
+/**
+ * Collect every text block from a slide's elements, in document order.
+ * Groups are flattened so nested text is included.
+ */
+function collectSlideBlocks(slide) {
+    const blocks = [];
+    for (const el of flattenElements(slide.elements)) {
+        for (const body of textBodiesOf(el)) {
+            blocks.push(...body.blocks);
+        }
+    }
+    return blocks;
+}
+/** Extract every `TextBody` carried by a single element. */
+function textBodiesOf(el) {
+    switch (el.type) {
+        case 'text':
+            // `TextElement.data` is a `TextBody` (intersection with fill/stroke).
+            return [el.data];
+        case 'shape':
+            return el.data.text ? [el.data.text] : [];
+        case 'table':
+            return el.data.rows.flatMap((row) => row.cells.map((cell) => cell.body));
+        default:
+            // image / connector carry no text; group is handled by flatten.
+            return [];
+    }
+}
+/**
+ * Serialize a flat `Block[]` via the docs serializers by wrapping them
+ * in a synthetic `Document`. The serializers read only `doc.blocks`
+ * (header/footer are opt-in and never set here), so the cast is safe.
+ */
+function serializeBlocks(blocks, format) {
+    const doc = { blocks };
+    return format === 'md' ? serializeMarkdown(doc) : serializeText(doc);
+}

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,10 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wafflebase/cli",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "CLI for Wafflebase spreadsheet API",
   "license": "Apache-2.0",
   "type": "module",
@@ -20,14 +20,15 @@
     "open": "^11.0.0",
     "pdf-lib": "^1.17.1",
     "yaml": "^2.0.0",
-    "@wafflebase/slides": "0.4.7",
-    "@wafflebase/docs": "0.4.7"
+    "@wafflebase/docs": "0.4.9",
+    "@wafflebase/slides": "0.4.9"
   },
   "devDependencies": {
     "@types/fontkit": "^2.0.0",
     "@types/node": "^25.4.0",
     "@vitest/coverage-v8": "4.1.8",
     "eslint": "^9.18.0",
+    "jszip": "^3.10.1",
     "tsx": "^4.19.0",
     "typescript": "^5.9.3",
     "vitest": "^4.1.8"