@agent-canvas/cli 0.8.0 → 0.9.0

package/dist/commands/__tests__/add-shape.test.js

@@ -0,0 +1,193 @@
+import { describe, it, expect, vi } from 'vitest';
+import { addShape } from '../add-shape';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' })),
+        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('addShape', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with required options only', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addShape({ type: 'rectangle', x: 100, y: 200 }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'addShape',
+                id: 'test-id',
+                params: expect.objectContaining({
+                    type: 'rectangle',
+                    x: 100,
+                    y: 200,
+                }),
+            }));
+            // customData should be undefined when no note
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toBeUndefined();
+            // label should be undefined when no label
+            expect(callParams.label).toBeUndefined();
+        });
+        it('should send correct style params', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addShape({
+                type: 'ellipse',
+                x: 50,
+                y: 60,
+                width: 200,
+                height: 100,
+                strokeColor: '#ff0000',
+                backgroundColor: '#00ff00',
+                strokeWidth: 2,
+                strokeStyle: 'dashed',
+                fillStyle: 'solid',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.type).toBe('ellipse');
+            expect(callParams.x).toBe(50);
+            expect(callParams.y).toBe(60);
+            expect(callParams.width).toBe(200);
+            expect(callParams.height).toBe(100);
+            expect(callParams.strokeColor).toBe('#ff0000');
+            expect(callParams.backgroundColor).toBe('#00ff00');
+            expect(callParams.strokeWidth).toBe(2);
+            expect(callParams.strokeStyle).toBe('dashed');
+            expect(callParams.fillStyle).toBe('solid');
+        });
+        it('should set label with text and fontSize when label is provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addShape({
+                type: 'rectangle',
+                x: 100,
+                y: 100,
+                label: 'Hello World',
+                labelFontSize: 24,
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.label).toEqual({ text: 'Hello World', fontSize: 24 });
+        });
+        it('should set label without fontSize when labelFontSize is not provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addShape({
+                type: 'diamond',
+                x: 100,
+                y: 100,
+                label: 'No font size',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.label).toEqual({ text: 'No font size', fontSize: undefined });
+        });
+        it('should not include label field when label is not provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addShape({ type: 'rectangle', x: 0, y: 0 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.label).toBeUndefined();
+        });
+        it('should set customData with note when note is provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addShape({
+                type: 'rectangle',
+                x: 100,
+                y: 100,
+                note: 'my note',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toEqual({ note: 'my note' });
+        });
+        it('should not include customData when note is not provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addShape({ type: 'rectangle', x: 0, y: 0 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toBeUndefined();
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with dimensions when provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elementId: 'el-123',
+                x: 100,
+                y: 200,
+                width: 300,
+                height: 400,
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addShape({ type: 'rectangle', x: 100, y: 200 }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Shape created (id: el-123 x=100 y=200 w=300 h=400)');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Something went wrong',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addShape({ type: 'rectangle', x: 0, y: 0 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Something went wrong');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addShape({ type: 'rectangle', x: 0, y: 0 }, 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 addShape({ type: 'rectangle', x: 0, y: 0 }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/add-text.test.d.ts

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

package/dist/commands/__tests__/add-text.test.js

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi } from 'vitest';
+import { addText } from '../add-text';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' })),
+        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('addText', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with required options only', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addText({ text: 'Hello World', x: 100, y: 200 }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'addText',
+                id: 'test-id',
+                params: expect.objectContaining({
+                    text: 'Hello World',
+                    x: 100,
+                    y: 200,
+                }),
+            }));
+            // customData should be undefined when no note
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toBeUndefined();
+        });
+        it('should send correct optional params', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addText({
+                text: 'Styled Text',
+                x: 50,
+                y: 60,
+                fontSize: 24,
+                textAlign: 'center',
+                anchor: 'topLeft',
+                strokeColor: '#ff0000',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.text).toBe('Styled Text');
+            expect(callParams.x).toBe(50);
+            expect(callParams.y).toBe(60);
+            expect(callParams.fontSize).toBe(24);
+            expect(callParams.textAlign).toBe('center');
+            expect(callParams.anchor).toBe('topLeft');
+            expect(callParams.strokeColor).toBe('#ff0000');
+        });
+        it('should set customData with note when note is provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addText({
+                text: 'Text with note',
+                x: 100,
+                y: 100,
+                note: 'my note',
+            }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toEqual({ note: 'my note' });
+        });
+        it('should not include customData when note is not provided', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addText({ text: 'No note', x: 0, y: 0 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.customData).toBeUndefined();
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with position and dimensions', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elementId: 'el-123',
+                x: 100,
+                y: 200,
+                width: 150,
+                height: 30,
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addText({ text: 'Test', x: 100, y: 200 }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Text created (id: el-123, x: 100, y: 200, 150x30)');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Something went wrong',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addText({ text: 'Test', x: 0, y: 0 }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Something went wrong');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elementId: 'el-1' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await addText({ text: 'Test', x: 0, y: 0 }, 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 addText({ text: 'Test', x: 0, y: 0 }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi } from 'vitest';
+import { clear } from '../clear';
+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('clear', () => {
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message on success', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await clear(deps);
+            expect(deps.log).toHaveBeenCalledWith('Canvas cleared');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Clear failed',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await clear(deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Clear failed');
+            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 clear(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 clear(deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi } from 'vitest';
+import { deleteElements } from '../delete-elements';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, deletedCount: 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('deleteElements', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should parse comma-separated element IDs correctly', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, deletedCount: 3 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await deleteElements({ elementIds: 'id1, id2, id3' }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'deleteElements',
+                id: 'test-id',
+                params: {
+                    elementIds: ['id1', 'id2', 'id3'],
+                },
+            }));
+        });
+        it('should handle single element ID', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, deletedCount: 1 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await deleteElements({ elementIds: 'single-id' }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.elementIds).toEqual(['single-id']);
+        });
+        it('should trim whitespace from element IDs', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, deletedCount: 2 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await deleteElements({ elementIds: '  id1  ,  id2  ' }, 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 deleted count', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, deletedCount: 5 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await deleteElements({ elementIds: 'id1,id2,id3,id4,id5' }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Deleted 5 element(s)');
+        });
+        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 deleteElements({ elementIds: 'invalid-id' }, 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, deletedCount: 1 }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await deleteElements({ elementIds: 'id1' }, 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 deleteElements({ elementIds: 'id1' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

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

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