@agent-canvas/cli 0.8.0 → 0.9.0

package/dist/commands/__tests__/resize-elements.test.js

@@ -0,0 +1,150 @@
+import { describe, it, expect, vi } from 'vitest';
+import { resizeElements } from '../resize-elements';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, resizedCount: 2 })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('resizeElements', () => {
+    // ==================== Input Validation Tests ====================
+    describe('input validation', () => {
+        it('should error when all direction params are unspecified (default to 0)', async () => {
+            const deps = createMockDeps();
+            await resizeElements({ elementIds: ['el-1', 'el-2'] }, deps);
+            expect(deps.error).toHaveBeenCalledWith('At least one of --top, --bottom, --left, --right must be specified');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+            expect(deps.connectToCanvas).not.toHaveBeenCalled();
+        });
+        it('should error when all direction params are explicitly 0', async () => {
+            const deps = createMockDeps();
+            await resizeElements({
+                elementIds: ['el-1'],
+                top: 0,
+                bottom: 0,
+                left: 0,
+                right: 0,
+            }, deps);
+            expect(deps.error).toHaveBeenCalledWith('At least one of --top, --bottom, --left, --right must be specified');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+            expect(deps.connectToCanvas).not.toHaveBeenCalled();
+        });
+    });
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with elementIds and single direction', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, resizedCount: 1 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await resizeElements({
+                elementIds: ['el-1', 'el-2'],
+                top: 50,
+            }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'resizeElements',
+                id: 'test-id',
+                params: {
+                    elementIds: ['el-1', 'el-2'],
+                    top: 50,
+                    bottom: 0,
+                    left: 0,
+                    right: 0,
+                },
+            }));
+        });
+        it('should send correct params with all directions', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, resizedCount: 2 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await resizeElements({
+                elementIds: ['el-1'],
+                top: 10,
+                bottom: 20,
+                left: 30,
+                right: 40,
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.elementIds).toEqual(['el-1']);
+            expect(callParams.top).toBe(10);
+            expect(callParams.bottom).toBe(20);
+            expect(callParams.left).toBe(30);
+            expect(callParams.right).toBe(40);
+        });
+        it('should default unspecified directions to 0', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, resizedCount: 1 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await resizeElements({
+                elementIds: ['el-1'],
+                left: 25,
+                right: -10,
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.top).toBe(0);
+            expect(callParams.bottom).toBe(0);
+            expect(callParams.left).toBe(25);
+            expect(callParams.right).toBe(-10);
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with count', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, resizedCount: 3 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await resizeElements({ elementIds: ['el-1', 'el-2', 'el-3'], top: 10 }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Resized 3 element(s)');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Invalid element ID',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await resizeElements({ elementIds: ['invalid'], bottom: 5 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Invalid element ID');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, resizedCount: 1 }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await resizeElements({ elementIds: ['el-1'], top: 10 }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await resizeElements({ elementIds: ['el-1'], top: 10 }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/rotate-elements.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/rotate-elements.test.js

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi } from 'vitest';
+import { rotateElements } from '../rotate-elements';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, rotatedCount: 2 })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('rotateElements', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should parse comma-separated element IDs correctly', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, rotatedCount: 2 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await rotateElements({ elementIds: 'id1, id2', angle: 45 }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'rotateElements',
+                id: 'test-id',
+                params: {
+                    elementIds: ['id1', 'id2'],
+                    angle: 45,
+                },
+            }));
+        });
+        it('should pass angle correctly', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, rotatedCount: 1 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await rotateElements({ elementIds: 'id1', angle: 90 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.angle).toBe(90);
+        });
+        it('should handle negative angle', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, rotatedCount: 1 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await rotateElements({ elementIds: 'id1', angle: -45 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.angle).toBe(-45);
+        });
+        it('should trim whitespace from element IDs', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, rotatedCount: 2 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await rotateElements({ elementIds: '  id1  ,  id2  ', angle: 30 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.elementIds).toEqual(['id1', 'id2']);
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with rotated count', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, rotatedCount: 3 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await rotateElements({ elementIds: 'id1,id2,id3', angle: 45 }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Rotated 3 element(s)');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Cannot rotate text element',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await rotateElements({ elementIds: 'text-id', angle: 45 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Cannot rotate text element');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, rotatedCount: 1 }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await rotateElements({ elementIds: 'id1', angle: 90 }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await rotateElements({ elementIds: 'id1', angle: 45 }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/save.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/save.test.js

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi } from 'vitest';
+import { save } from '../save';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, data: { elements: [] } })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        writeFile: vi.fn(),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('save', () => {
+    // ==================== Parameter/Logic Tests ====================
+    describe('filepath handling', () => {
+        it('should auto-add .excalidraw extension if not present', async () => {
+            const mockWriteFile = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, data: { elements: [] } }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                writeFile: mockWriteFile,
+            });
+            await save('mycanvas', deps);
+            expect(mockWriteFile).toHaveBeenCalledWith('mycanvas.excalidraw', expect.any(String));
+            expect(deps.log).toHaveBeenCalledWith('Saved to mycanvas.excalidraw');
+        });
+        it('should not add extension if .excalidraw already present', async () => {
+            const mockWriteFile = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, data: { elements: [] } }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                writeFile: mockWriteFile,
+            });
+            await save('mycanvas.excalidraw', deps);
+            expect(mockWriteFile).toHaveBeenCalledWith('mycanvas.excalidraw', expect.any(String));
+            expect(deps.log).toHaveBeenCalledWith('Saved to mycanvas.excalidraw');
+        });
+        it('should write JSON data correctly', async () => {
+            const mockWriteFile = vi.fn();
+            const sceneData = { elements: [{ id: 'el-1' }], appState: {} };
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, data: sceneData }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                writeFile: mockWriteFile,
+            });
+            await save('test', deps);
+            expect(mockWriteFile).toHaveBeenCalledWith('test.excalidraw', JSON.stringify(sceneData, null, 2));
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message on success', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, data: { elements: [] } }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await save('output', deps);
+            expect(deps.log).toHaveBeenCalledWith('Saved to output.excalidraw');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Connection lost',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await save('output', deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Connection lost');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, data: { elements: [] } }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await save('output', deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await save('output', deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/ungroup-element.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/ungroup-element.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ungroupElement } from '../ungroup-element';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('ungroupElement', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with elementId', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await ungroupElement({ elementId: 'el-123' }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'ungroupElement',
+                id: 'test-id',
+                params: {
+                    elementId: 'el-123',
+                },
+            }));
+        });
+        it('should pass elementId correctly', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await ungroupElement({ elementId: 'complex-element-id-abc' }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.elementId).toBe('complex-element-id-abc');
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await ungroupElement({ elementId: 'el-1' }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Element ungrouped');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Element not found',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await ungroupElement({ elementId: 'non-existent' }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Element not found');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await ungroupElement({ elementId: 'el-1' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await ungroupElement({ elementId: 'el-1' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/use-canvas.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/use-canvas.test.js

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi } from 'vitest';
+import { useCanvas } from '../use-canvas';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, canvas: { name: 'Test' } })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('useCanvas', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with name', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, canvas: { name: 'Target Canvas' } }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await useCanvas({ name: 'Target Canvas' }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'switchCanvas',
+                id: 'test-id',
+                params: {
+                    name: 'Target Canvas',
+                },
+            }));
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with canvas name', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                canvas: { name: 'My Canvas' },
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await useCanvas({ name: 'My Canvas' }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Switched to canvas "My Canvas"');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Canvas not found',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await useCanvas({ name: 'Non-existent' }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Canvas not found');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, canvas: { name: 'Test' } }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await useCanvas({ name: 'Test' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await useCanvas({ name: 'Test' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/add-arrow.d.ts

@@ -0,0 +1,40 @@
+export interface AddArrowOptions {
+    x: number;
+    y: number;
+    endX: number;
+    endY: number;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeStyle?: 'solid' | 'dashed' | 'dotted';
+    startArrowhead?: 'arrow' | 'bar' | 'dot' | 'triangle' | 'diamond' | 'none';
+    endArrowhead?: 'arrow' | 'bar' | 'dot' | 'triangle' | 'diamond' | 'none';
+    arrowType?: 'sharp' | 'round' | 'elbow';
+    via?: string;
+    note?: string;
+}
+export interface ArrowClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface AddArrowDeps {
+    connectToCanvas: () => Promise<ArrowClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: AddArrowDeps;
+/**
+ * Parse via points string into midpoints array
+ * @param via - Points string in format "x1,y1;x2,y2;..."
+ * @returns Array of point objects
+ */
+export declare function parseViaPoints(via: string): Array<{
+    x: number;
+    y: number;
+}>;
+export declare function addArrow(options: AddArrowOptions, deps?: AddArrowDeps): Promise<void>;

package/dist/commands/add-arrow.js

@@ -0,0 +1,52 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+/**
+ * Parse via points string into midpoints array
+ * @param via - Points string in format "x1,y1;x2,y2;..."
+ * @returns Array of point objects
+ */
+export function parseViaPoints(via) {
+    return via.split(';').map((pt) => {
+        const [x, y] = pt.split(',').map(Number);
+        return { x, y };
+    });
+}
+export async function addArrow(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    // Parse --via option into midpoints array
+    const midpoints = options.via ? parseViaPoints(options.via) : undefined;
+    // Build params
+    const params = {
+        x: options.x,
+        y: options.y,
+        endX: options.endX,
+        endY: options.endY,
+        strokeColor: options.strokeColor,
+        strokeWidth: options.strokeWidth,
+        strokeStyle: options.strokeStyle,
+        startArrowhead: options.startArrowhead,
+        endArrowhead: options.endArrowhead,
+        arrowType: options.arrowType,
+        midpoints,
+        customData: options.note ? { note: options.note } : undefined,
+    };
+    const result = await client.send({
+        type: 'addArrow',
+        id: deps.generateId(),
+        params,
+    });
+    if (result.success) {
+        deps.log(`Arrow created (id: ${result.elementId})`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}