@neta-art/cohub-cli 8.4.1 → 9.1.0

package/dist/commands/boards/items.js

@@ -1,184 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { BoardAuthoringItemSchema, BoardItemPatchSchema, } from "@neta-art/cohub";
-import { computeArrowFrame, computeDrawBounds } from "@neta-art/cohub/board";
-import { BOARD_DOMAIN_INPUT_MAX_BYTES, readBoardJsonObject, } from "../../board-command-support.js";
-import { handleHttp, json, jsonRequested, ok, table } from "../../output.js";
-import { readInput, readOptions, resolvedBoard, withJson, } from "./context.js";
-const baseVersion = (value, fallback) => {
-    if (value === undefined)
-        return fallback;
-    const parsed = Number(value);
-    if (!Number.isSafeInteger(parsed) || parsed < 0) {
-        throw new Error("base version must be a non-negative integer");
-    }
-    return parsed;
-};
-async function execute(boards, target, command, options) {
-    const board = await resolvedBoard(boards, target);
-    const snapshot = await board.summary();
-    const mutation = {
-        mutationId: options.mutationId?.trim() || randomUUID(),
-        baseVersion: baseVersion(options.baseVersion, snapshot.board.version),
-        dryRun: Boolean(options.dryRun),
-        commands: [command],
-    };
-    // Server-side validation: schema, version, references, cascade rules — the
-    // same checks the real write would run, just without persisting anything.
-    const receipt = await board.mutateSemantic(mutation);
-    if (jsonRequested(options))
-        return json(receipt);
-    if (options.dryRun) {
-        ok(`Validated against Board version ${receipt.board.version}; no changes written`);
-        return;
-    }
-    ok(`${receipt.replayed ? "Replayed" : "Applied"} mutation at Board version ${receipt.board.version}`);
-}
-function mutationOptions(command) {
-    return withJson(command)
-        .option("--base-version <version>", "Expected Board version; defaults to latest")
-        .option("--mutation-id <id>", "Stable id for safe retries")
-        .option("--dry-run", "Validate on the server (references, version, cascade) without writing");
-}
-function itemLayout(item) {
-    if ("position" in item) {
-        const size = "size" in item ? item.size : undefined;
-        return { x: item.position.x, y: item.position.y, width: size?.width ?? "", height: size?.height ?? "" };
-    }
-    if (item.type === "draw") {
-        const points = item.props.points;
-        const strokeWidth = item.style?.strokeWidth ?? 4;
-        const bounds = computeDrawBounds(points, strokeWidth);
-        return { x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height };
-    }
-    const bounds = computeArrowFrame({
-        start: item.props.start,
-        end: item.props.end,
-        bend: item.props.bend,
-        size: item.style?.strokeWidth ?? 2.5,
-    });
-    return { x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height };
-}
-export function registerBoardItemCommands(boards) {
-    const items = boards.command("items").description("Author Board items with semantic JSON");
-    readOptions(withJson(items.command("list <board>").alias("ls").description("List semantic Board items")))
-        .action(async (target, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const snapshot = await board.authoring(readInput(options, "items"));
-            const items = snapshot.items ?? [];
-            if (jsonRequested(options))
-                return json(items);
-            table(items.map((item) => ({
-                id: item.id,
-                type: item.type,
-                ...itemLayout(item),
-            })), [
-                { key: "id", label: "ID" },
-                { key: "type", label: "TYPE" },
-                { key: "x", label: "X" },
-                { key: "y", label: "Y" },
-                { key: "width", label: "WIDTH" },
-                { key: "height", label: "HEIGHT" },
-            ]);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(items.command("get <board> <item-id>").description("Get one complete Board item"))
-        .action(async (target, itemId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const snapshot = await board.authoring({ include: ["items"], itemIds: [itemId] });
-            const item = snapshot.items?.[0];
-            if (!item)
-                throw new Error(`Item not found: ${itemId}`);
-            if (jsonRequested(options))
-                return json(item);
-            table([{
-                    id: item.id,
-                    type: item.type,
-                    ...itemLayout(item),
-                }], [
-                { key: "id", label: "ID" },
-                { key: "type", label: "TYPE" },
-                { key: "x", label: "X" },
-                { key: "y", label: "Y" },
-                { key: "width", label: "WIDTH" },
-                { key: "height", label: "HEIGHT" },
-            ]);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    mutationOptions(items.command("create <board>")
-        .description("Create one item")
-        .requiredOption("-i, --input <file>", "Board Item JSON; use - for stdin")
-        .addHelpText("after", `
-Minimal text item:
-  {"id":"title","type":"text","position":{"x":120,"y":80},"size":{"width":320,"height":48},"props":{"text":"Launch plan","fontSize":32},"style":{"color":"brand"}}`))
-        .action(async (target, options) => {
-        try {
-            const value = await readBoardJsonObject(options.input, BOARD_DOMAIN_INPUT_MAX_BYTES);
-            await execute(boards, target, {
-                type: "item.create",
-                item: BoardAuthoringItemSchema.parse(value),
-            }, options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    mutationOptions(items.command("patch <board> <item-id>")
-        .description("Recursively merge item fields")
-        .requiredOption("-i, --input <file>", "Board Item patch JSON; use - for stdin")
-        .addHelpText("after", `
-Objects merge recursively, arrays replace, and null clears optional fields.
-Move and rename a text item without replacing its size or font:
-  {"position":{"x":160,"y":120},"props":{"text":"Updated"}}`))
-        .action(async (target, itemId, options) => {
-        try {
-            const value = await readBoardJsonObject(options.input, BOARD_DOMAIN_INPUT_MAX_BYTES);
-            await execute(boards, target, {
-                type: "item.patch",
-                itemId,
-                patch: BoardItemPatchSchema.parse(value),
-            }, options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    mutationOptions(items.command("replace <board> <item-id>")
-        .description("Replace one complete item")
-        .requiredOption("-i, --input <file>", "Complete Board Item JSON; use - for stdin"))
-        .action(async (target, itemId, options) => {
-        try {
-            const value = await readBoardJsonObject(options.input, BOARD_DOMAIN_INPUT_MAX_BYTES);
-            await execute(boards, target, {
-                type: "item.replace",
-                itemId,
-                item: BoardAuthoringItemSchema.parse(value),
-            }, options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    mutationOptions(items.command("delete <board> <item-id>").alias("rm")
-        .description("Delete one item")
-        .option("--cascade", "Atomically remove relations, effects, and animation references"))
-        .action(async (target, itemId, options) => {
-        try {
-            await execute(boards, target, {
-                type: "item.delete",
-                itemId,
-                cascade: Boolean(options.cascade),
-            }, options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}

package/dist/commands/boards/transactions.d.ts

@@ -1,12 +0,0 @@
-import type { BoardTransactionRecord } from "@neta-art/cohub";
-import type { Command } from "commander";
-/** Compact `type×count` summary, e.g. `node.patch×3 connection.create`. */
-export declare function summarizeOperations(operations: BoardTransactionRecord["operations"]): string;
-export declare function transactionRows(transactions: BoardTransactionRecord[]): {
-    version: number;
-    createdAt: string;
-    actor: string;
-    via: import("@neta-art/cohub/board").BoardReplayActorKind;
-    changes: string;
-}[];
-export declare function registerBoardTransactionCommands(boards: Command): void;

package/dist/commands/boards/transactions.js

@@ -1,69 +0,0 @@
-import { boardReplayActorKind } from "@neta-art/cohub/board";
-import { handleHttp, json, jsonRequested, table } from "../../output.js";
-import { finite, resolvedBoard, withJson } from "./context.js";
-const columns = [
-    { key: "version", label: "VERSION" },
-    { key: "createdAt", label: "AT" },
-    { key: "actor", label: "ACTOR" },
-    { key: "via", label: "VIA" },
-    { key: "changes", label: "CHANGES" },
-];
-/** Compact `type×count` summary, e.g. `node.patch×3 connection.create`. */
-export function summarizeOperations(operations) {
-    const counts = new Map();
-    for (const operation of operations)
-        counts.set(operation.type, (counts.get(operation.type) ?? 0) + 1);
-    return [...counts.entries()].map(([type, count]) => (count > 1 ? `${type}×${count}` : type)).join(" ");
-}
-export function transactionRows(transactions) {
-    return transactions.map((transaction) => ({
-        version: transaction.version,
-        createdAt: transaction.createdAt,
-        actor: transaction.actorId,
-        via: boardReplayActorKind(transaction.source),
-        changes: summarizeOperations(transaction.operations),
-    }));
-}
-export function registerBoardTransactionCommands(boards) {
-    withJson(boards
-        .command("transactions <board>")
-        .alias("history")
-        .description("List the Board transaction log, newest first")
-        .option("--before <version>", "Only transactions below this version")
-        .option("--limit <count>", "Page size (max 500)", "50")
-        .option("--operations", "Include full operations and inverses in --json output")
-        .addHelpText("after", `
-Every applied mutation is one transaction. --json prints the page summary; add
---operations for the full payloads, inverses and (on the newest page) the current
-node and connection rows, which is what the web replay view consumes.`)).action(async (target, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            // The snapshot is only ever printed in full --json --operations output;
-            // every other mode would fetch the whole Board just to drop it.
-            const full = jsonRequested(options) && Boolean(options.operations);
-            const page = await board.transactions({
-                ...(options.before !== undefined ? { before: finite(options.before, "--before") } : {}),
-                limit: finite(options.limit, "--limit", 50),
-                snapshot: full,
-            });
-            if (jsonRequested(options)) {
-                return json(full
-                    ? page
-                    : {
-                        ...page,
-                        transactions: page.transactions.map(({ operations, ...transaction }) => ({
-                            ...transaction,
-                            operationCount: operations.length,
-                        })),
-                    });
-            }
-            table(transactionRows(page.transactions), columns);
-            if (page.nextBefore !== null) {
-                console.log(`\nOlder transactions: --before ${page.nextBefore}`);
-            }
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}