@nexical/cli 0.1.0

package/test/unit/commands/branch/delete.test.ts

@@ -0,0 +1,49 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import BranchesDeleteCommand from '../../../../src/commands/branch/delete.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('BranchesDeleteCommand', () => {
+    let command: BranchesDeleteCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            branches: {
+                delete: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new BranchesDeleteCommand([], {} as any);
+        vi.spyOn(command, 'success').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should delete branch successfully', async () => {
+        mockClient.branches.delete.mockResolvedValue({});
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3' });
+
+        expect(mockClient.branches.delete).toHaveBeenCalledWith(1, 2, 3);
+        expect(command.success).toHaveBeenCalledWith('Branch 3 deleted.');
+    });
+
+    it('should validate IDs', async () => {
+        await command.run({ teamId: '1', projectId: 'invalid', branchId: '3' });
+        expect(command.error).toHaveBeenCalledWith('IDs must be numbers.');
+        expect(mockClient.branches.delete).not.toHaveBeenCalled();
+    });
+
+    it('should handle deletion failure', async () => {
+        mockClient.branches.delete.mockRejectedValue(new Error('Not found'));
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to delete branch: Not found');
+    });
+});

package/test/unit/commands/branch/get.test.ts

@@ -0,0 +1,67 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import BranchesGetCommand from '../../../../src/commands/branch/get.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('BranchesGetCommand', () => {
+    let command: BranchesGetCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            branches: {
+                get: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new BranchesGetCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should get branch details successfully', async () => {
+        mockClient.branches.get.mockResolvedValue({
+            id: '100',
+            name: 'main',
+            previewUrl: 'http://test.com'
+        });
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3' });
+
+        expect(mockClient.branches.get).toHaveBeenCalledWith(1, 2, 3);
+        expect(command.info).toHaveBeenCalledWith('Branch Details:');
+        expect(command.info).toHaveBeenCalledWith('  ID:   100');
+        expect(command.info).toHaveBeenCalledWith('  Name: main');
+        expect(command.info).toHaveBeenCalledWith('  Preview: http://test.com');
+    });
+
+    it('should show N/A for missing preview', async () => {
+        mockClient.branches.get.mockResolvedValue({
+            id: '100',
+            name: 'main'
+        });
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3' });
+
+        expect(command.info).toHaveBeenCalledWith('  Preview: N/A');
+    });
+
+    it('should validate IDs', async () => {
+        await command.run({ teamId: '1', projectId: 'invalid', branchId: '3' });
+        expect(command.error).toHaveBeenCalledWith('IDs must be numbers.');
+        expect(mockClient.branches.get).not.toHaveBeenCalled();
+    });
+
+    it('should handle get failure', async () => {
+        mockClient.branches.get.mockRejectedValue(new Error('Not found'));
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to get branch: Not found');
+    });
+});

package/test/unit/commands/branch/list.test.ts

@@ -0,0 +1,62 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import BranchesListCommand from '../../../../src/commands/branch/list.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('BranchesListCommand', () => {
+    let command: BranchesListCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            branches: {
+                list: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new BranchesListCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should list branches successfully', async () => {
+        mockClient.branches.list.mockResolvedValue([
+            { id: '100', name: 'main' },
+            { id: '101', name: 'dev' }
+        ]);
+
+        await command.run({ teamId: '1', projectId: '2' });
+
+        expect(mockClient.branches.list).toHaveBeenCalledWith(1, 2);
+        expect(command.info).toHaveBeenCalledWith('Branches for Project 2:');
+        expect(command.info).toHaveBeenCalledWith('- main (ID: 100)');
+        expect(command.info).toHaveBeenCalledWith('- dev (ID: 101)');
+    });
+
+    it('should handle empty list', async () => {
+        mockClient.branches.list.mockResolvedValue([]);
+
+        await command.run({ teamId: '1', projectId: '2' });
+
+        expect(command.info).toHaveBeenCalledWith('No branches found.');
+    });
+
+    it('should validate IDs', async () => {
+        await command.run({ teamId: 'invalid', projectId: '2' });
+        expect(command.error).toHaveBeenCalledWith('IDs must be numbers.');
+        expect(mockClient.branches.list).not.toHaveBeenCalled();
+    });
+
+    it('should handle list failure', async () => {
+        mockClient.branches.list.mockRejectedValue(new Error('Network error'));
+
+        await command.run({ teamId: '1', projectId: '2' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to list branches: Network error');
+    });
+});

package/test/unit/commands/job/get.test.ts

@@ -0,0 +1,76 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import JobsGetCommand from '../../../../src/commands/job/get.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('JobsGetCommand', () => {
+    let command: JobsGetCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            jobs: {
+                get: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new JobsGetCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should get job details successfully', async () => {
+        mockClient.jobs.get.mockResolvedValue({
+            id: '100',
+            type: 'preview',
+            status: 'completed',
+            startedAt: '2023-01-01',
+            completedAt: '2023-01-02',
+            queue: 'default'
+        });
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: '4' });
+
+        expect(mockClient.jobs.get).toHaveBeenCalledWith(1, 2, 3, 4);
+        expect(command.info).toHaveBeenCalledWith('Job Details:');
+        expect(command.info).toHaveBeenCalledWith('  ID:      100');
+        expect(command.info).toHaveBeenCalledWith('  Type:    preview');
+        expect(command.info).toHaveBeenCalledWith('  Status:  completed');
+        expect(command.info).toHaveBeenCalledWith('  Started: 2023-01-01');
+        expect(command.info).toHaveBeenCalledWith('  Ended:   2023-01-02');
+        expect(command.info).toHaveBeenCalledWith('  Queue:   default');
+    });
+
+    it('should display defaults for missing times', async () => {
+        mockClient.jobs.get.mockResolvedValue({
+            id: '100',
+            type: 'preview',
+            status: 'pending',
+            queue: 'default'
+        });
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: '4' });
+
+        expect(command.info).toHaveBeenCalledWith('  Started: Waiting');
+        expect(command.info).toHaveBeenCalledWith('  Ended:   Running');
+    });
+
+    it('should validate IDs', async () => {
+        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: 'invalid' });
+        expect(command.error).toHaveBeenCalledWith('IDs must be numbers.');
+        expect(mockClient.jobs.get).not.toHaveBeenCalled();
+    });
+
+    it('should handle get failure', async () => {
+        mockClient.jobs.get.mockRejectedValue(new Error('Job not found'));
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: '4' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to get job: Job not found');
+    });
+});

package/test/unit/commands/job/list.test.ts

@@ -0,0 +1,62 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import JobsListCommand from '../../../../src/commands/job/list.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('JobsListCommand', () => {
+    let command: JobsListCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            jobs: {
+                list: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new JobsListCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should list jobs successfully', async () => {
+        mockClient.jobs.list.mockResolvedValue([
+            { id: '100', type: 'preview', status: 'completed', startedAt: '2023-01-01' },
+            { id: '101', type: 'deploy', status: 'running' }
+        ]);
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3' });
+
+        expect(mockClient.jobs.list).toHaveBeenCalledWith(1, 2, 3);
+        expect(command.info).toHaveBeenCalledWith('Jobs for Branch 3:');
+        expect(command.info).toHaveBeenCalledWith('100 - preview [completed] (Started: 2023-01-01)');
+        expect(command.info).toHaveBeenCalledWith('101 - deploy [running] (Started: Waiting)');
+    });
+
+    it('should handle empty list', async () => {
+        mockClient.jobs.list.mockResolvedValue([]);
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3' });
+
+        expect(command.info).toHaveBeenCalledWith('No jobs found.');
+    });
+
+    it('should validate IDs', async () => {
+        await command.run({ teamId: '1', projectId: '2', branchId: 'invalid' });
+        expect(command.error).toHaveBeenCalledWith('IDs must be numbers.');
+        expect(mockClient.jobs.list).not.toHaveBeenCalled();
+    });
+
+    it('should handle list failure', async () => {
+        mockClient.jobs.list.mockRejectedValue(new Error('Network error'));
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to list jobs: Network error');
+    });
+});

package/test/unit/commands/job/logs.test.ts

@@ -0,0 +1,60 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import JobsLogsCommand from '../../../../src/commands/job/logs.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('JobsLogsCommand', () => {
+    let command: JobsLogsCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            jobs: {
+                getLogs: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new JobsLogsCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'warn').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should display logs successfully', async () => {
+        mockClient.jobs.getLogs.mockResolvedValue([
+            { timestamp: '2023-01-01T10:00:00Z', level: 'info', message: 'Starting job' },
+            { timestamp: '2023-01-01T10:00:01Z', level: 'warn', message: 'Slow network' },
+            { timestamp: '2023-01-01T10:00:02Z', level: 'error', message: 'Failed to connect' }
+        ]);
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: '4' });
+
+        expect(mockClient.jobs.getLogs).toHaveBeenCalledWith(1, 2, 3, 4);
+        expect(command.info).toHaveBeenCalledWith('Logs for Job 4:');
+
+        // Timestamps will be converted to locale string, so exact match depends on timezone.
+        // We can just check that info, warn, error were called.
+        expect(command.info).toHaveBeenCalledWith(expect.stringContaining('Starting job'));
+        expect(command.warn).toHaveBeenCalledWith(expect.stringContaining('Slow network'));
+        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to connect'));
+    });
+
+    it('should validate IDs', async () => {
+        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: 'invalid' });
+        expect(command.error).toHaveBeenCalledWith('IDs must be numbers.');
+        expect(mockClient.jobs.getLogs).not.toHaveBeenCalled();
+    });
+
+    it('should handle logs failure', async () => {
+        mockClient.jobs.getLogs.mockRejectedValue(new Error('Logs not available'));
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: '4' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to get logs: Logs not available');
+    });
+});

package/test/unit/commands/job/trigger.test.ts

@@ -0,0 +1,75 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import JobsTriggerCommand from '../../../../src/commands/job/trigger.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('JobsTriggerCommand', () => {
+    let command: JobsTriggerCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            jobs: {
+                create: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new JobsTriggerCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'success').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should trigger job successfully', async () => {
+        mockClient.jobs.create.mockResolvedValue({
+            id: '100',
+            status: 'pending'
+        });
+
+        await command.run({
+            teamId: '1',
+            projectId: '2',
+            branchId: '3',
+            type: 'deploy',
+            input: '{"env":"prod"}'
+        });
+
+        expect(mockClient.jobs.create).toHaveBeenCalledWith(1, 2, 3, {
+            type: 'deploy',
+            inputs: { env: 'prod' }
+        });
+        expect(command.success).toHaveBeenCalledWith('Job 100 triggered successfully!');
+        expect(command.info).toHaveBeenCalledWith('Status: pending');
+    });
+
+    it('should handle invalid JSON input', async () => {
+        await command.run({
+            teamId: '1',
+            projectId: '2',
+            branchId: '3',
+            type: 'deploy',
+            input: '{invalid-json'
+        });
+
+        expect(command.error).toHaveBeenCalledWith('Invalid JSON inputs.');
+        expect(mockClient.jobs.create).not.toHaveBeenCalled();
+    });
+
+    it('should validate IDs', async () => {
+        await command.run({ teamId: 'invalid', projectId: '2', branchId: '3', type: 'deploy' });
+        expect(command.error).toHaveBeenCalledWith('IDs must be numbers.');
+    });
+
+    it('should handle trigger failure', async () => {
+        mockClient.jobs.create.mockRejectedValue(new Error('Quota exceeded'));
+
+        await command.run({ teamId: '1', projectId: '2', branchId: '3', type: 'deploy' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to trigger job: Quota exceeded');
+    });
+});

package/test/unit/commands/login.test.ts

@@ -0,0 +1,64 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import LoginCommand from '../../../src/commands/login.js';
+import { getClient, saveToken } from '../../../src/utils/nexical-client.js';
+
+vi.mock('../../../src/utils/nexical-client.js');
+
+describe('LoginCommand', () => {
+    let command: LoginCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            auth: {
+                authenticateDevice: vi.fn(),
+            },
+            users: {
+                me: vi.fn(),
+            },
+            setToken: vi.fn(),
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new LoginCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'notice').mockImplementation(() => { });
+        vi.spyOn(command, 'success').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should authenticate successfully', async () => {
+        mockClient.auth.authenticateDevice.mockImplementation(async (_clientId: string, callback: any) => {
+            callback('USER-CODE', 'https://verify.url');
+            return 'new-token';
+        });
+        mockClient.users.me.mockResolvedValue({ fullName: 'Test User', email: 'test@example.com' });
+
+        await command.run();
+
+        expect(command.info).toHaveBeenCalledWith('Starting device authentication...');
+        expect(mockClient.auth.authenticateDevice).toHaveBeenCalledWith('nexical-cli', expect.any(Function));
+
+        // Verify callback interaction via implicit check or spy if feasible, 
+        // but here we know the callback is called because we mocked implementation calling it.
+        expect(command.notice).toHaveBeenCalledWith('Please visit: https://verify.url');
+        expect(command.notice).toHaveBeenCalledWith('And enter code: USER-CODE');
+
+        expect(saveToken).toHaveBeenCalledWith('new-token');
+        expect(mockClient.setToken).toHaveBeenCalledWith('new-token');
+        expect(mockClient.users.me).toHaveBeenCalled();
+        expect(command.success).toHaveBeenCalledWith('Successfully logged in as Test User (test@example.com)');
+    });
+
+    it('should handle authentication failure', async () => {
+        mockClient.auth.authenticateDevice.mockRejectedValue(new Error('Auth failed'));
+
+        await command.run();
+
+        expect(command.error).toHaveBeenCalledWith('Login failed: Auth failed');
+        expect(saveToken).not.toHaveBeenCalled();
+    });
+});

package/test/unit/commands/project/create.test.ts

@@ -0,0 +1,64 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import ProjectsCreateCommand from '../../../../src/commands/project/create.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('ProjectsCreateCommand', () => {
+    let command: ProjectsCreateCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            projects: {
+                create: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new ProjectsCreateCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'success').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should create project successfully', async () => {
+        mockClient.projects.create.mockResolvedValue({
+            name: 'New Project',
+            id: '200'
+        });
+
+        await command.run({
+            teamId: '1',
+            name: 'New Project',
+            repo: 'http://repo.git',
+            prod: 'http://prod.url',
+            mode: 'managed'
+        });
+
+        expect(mockClient.projects.create).toHaveBeenCalledWith(1, {
+            name: 'New Project',
+            repoUrl: 'http://repo.git',
+            productionUrl: 'http://prod.url'
+        });
+        expect(command.success).toHaveBeenCalledWith('Project "New Project" set up successfully!');
+        expect(command.info).toHaveBeenCalledWith('ID: 200');
+    });
+
+    it('should validate Team ID', async () => {
+        await command.run({ teamId: 'invalid', name: 'New Project' });
+        expect(command.error).toHaveBeenCalledWith('Team ID must be a number.');
+        expect(mockClient.projects.create).not.toHaveBeenCalled();
+    });
+
+    it('should handle creation failure', async () => {
+        mockClient.projects.create.mockRejectedValue(new Error('Name taken'));
+
+        await command.run({ teamId: '1', name: 'New Project' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to create project: Name taken');
+    });
+});

package/test/unit/commands/project/delete.test.ts

@@ -0,0 +1,72 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import ProjectsDeleteCommand from '../../../../src/commands/project/delete.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('ProjectsDeleteCommand', () => {
+    let command: ProjectsDeleteCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            projects: {
+                delete: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new ProjectsDeleteCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'success').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+        // Mock prompt method which is likely on BaseCommand prototype or instance
+        (command as any).prompt = vi.fn();
+    });
+
+    it('should delete project successfully with confirmation', async () => {
+        mockClient.projects.delete.mockResolvedValue({});
+        (command as any).prompt.mockResolvedValue('yes');
+
+        await command.run({ teamId: '1', projectId: '2', confirm: false });
+
+        expect((command as any).prompt).toHaveBeenCalled();
+        expect(mockClient.projects.delete).toHaveBeenCalledWith(1, 2);
+        expect(command.success).toHaveBeenCalledWith('Project 2 deleted.');
+    });
+
+    it('should delete project successfully with --confirm flag', async () => {
+        mockClient.projects.delete.mockResolvedValue({});
+
+        await command.run({ teamId: '1', projectId: '2', confirm: true });
+
+        expect((command as any).prompt).not.toHaveBeenCalled();
+        expect(mockClient.projects.delete).toHaveBeenCalledWith(1, 2);
+        expect(command.success).toHaveBeenCalledWith('Project 2 deleted.');
+    });
+
+    it('should abort deletion if user says no', async () => {
+        (command as any).prompt.mockResolvedValue('no');
+
+        await command.run({ teamId: '1', projectId: '2', confirm: false });
+
+        expect(mockClient.projects.delete).not.toHaveBeenCalled();
+        expect(command.info).toHaveBeenCalledWith('Aborted.');
+    });
+
+    it('should validate IDs', async () => {
+        await command.run({ teamId: 'invalid', projectId: '2' });
+        expect(command.error).toHaveBeenCalledWith('IDs must be numbers.');
+    });
+
+    it('should handle deletion failure', async () => {
+        mockClient.projects.delete.mockRejectedValue(new Error('Project not found'));
+
+        await command.run({ teamId: '1', projectId: '2', confirm: true });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to delete project: Project not found');
+    });
+});