@agent-canvas/cli 0.8.0 → 0.9.0

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

@@ -0,0 +1,117 @@
+import { describe, it, expect, vi } from 'vitest';
+import { moveElements } from '../move-elements';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, movedCount: 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('moveElements', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should parse comma-separated element IDs correctly', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, movedCount: 2 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveElements({ elementIds: 'id1, id2', deltaX: 100, deltaY: 50 }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'moveElements',
+                id: 'test-id',
+                params: {
+                    elementIds: ['id1', 'id2'],
+                    deltaX: 100,
+                    deltaY: 50,
+                },
+            }));
+        });
+        it('should pass deltaX and deltaY correctly', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, movedCount: 1 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveElements({ elementIds: 'id1', deltaX: 200, deltaY: -100 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.deltaX).toBe(200);
+            expect(callParams.deltaY).toBe(-100);
+        });
+        it('should handle negative deltas', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, movedCount: 1 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveElements({ elementIds: 'id1', deltaX: -50, deltaY: -75 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.deltaX).toBe(-50);
+            expect(callParams.deltaY).toBe(-75);
+        });
+        it('should trim whitespace from element IDs', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, movedCount: 3 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveElements({ elementIds: '  id1  ,  id2  ,  id3  ', deltaX: 10, deltaY: 20 }, deps);
+            const callParams = mockSend.mock.calls[0][0].params;
+            expect(callParams.elementIds).toEqual(['id1', 'id2', 'id3']);
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with moved count', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, movedCount: 4 }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveElements({ elementIds: 'id1,id2,id3,id4', deltaX: 50, deltaY: 50 }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Moved 4 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 moveElements({ elementIds: 'invalid-id', deltaX: 10, deltaY: 10 }, 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, movedCount: 1 }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveElements({ elementIds: 'id1', deltaX: 10, deltaY: 20 }, 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 moveElements({ elementIds: 'id1', deltaX: 0, deltaY: 0 }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,113 @@
+import { describe, it, expect, vi } from 'vitest';
+import { newCanvas } from '../new-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('newCanvas', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with name and switchTo=false', 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 newCanvas({ name: 'My Canvas' }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'createCanvas',
+                id: 'test-id',
+                params: {
+                    name: 'My Canvas',
+                    switchTo: false,
+                },
+            }));
+        });
+        it('should send switchTo=true when use is true', 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 newCanvas({ name: 'My Canvas', use: true }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                params: {
+                    name: 'My Canvas',
+                    switchTo: true,
+                },
+            }));
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message without switch text when use=false', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                canvas: { name: 'New Canvas' },
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await newCanvas({ name: 'New Canvas', use: false }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Canvas "New Canvas" created');
+        });
+        it('should log success message with switch text when use=true', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                canvas: { name: 'New Canvas' },
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await newCanvas({ name: 'New Canvas', use: true }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Canvas "New Canvas" created and switched to it');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Canvas name already exists',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await newCanvas({ name: 'Test' }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Canvas name already exists');
+            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 newCanvas({ 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 newCanvas({ name: 'Test' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,247 @@
+import { describe, it, expect, vi } from 'vitest';
+import { read } from '../read';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, elements: [] })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        toToon: vi.fn((data) => JSON.stringify(data)),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('read', () => {
+    // ==================== JSON Mode Tests ====================
+    describe('json mode', () => {
+        it('should call saveScene when --json is specified', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                data: { elements: [], appState: {} },
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await read({ json: true }, deps);
+            expect(mockSend).toHaveBeenCalledWith({
+                type: 'saveScene',
+                id: 'test-id',
+            });
+        });
+        it('should output JSON data on success', async () => {
+            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)),
+            });
+            await read({ json: true }, deps);
+            expect(deps.log).toHaveBeenCalledWith(JSON.stringify(sceneData, null, 2));
+        });
+        it('should error and exit on json mode failure', 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 read({ json: true }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Connection lost');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+    });
+    // ==================== TOON Mode Tests ====================
+    describe('toon mode (default)', () => {
+        it('should call readScene in default mode', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elements: [],
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await read({}, deps);
+            expect(mockSend).toHaveBeenCalledWith({
+                type: 'readScene',
+                id: 'test-id',
+            });
+        });
+        it('should call toToon with converted data', async () => {
+            const mockToToon = vi.fn(() => 'toon-output');
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elements: [
+                    { id: 'rect-1', type: 'rectangle', x: 100, y: 200, width: 150, height: 80 },
+                ],
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                toToon: mockToToon,
+            });
+            await read({}, deps);
+            expect(mockToToon).toHaveBeenCalled();
+            const calls = mockToToon.mock.calls;
+            const callArg = calls[0]?.[0];
+            expect(callArg).toBeDefined();
+            expect(callArg).toHaveProperty('shapes');
+            expect(callArg).toHaveProperty('lines');
+            expect(callArg).toHaveProperty('labels');
+            expect(callArg).toHaveProperty('texts');
+            expect(callArg).toHaveProperty('images');
+            expect(callArg).toHaveProperty('groups');
+        });
+        it('should output TOON format on success', async () => {
+            const mockToToon = vi.fn(() => 'formatted-toon-output');
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elements: [],
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                toToon: mockToToon,
+            });
+            await read({}, deps);
+            expect(deps.log).toHaveBeenCalledWith('formatted-toon-output');
+        });
+        it('should output selected elements when present', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elements: [],
+                selectedElementIds: ['el-1', 'el-2'],
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await read({}, deps);
+            expect(deps.log).toHaveBeenCalledWith('\nSelected: el-1, el-2');
+        });
+        it('should not output selected elements when empty', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elements: [],
+                selectedElementIds: [],
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await read({}, deps);
+            // Should only be called once (for the TOON output)
+            expect(deps.log).toHaveBeenCalledTimes(1);
+        });
+        it('should error and exit on failure', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Read failed',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await read({}, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Read failed');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+    });
+    // ==================== withStyle Tests ====================
+    describe('withStyle option', () => {
+        it('should pass withStyle=false by default', async () => {
+            const mockToToon = vi.fn(() => 'output');
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elements: [
+                    { id: 'rect-1', type: 'rectangle', x: 0, y: 0, strokeColor: '#ff0000' },
+                ],
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                toToon: mockToToon,
+            });
+            await read({}, deps);
+            const calls = mockToToon.mock.calls;
+            const callArg = calls[0]?.[0];
+            expect(callArg).toBeDefined();
+            expect(callArg.shapes[0]).not.toHaveProperty('stroke');
+        });
+        it('should include style when withStyle=true', async () => {
+            const mockToToon = vi.fn(() => 'output');
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                elements: [
+                    { id: 'rect-1', type: 'rectangle', x: 0, y: 0, strokeColor: '#ff0000', backgroundColor: '#00ff00' },
+                ],
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+                toToon: mockToToon,
+            });
+            await read({ withStyle: true }, deps);
+            const calls = mockToToon.mock.calls;
+            const callArg = calls[0]?.[0];
+            expect(callArg).toBeDefined();
+            expect(callArg.shapes[0].stroke).toBe('#ff0000');
+            expect(callArg.shapes[0].bg).toBe('#00ff00');
+        });
+    });
+    // ==================== Client Lifecycle Tests ====================
+    describe('client lifecycle', () => {
+        it('should close client after json mode success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, data: {} }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await read({ json: true }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after json mode 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 read({ json: true }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after toon mode success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, elements: [] }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await read({}, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after toon mode 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 read({}, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi } from 'vitest';
+import { renameCanvas } from '../rename-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('renameCanvas', () => {
+    // ==================== Parameter Assembly Tests ====================
+    describe('parameter assembly', () => {
+        it('should send correct params with newName', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, canvas: { name: 'New Name' } }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await renameCanvas({ newName: 'New Name' }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'renameCanvas',
+                id: 'test-id',
+                params: {
+                    newName: 'New Name',
+                },
+            }));
+        });
+    });
+    // ==================== Response Handling Tests ====================
+    describe('response handling', () => {
+        it('should log success message with new canvas name', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                canvas: { name: 'Renamed Canvas' },
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await renameCanvas({ newName: 'Renamed Canvas' }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Canvas renamed to "Renamed Canvas"');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Name already in use',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await renameCanvas({ newName: 'Duplicate' }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Name already in use');
+            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 renameCanvas({ newName: '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 renameCanvas({ newName: 'Test' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

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

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