@neta-art/cohub-cli 8.4.0 → 9.0.0

package/dist/commands/boards/connections.js

@@ -1,95 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { createBoardConnection } from "@neta-art/cohub/board";
-import { handleHttp, json, jsonRequested, table } from "../../output.js";
-import { mutateSemantic, readInput, readOptions, resolvedBoard, showUpdated, withJson, } from "./context.js";
-const columns = [
-    { key: "id", label: "ID" },
-    { key: "source", label: "SOURCE" },
-    { key: "target", label: "TARGET" },
-    { key: "relation", label: "RELATION" },
-    { key: "direction", label: "DIRECTION" },
-    { key: "label", label: "LABEL" },
-];
-function rows(connections) {
-    return connections.map((connection) => ({
-        id: connection.id,
-        source: connection.source.itemId,
-        target: connection.target.itemId,
-        relation: connection.relation ?? "",
-        direction: connection.direction ?? "",
-        label: connection.label ?? "",
-    }));
-}
-export function registerBoardConnectionCommands(boards) {
-    const connections = boards.command("connections").description("Manage Board connections");
-    readOptions(withJson(connections.command("list <board>").alias("ls").description("List Board connections")))
-        .action(async (target, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring(readInput(options, "connections"));
-            const value = result.connections ?? [];
-            if (jsonRequested(options))
-                return json(value);
-            table(rows(value), columns);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(connections.command("get <board> <connection-id>").description("Get one complete Board connection"))
-        .action(async (target, connectionId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring({ include: ["connections"], connectionIds: [connectionId] });
-            const connection = result.connections?.[0];
-            if (!connection)
-                throw new Error(`Connection not found: ${connectionId}`);
-            if (jsonRequested(options))
-                return json(connection);
-            table(rows([connection]), columns);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(connections.command("create <board> <source> <target>").description("Create a Board connection")
-        .option("--id <id>", "Connection id")
-        .option("--relation <relation>", "Relation type")
-        .option("--direction <direction>", "none, forward, backward, or both", "forward")
-        .option("--label <label>", "Connection label")
-        .option("--source-port <id>", "Source port id")
-        .option("--target-port <id>", "Target port id"))
-        .action(async (target, source, destination, options) => {
-        try {
-            const direction = options.direction ?? "forward";
-            if (!["none", "forward", "backward", "both"].includes(direction)) {
-                throw new Error("--direction must be none, forward, backward, or both");
-            }
-            const board = await resolvedBoard(boards, target);
-            const connection = createBoardConnection({
-                id: options.id ?? randomUUID(),
-                sourceItemId: source,
-                targetItemId: destination,
-                relation: options.relation,
-                direction: direction,
-                label: options.label,
-                sourcePortId: options.sourcePort,
-                targetPortId: options.targetPort,
-            });
-            showUpdated(await mutateSemantic(board, [{ type: "connection.create", connection }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(connections.command("delete <board> <connection-id>").alias("rm").description("Delete a Board connection"))
-        .action(async (target, connectionId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "connection.delete", connectionId }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}

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

@@ -1,31 +0,0 @@
-import type { BoardAuthoringReadInput, BoardClient, BoardSemanticCommand } from "@neta-art/cohub";
-import type { Command } from "commander";
-export type JsonOptions = {
-    json?: boolean;
-};
-export type ReadOptions = JsonOptions & {
-    ids?: string;
-};
-export declare function withJson(command: Command): Command;
-export declare function finite(value: string | undefined, name: string, fallback?: number): number;
-export declare function readInput(options: ReadOptions, section: NonNullable<BoardAuthoringReadInput["include"]>[number]): BoardAuthoringReadInput;
-export declare function readOptions(command: Command, label?: string): Command;
-export declare function resolvedBoard(boards: Command, target: string): Promise<BoardClient>;
-/**
- * Send semantic commands with one automatic version-conflict retry when the
- * caller did not pin a base version. An explicit `baseVersion` is a strict
- * optimistic-concurrency check and must fail instead of being rebased.
- */
-export declare function mutateSemantic(board: BoardClient, commands: BoardSemanticCommand[], options?: {
-    baseVersion?: number;
-    mutationId?: string;
-    dryRun?: boolean;
-}): Promise<import("@neta-art/cohub").BoardMutationReceipt>;
-export declare function showUpdated(result: {
-    board: {
-        version: number;
-    };
-    status?: string;
-    outcome?: string;
-    replayed?: boolean;
-}, options: JsonOptions): void;

package/dist/commands/boards/context.js

@@ -1,71 +0,0 @@
-import { createClient } from "../../client.js";
-import { resolveBoardId } from "../../board-command-support.js";
-import { json, jsonRequested, ok } from "../../output.js";
-import { resolveSpace } from "../../space.js";
-export function withJson(command) {
-    return command.option("--json", "Output as JSON");
-}
-export function finite(value, name, fallback) {
-    if (value === undefined && fallback !== undefined)
-        return fallback;
-    const result = Number(value);
-    if (!Number.isFinite(result))
-        throw new Error(`${name} must be a finite number`);
-    return result;
-}
-export function readInput(options, section) {
-    const ids = options.ids?.split(",").map((id) => id.trim()).filter(Boolean);
-    return {
-        include: [section],
-        ...(ids?.length ? { [`${section.slice(0, -1)}Ids`]: ids } : {}),
-    };
-}
-export function readOptions(command, label = "Comma-separated resource IDs") {
-    return command.option("--ids <ids>", label);
-}
-export async function resolvedBoard(boards, target) {
-    const spaceId = await resolveSpace(boards);
-    const boardId = await resolveBoardId(spaceId, target);
-    return createClient().space(spaceId).board(boardId);
-}
-/**
- * Send semantic commands with one automatic version-conflict retry when the
- * caller did not pin a base version. An explicit `baseVersion` is a strict
- * optimistic-concurrency check and must fail instead of being rebased.
- */
-export async function mutateSemantic(board, commands, options = {}) {
-    const pinnedVersion = options.baseVersion;
-    const baseVersion = pinnedVersion ?? (await board.summary()).board.version;
-    const send = (version) => board.mutateSemantic({
-        mutationId: options.mutationId,
-        baseVersion: version,
-        dryRun: options.dryRun ?? false,
-        commands,
-    });
-    try {
-        return await send(baseVersion);
-    }
-    catch (cause) {
-        if (options.dryRun || pinnedVersion !== undefined || !isVersionConflict(cause))
-            throw cause;
-        const retry = (await board.summary()).board.version;
-        return send(retry);
-    }
-}
-function isVersionConflict(error) {
-    return Boolean(error && typeof error === "object" &&
-        error.code === "VERSION_CONFLICT");
-}
-export function showUpdated(result, options) {
-    if (jsonRequested(options))
-        return json(result);
-    if (result.outcome === "dry-run") {
-        ok(`Validated against Board version ${result.board.version}; no changes written`);
-        return;
-    }
-    if (result.outcome === "noop" || result.status === "validated") {
-        ok(`Board already matches the requested state at version ${result.board.version}`);
-        return;
-    }
-    ok(`Board updated to version ${result.board.version}${result.replayed ? " (replayed)" : ""}`);
-}

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

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerBoardItemCommands(boards: Command): void;

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);
-        }
-    });
-}