@creator-notes/cli 0.1.0

package/dist/commands/canvas.js

@@ -0,0 +1,721 @@
+import { Option } from "commander";
+import { ApiClient } from "../lib/api-client.js";
+import { resolveConfig } from "../lib/config.js";
+import { handleError, ValidationError } from "../lib/errors.js";
+import { outputJson, outputTable, outputQuiet, truncate, timeAgo } from "../lib/output.js";
+export function registerCanvasCommands(program) {
+    const canvas = program
+        .command("canvas")
+        .alias("c")
+        .description("Manage canvases");
+    canvas
+        .command("list")
+        .description("List canvases in the current workspace")
+        .option("--include-archived", "Include archived canvases")
+        .action(async (opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const params = { workspaceId: cfg.workspaceId };
+            if (opts.includeArchived) {
+                params.includeArchived = "true";
+            }
+            const data = await api.get("/api/canvas", params);
+            const list = data.canvases || data;
+            if (cfg.json) {
+                outputJson(list);
+                return;
+            }
+            const items = Array.isArray(list) ? list : [];
+            if (items.length === 0) {
+                console.log("No canvases found.");
+                return;
+            }
+            const rows = items.map((c) => [
+                String(c._id || c.id || ""),
+                truncate(String(c.name || "(unnamed)"), 30),
+                c.isDefault ? "(default)" : c.archivedAt ? "(archived)" : "",
+                c.updatedAt ? timeAgo(c.updatedAt) : "",
+            ]);
+            outputTable(["ID", "NAME", "", "UPDATED"], rows);
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("get")
+        .description("Get canvas details with nodes and edges")
+        .argument("<canvasId>", "Canvas ID")
+        .action(async (canvasId) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.get(`/api/canvas/${canvasId}`);
+            if (cfg.json) {
+                outputJson(data);
+                return;
+            }
+            console.log(`Canvas: ${data.name || "(unnamed)"}`);
+            console.log(`ID: ${canvasId}`);
+            const nodes = data.nodes;
+            const edges = data.edges;
+            if (nodes && nodes.length > 0) {
+                console.log(`\nNodes (${nodes.length}):`);
+                for (const node of nodes) {
+                    const noteTitle = node.note?.title || node.content || node.noteId || "?";
+                    console.log(`  ${node._id || node.id}: ${noteTitle} (${node.positionX}, ${node.positionY})`);
+                }
+            }
+            if (edges && edges.length > 0) {
+                console.log(`\nEdges (${edges.length}):`);
+                for (const edge of edges) {
+                    const label = edge.label ? ` [${edge.label}]` : "";
+                    console.log(`  ${edge.sourceNodeId} -> ${edge.targetNodeId}${label}`);
+                }
+            }
+            const linkNodes = data.canvasLinkNodes;
+            if (linkNodes && linkNodes.length > 0) {
+                console.log(`\nCanvas Links (${linkNodes.length}):`);
+                for (const ln of linkNodes) {
+                    const linked = ln.linkedCanvas;
+                    const name = linked?.name || ln.linkedCanvasId || "?";
+                    console.log(`  ${ln.id}: -> ${name} (${ln.positionX}, ${ln.positionY})`);
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("digest")
+        .description("Get the AI-generated digest (summary) of a canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .action(async (canvasId) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.get(`/api/canvas/${canvasId}/digest`);
+            if (cfg.json) {
+                outputJson(data);
+                return;
+            }
+            const status = String(data.status || "none");
+            if (status === "none") {
+                console.log("No digest available for this canvas.");
+                return;
+            }
+            if (status !== "ready") {
+                console.log(`Digest status: ${status} — try again shortly.`);
+                return;
+            }
+            const canvasName = data.canvasName || "(unnamed)";
+            console.log(`Canvas: ${canvasName}\n`);
+            console.log(String(data.digest || ""));
+            const themes = data.themes;
+            if (themes && themes.length > 0) {
+                console.log(`\nThemes:`);
+                for (const t of themes) {
+                    console.log(`  • ${t}`);
+                }
+            }
+            const noteCount = data.noteCount || 0;
+            console.log(`\nNotes: ${noteCount}`);
+            if (data.generatedAt) {
+                console.log(`Generated: ${timeAgo(data.generatedAt)}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("create")
+        .description("Create a new canvas")
+        .argument("<name>", "Canvas name")
+        .action(async (name) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.post("/api/canvas", {
+                workspaceId: cfg.workspaceId,
+                title: name,
+            });
+            if (cfg.quiet) {
+                outputQuiet(String(data._id || data.id || ""));
+                return;
+            }
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Created canvas: ${name}`);
+                console.log(`ID: ${data._id || data.id}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("delete")
+        .description("Delete a canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .action(async (canvasId) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.delete(`/api/canvas/${canvasId}`);
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Deleted canvas ${canvasId}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("set-as-home")
+        .description("Set a canvas as the workspace home/default canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .action(async (canvasId) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "setAsHome",
+            });
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Canvas ${canvasId} set as workspace home.`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("archive")
+        .description("Archive a canvas (soft delete)")
+        .argument("<canvasId>", "Canvas ID")
+        .action(async (canvasId) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "archive",
+            });
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Archived canvas ${canvasId}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("unarchive")
+        .description("Unarchive (restore) an archived canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .action(async (canvasId) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "unarchive",
+            });
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Unarchived canvas ${canvasId}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("add-node")
+        .description("Add a note to a canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .requiredOption("--note <noteId>", "Note display ID or Convex ID")
+        .option("--x <n>", "X position", "100")
+        .option("--y <n>", "Y position", "100")
+        .action(async (canvasId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "addNode",
+                noteId: opts.note,
+                positionX: parseInt(opts.x, 10),
+                positionY: parseInt(opts.y, 10),
+            });
+            if (cfg.quiet) {
+                outputQuiet(String(data.nodeId || data._id || ""));
+                return;
+            }
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Added note ${opts.note} to canvas at (${opts.x}, ${opts.y})`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("add-text")
+        .description("Add a text annotation to a canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .requiredOption("--text <content>", "Text content")
+        .addOption(new Option("--size <size>", "Text size: heading (default, larger) or paragraph (smaller readable text)").choices(["heading", "paragraph"]).default("heading"))
+        .option("--x <n>", "X position", "100")
+        .option("--y <n>", "Y position", "100")
+        .action(async (canvasId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        const fontSize = opts.size === "paragraph" ? 18 : 32;
+        try {
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "addTextNode",
+                content: opts.text,
+                fontSize,
+                positionX: parseInt(opts.x, 10),
+                positionY: parseInt(opts.y, 10),
+            });
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Added text node to canvas at (${opts.x}, ${opts.y})`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("add-list")
+        .description("Add a list/grid node grouping notes on a canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .requiredOption("--name <name>", "List name")
+        .option("--notes <ids>", "Note IDs (comma-separated, display IDs like TASK-6 or Convex IDs)")
+        .option("--view <mode>", "View mode: list or grid", "list")
+        .option("--x <n>", "X position", "100")
+        .option("--y <n>", "Y position", "100")
+        .action(async (canvasId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            if (opts.view !== "list" && opts.view !== "grid") {
+                throw new ValidationError(`Invalid view mode "${opts.view}". Must be "list" or "grid".`);
+            }
+            const noteIds = opts.notes ? opts.notes.split(",").map((id) => id.trim()) : [];
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "addListNode",
+                name: opts.name,
+                noteIds: noteIds.length > 0 ? noteIds : undefined,
+                viewMode: opts.view,
+                positionX: parseInt(opts.x, 10),
+                positionY: parseInt(opts.y, 10),
+            });
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Added "${opts.name}" (${opts.view}) with ${noteIds.length} notes to canvas`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("add-link")
+        .description("Add a link to another canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .requiredOption("--target <canvasId>", "Target canvas ID to link to")
+        .option("--x <n>", "X position", "100")
+        .option("--y <n>", "Y position", "100")
+        .action(async (canvasId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "addCanvasLink",
+                linkedCanvasId: opts.target,
+                positionX: parseInt(opts.x, 10),
+                positionY: parseInt(opts.y, 10),
+            });
+            if (cfg.quiet) {
+                outputQuiet(String(data.nodeId || data._id || ""));
+                return;
+            }
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Added link to canvas ${opts.target} at (${opts.x}, ${opts.y})`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("bulk-add")
+        .description("Add multiple notes to a canvas in one operation with positions")
+        .argument("<canvasId>", "Canvas ID")
+        .requiredOption("--notes <json>", "JSON array of {noteId, x, y} objects")
+        .action(async (canvasId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            let items;
+            try {
+                items = JSON.parse(opts.notes);
+            }
+            catch {
+                throw new ValidationError("--notes must be valid JSON array, e.g. '[{\"noteId\":\"TASK-1\",\"x\":100,\"y\":200}]'");
+            }
+            if (!Array.isArray(items) || items.length === 0) {
+                throw new ValidationError("--notes must be a non-empty JSON array");
+            }
+            const notes = items.map((item, i) => {
+                const positionX = Number(item.x);
+                const positionY = Number(item.y);
+                if (isNaN(positionX) || isNaN(positionY)) {
+                    throw new ValidationError(`Item ${i}: x and y must be numbers`);
+                }
+                return {
+                    noteId: String(item.noteId),
+                    positionX,
+                    positionY,
+                };
+            });
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "bulkAddNodes",
+                notes,
+            });
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                const results = (data.results || []);
+                const added = results.filter((r) => r.status === "added").length;
+                const skipped = results.filter((r) => r.status !== "added").length;
+                console.log(`Added ${added} notes to canvas${skipped > 0 ? ` (${skipped} skipped/failed)` : ""}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("bulk-move")
+        .description("Move multiple nodes to new positions in one operation")
+        .argument("<canvasId>", "Canvas ID (used for routing/auth)")
+        .requiredOption("--moves <json>", "JSON array of {nodeId, nodeType, x, y} objects (nodeType: note|text|list|canvas)")
+        .action(async (canvasId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            let items;
+            try {
+                items = JSON.parse(opts.moves);
+            }
+            catch {
+                throw new ValidationError("--moves must be valid JSON array, e.g. '[{\"nodeId\":\"abc\",\"nodeType\":\"note\",\"x\":100,\"y\":200}]'");
+            }
+            if (!Array.isArray(items) || items.length === 0) {
+                throw new ValidationError("--moves must be a non-empty JSON array");
+            }
+            const validNodeTypes = new Set(["note", "text", "list", "canvas"]);
+            const moves = items.map((item, i) => {
+                const positionX = Number(item.x);
+                const positionY = Number(item.y);
+                if (isNaN(positionX) || isNaN(positionY)) {
+                    throw new ValidationError(`Item ${i}: x and y must be numbers`);
+                }
+                const nodeType = item.nodeType || "note";
+                if (!validNodeTypes.has(nodeType)) {
+                    throw new ValidationError(`Item ${i}: nodeType must be one of: note, text, list, canvas`);
+                }
+                return {
+                    nodeId: String(item.nodeId),
+                    nodeType: nodeType,
+                    positionX,
+                    positionY,
+                };
+            });
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "bulkMoveNodes",
+                moves,
+            });
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                const count = typeof data.count === "number" ? data.count : moves.length;
+                console.log(`Moved ${count} nodes`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("bulk-remove")
+        .description("Remove multiple nodes from a canvas in one operation")
+        .argument("<canvasId>", "Canvas ID")
+        .requiredOption("--nodes <json>", "JSON array of node ID strings, e.g. '[\"nodeId1\",\"nodeId2\"]'")
+        .action(async (canvasId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            let nodeIds;
+            try {
+                nodeIds = JSON.parse(opts.nodes);
+            }
+            catch {
+                throw new ValidationError("--nodes must be valid JSON array, e.g. '[\"nodeId1\",\"nodeId2\"]'");
+            }
+            if (!Array.isArray(nodeIds) || nodeIds.length === 0) {
+                throw new ValidationError("--nodes must be a non-empty JSON array of strings");
+            }
+            nodeIds = nodeIds.map(String);
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "bulkRemoveNodes",
+                nodeIds,
+            });
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                const results = (data.results || []);
+                const deleted = results.filter((r) => r.status === "deleted").length;
+                const failed = results.filter((r) => r.status !== "deleted").length;
+                console.log(`Removed ${deleted} nodes from canvas${failed > 0 ? ` (${failed} failed)` : ""}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("add-edge")
+        .description("Connect two nodes on a canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .requiredOption("--source <nodeId>", "Source node ID")
+        .requiredOption("--target <nodeId>", "Target node ID")
+        .option("--label <text>", "Edge label")
+        .action(async (canvasId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.post(`/api/canvas/${canvasId}`, {
+                action: "addEdge",
+                sourceNodeId: opts.source,
+                targetNodeId: opts.target,
+                label: opts.label,
+            });
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                const label = opts.label ? ` [${opts.label}]` : "";
+                console.log(`Connected ${opts.source} -> ${opts.target}${label}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("move-node")
+        .description("Move a node to a new position on a canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .requiredOption("--node <nodeId>", "Canvas node ID")
+        .requiredOption("--x <n>", "X position")
+        .requiredOption("--y <n>", "Y position")
+        .action(async (canvasId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const positionX = Number(opts.x);
+            const positionY = Number(opts.y);
+            await api.post(`/api/canvas/${canvasId}`, {
+                action: "moveNode",
+                nodeId: opts.node,
+                positionX,
+                positionY,
+            });
+            if (cfg.json) {
+                outputJson({ success: true, nodeId: opts.node, positionX, positionY });
+            }
+            else {
+                console.log(`Moved node ${opts.node} to (${positionX}, ${positionY})`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("remove-node")
+        .description("Remove a node from a canvas")
+        .argument("<canvasId>", "Canvas ID")
+        .requiredOption("--node <nodeId>", "Canvas node ID")
+        .action(async (canvasId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            await api.post(`/api/canvas/${canvasId}`, {
+                action: "removeNode",
+                nodeId: opts.node,
+            });
+            if (cfg.json) {
+                outputJson({ success: true, nodeId: opts.node });
+            }
+            else {
+                console.log(`Removed node ${opts.node} from canvas`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    // ---- Template commands ----
+    canvas
+        .command("templates")
+        .description("List available canvas templates")
+        .action(async () => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.get("/api/canvas/template");
+            const templates = data.templates || [];
+            if (cfg.json) {
+                outputJson(templates);
+                return;
+            }
+            if (templates.length === 0) {
+                console.log("No templates available.");
+                return;
+            }
+            const rows = templates.map((t) => [
+                String(t.id || ""),
+                String(t.name || ""),
+                truncate(String(t.description || ""), 40),
+                String(t.category || ""),
+                String(t.zoneCount || 0),
+            ]);
+            outputTable(["ID", "NAME", "DESCRIPTION", "CATEGORY", "ZONES"], rows);
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    canvas
+        .command("from-template")
+        .description("Create a canvas from a predefined template")
+        .argument("<templateId>", "Template ID (use 'cn canvas templates' to list)")
+        .option("--title <title>", "Custom canvas title")
+        .option("--density <mode>", "Layout density: tight, medium, or spacious")
+        .option("--populate", "Auto-populate zones with matching notes from workspace")
+        .action(async (templateId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            // Validate template exists by fetching template list
+            const templateData = await api.get("/api/canvas/template");
+            const templates = templateData.templates || [];
+            const template = templates.find((t) => t.id === templateId);
+            if (!template) {
+                const available = templates.map((t) => t.id).join(", ");
+                throw new ValidationError(`Unknown template "${templateId}". Available: ${available}`);
+            }
+            // Validate density (must match LAYOUT_DENSITIES in lib/canvas/templates/types.ts)
+            const validDensities = ["tight", "medium", "spacious"];
+            if (opts.density && !validDensities.includes(opts.density)) {
+                throw new ValidationError(`Invalid density "${opts.density}". Must be: ${validDensities.join(", ")}`);
+            }
+            // If --populate, search notes for each zone
+            let zonePopulations;
+            if (opts.populate) {
+                zonePopulations = [];
+                const zones = template.zones;
+                if (zones) {
+                    for (const zone of zones) {
+                        const hint = zone.populationHint;
+                        if (!hint || hint.startsEmpty)
+                            continue;
+                        const searchQuery = hint.searchQuery;
+                        const noteTypes = hint.noteTypes;
+                        const maxNotes = hint.maxNotes || 8;
+                        // Search for matching notes
+                        const searchParams = {
+                            workspaceId: cfg.workspaceId,
+                            limit: String(maxNotes),
+                        };
+                        if (searchQuery)
+                            searchParams.search = searchQuery;
+                        if (noteTypes && noteTypes.length > 0)
+                            searchParams.types = noteTypes.join(",");
+                        try {
+                            const searchResult = await api.get("/api/notes", searchParams);
+                            const notes = searchResult.notes || [];
+                            if (notes.length > 0) {
+                                zonePopulations.push({
+                                    zoneId: String(zone.id),
+                                    noteIds: notes.map((n) => String(n.displayId || n.id || n._id)),
+                                });
+                            }
+                        }
+                        catch {
+                            // Search failed for this zone, continue without population
+                        }
+                    }
+                }
+            }
+            // Create canvas from template
+            const data = await api.post("/api/canvas/template", {
+                workspaceId: cfg.workspaceId,
+                templateId,
+                title: opts.title,
+                density: opts.density,
+                zonePopulations,
+            });
+            if (cfg.quiet) {
+                outputQuiet(String(data.canvasId || ""));
+                return;
+            }
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                const name = opts.title || template.name;
+                console.log(`Created canvas from template "${templateId}": ${name}`);
+                console.log(`Canvas ID: ${data.canvasId}`);
+                console.log(`Zones: ${data.zoneCount}, Notes: ${data.noteCount}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+}
+//# sourceMappingURL=canvas.js.map