@nestbox-ai/cli 1.0.19 → 1.0.21

package/test/compute.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+import { registerComputeProgram } from '../src/commands/compute';
+
+describe('Compute Commands', () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    vi.clearAllMocks();
+  });
+
+  describe('registerComputeProgram', () => {
+    it('should register compute command group', () => {
+      registerComputeProgram(program);
+
+      const commands = program.commands;
+      const computeCommand = commands.find(cmd => cmd.name() === 'compute');
+
+      expect(computeCommand).toBeDefined();
+      expect(computeCommand?.description()).toBe('Manage Nestbox computes');
+    });
+
+    it('should register compute list subcommand', () => {
+      registerComputeProgram(program);
+
+      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
+      const subCommands = computeCommand?.commands || [];
+      const listCommand = subCommands.find(cmd => cmd.name() === 'list');
+
+      expect(listCommand).toBeDefined();
+      expect(listCommand?.description()).toBe('List all compute instances');
+      
+      // Check options
+      const options = listCommand?.options || [];
+      const projectOption = options.find(opt => opt.long === '--project');
+      expect(projectOption).toBeDefined();
+      expect(projectOption?.description).toBe('Project ID or name (defaults to the current project)');
+    });
+
+    it('should register compute create subcommand', () => {
+      registerComputeProgram(program);
+
+      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
+      const subCommands = computeCommand?.commands || [];
+      const createCommand = subCommands.find(cmd => cmd.name() === 'create');
+
+      expect(createCommand).toBeDefined();
+      expect(createCommand?.description()).toBe('Create a new compute instance');
+      
+      // Check options
+      const options = createCommand?.options || [];
+      const projectOption = options.find(opt => opt.long === '--project');
+      const imageOption = options.find(opt => opt.long === '--image');
+      
+      expect(projectOption).toBeDefined();
+      expect(imageOption).toBeDefined();
+    });
+
+    it('should register compute delete subcommand', () => {
+      registerComputeProgram(program);
+
+      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
+      const subCommands = computeCommand?.commands || [];
+      const deleteCommand = subCommands.find(cmd => cmd.name() === 'delete');
+
+      expect(deleteCommand).toBeDefined();
+      expect(deleteCommand?.description()).toBe('Delete one or more compute instances');
+      
+      // Check options
+      const options = deleteCommand?.options || [];
+      const projectOption = options.find(opt => opt.long === '--project');
+      const forceOption = options.find(opt => opt.long === '--force');
+      
+      expect(projectOption).toBeDefined();
+      expect(forceOption).toBeDefined();
+    });
+
+    it('should have all expected compute subcommands', () => {
+      registerComputeProgram(program);
+
+      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
+      const subCommandNames = computeCommand?.commands.map(cmd => cmd.name()) || [];
+      
+      expect(subCommandNames).toContain('list');
+      expect(subCommandNames).toContain('create');
+      expect(subCommandNames).toContain('delete');
+      expect(subCommandNames).toHaveLength(3);
+    });
+
+    it('should have proper action functions for all subcommands', () => {
+      registerComputeProgram(program);
+
+      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
+      const subCommands = computeCommand?.commands || [];
+      
+      subCommands.forEach(cmd => {
+        expect(typeof cmd.action).toBe('function');
+      });
+    });
+
+    it('should register compute list command with correct structure', () => {
+      registerComputeProgram(program);
+
+      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
+      const listCommand = computeCommand?.commands.find(cmd => cmd.name() === 'list');
+      
+      expect(listCommand?.name()).toBe('list');
+      expect(listCommand?.description()).toBe('List all compute instances');
+      expect(typeof listCommand?.action).toBe('function');
+    });
+
+    it('should register compute create command with correct structure', () => {
+      registerComputeProgram(program);
+
+      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
+      const createCommand = computeCommand?.commands.find(cmd => cmd.name() === 'create');
+      
+      expect(createCommand?.name()).toBe('create');
+      expect(createCommand?.description()).toBe('Create a new compute instance');
+      expect(typeof createCommand?.action).toBe('function');
+    });
+
+    it('should register compute delete command with correct structure', () => {
+      registerComputeProgram(program);
+
+      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
+      const deleteCommand = computeCommand?.commands.find(cmd => cmd.name() === 'delete');
+      
+      expect(deleteCommand?.name()).toBe('delete');
+      expect(deleteCommand?.description()).toBe('Delete one or more compute instances');
+      expect(typeof deleteCommand?.action).toBe('function');
+    });
+  });
+});

package/test/document.test.ts

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+import { registerDocumentCommands } from '../src/commands/document';
+
+describe('Document Commands', () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    vi.clearAllMocks();
+  });
+
+  describe('registerDocumentCommands', () => {
+    it('should register document command group', () => {
+      registerDocumentCommands(program);
+
+      const commands = program.commands;
+      const documentCommand = commands.find(cmd => cmd.name() === 'document');
+
+      expect(documentCommand).toBeDefined();
+      expect(documentCommand?.description()).toBe('Manage Nestbox documents');
+    });
+
+    it('should register doc subcommand group', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const subCommands = documentCommand?.commands || [];
+      const docCommand = subCommands.find(cmd => cmd.name() === 'doc');
+
+      expect(docCommand).toBeDefined();
+      expect(docCommand?.description()).toBe('Manage individual documents');
+    });
+
+    it('should register collection subcommand group', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const subCommands = documentCommand?.commands || [];
+      const collectionCommand = subCommands.find(cmd => cmd.name() === 'collection');
+
+      expect(collectionCommand).toBeDefined();
+      expect(collectionCommand?.description()).toBe('Manage document collections');
+    });
+
+    it('should register doc list subcommand', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const collectionCommand = documentCommand?.commands.find(cmd => cmd.name() === 'collection');
+      const collectionSubCommands = collectionCommand?.commands || [];
+      const listCommand = collectionSubCommands.find(cmd => cmd.name() === 'list');
+
+      expect(listCommand).toBeDefined();
+      expect(listCommand?.description()).toBe('List document collections for a specific instance');
+      
+      // Check options
+      const options = listCommand?.options || [];
+      const instanceOption = options.find(opt => opt.long === '--instance');
+      const projectOption = options.find(opt => opt.long === '--project');
+      
+      expect(instanceOption).toBeDefined();
+      expect(projectOption).toBeDefined();
+    });
+
+    it('should register doc create subcommand', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const collectionCommand = documentCommand?.commands.find(cmd => cmd.name() === 'collection');
+      const collectionSubCommands = collectionCommand?.commands || [];
+      const createCommand = collectionSubCommands.find(cmd => cmd.name() === 'create');
+
+      expect(createCommand).toBeDefined();
+      expect(createCommand?.description()).toBe('Create a new document collection for a specific instance');
+      
+      // Check options
+      const options = createCommand?.options || [];
+      const instanceOption = options.find(opt => opt.long === '--instance');
+      const projectOption = options.find(opt => opt.long === '--project');
+      
+      expect(instanceOption).toBeDefined();
+      expect(projectOption).toBeDefined();
+    });
+
+    it('should register doc get subcommand', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
+      const docSubCommands = docCommand?.commands || [];
+      const getCommand = docSubCommands.find(cmd => cmd.name() === 'get');
+
+      expect(getCommand).toBeDefined();
+      expect(getCommand?.description()).toBe('Get a document from a collection');
+      
+      // Arguments are part of the command definition, not in args array
+      expect(getCommand?.name()).toBe('get');
+    });
+
+    it('should register doc delete subcommand', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
+      const docSubCommands = docCommand?.commands || [];
+      const deleteCommand = docSubCommands.find(cmd => cmd.name() === 'delete');
+
+      expect(deleteCommand).toBeDefined();
+      expect(deleteCommand?.description()).toBe('Delete a document from a collection');
+      
+      // Arguments are part of the command definition, not in args array
+      expect(deleteCommand?.name()).toBe('delete');
+    });
+
+    it('should register doc update subcommand', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
+      const docSubCommands = docCommand?.commands || [];
+      const updateCommand = docSubCommands.find(cmd => cmd.name() === 'update');
+
+      expect(updateCommand).toBeDefined();
+      expect(updateCommand?.description()).toBe('Update a document in a collection');
+      
+      // Arguments are part of the command definition, not in args array
+      expect(updateCommand?.name()).toBe('update');
+    });
+
+    it('should register collection add subcommand', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
+      const docSubCommands = docCommand?.commands || [];
+      const addCommand = docSubCommands.find(cmd => cmd.name() === 'add');
+
+      expect(addCommand).toBeDefined();
+      expect(addCommand?.description()).toBe('Add a new document to a collection');
+      
+      // Check options
+      const options = addCommand?.options || [];
+      const instanceOption = options.find(opt => opt.long === '--instance');
+      const collectionOption = options.find(opt => opt.long === '--collection');
+      
+      expect(instanceOption).toBeDefined();
+      expect(collectionOption).toBeDefined();
+    });
+
+    it('should register collection search subcommand', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
+      const docSubCommands = docCommand?.commands || [];
+      const searchCommand = docSubCommands.find(cmd => cmd.name() === 'search');
+
+      expect(searchCommand).toBeDefined();
+      expect(searchCommand?.description()).toBe('Search for documents in a collection');
+      
+      // Check arguments and options
+      expect(searchCommand?.name()).toBe('search');
+    });
+
+    it('should have all expected doc subcommands', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
+      const docSubCommandNames = docCommand?.commands.map(cmd => cmd.name()) || [];
+      
+      expect(docSubCommandNames).toContain('add');
+      expect(docSubCommandNames).toContain('get');
+      expect(docSubCommandNames).toContain('delete');
+      expect(docSubCommandNames).toContain('update');
+      expect(docSubCommandNames).toContain('upload-file');
+      expect(docSubCommandNames).toContain('search');
+      expect(docSubCommandNames).toHaveLength(6);
+    });
+
+    it('should have all expected collection subcommands', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const collectionCommand = documentCommand?.commands.find(cmd => cmd.name() === 'collection');
+      const collectionSubCommandNames = collectionCommand?.commands.map(cmd => cmd.name()) || [];
+      
+      expect(collectionSubCommandNames).toContain('list');
+      expect(collectionSubCommandNames).toContain('create');
+      expect(collectionSubCommandNames).toContain('get');
+      expect(collectionSubCommandNames).toContain('delete');
+      expect(collectionSubCommandNames).toContain('update');
+      expect(collectionSubCommandNames).toHaveLength(5);
+    });
+
+    it('should have proper action functions for all subcommands', () => {
+      registerDocumentCommands(program);
+
+      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
+      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
+      const collectionCommand = documentCommand?.commands.find(cmd => cmd.name() === 'collection');
+      
+      // Check doc subcommands
+      const docSubCommands = docCommand?.commands || [];
+      docSubCommands.forEach(cmd => {
+        expect(typeof cmd.action).toBe('function');
+      });
+
+      // Check collection subcommands
+      const collectionSubCommands = collectionCommand?.commands || [];
+      collectionSubCommands.forEach(cmd => {
+        expect(typeof cmd.action).toBe('function');
+      });
+    });
+  });
+});

package/test/image.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+import { registerImageCommands } from '../src/commands/image';
+
+describe('Image Commands', () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    vi.clearAllMocks();
+  });
+
+  describe('registerImageCommands', () => {
+    it('should register image command group', () => {
+      registerImageCommands(program);
+
+      const commands = program.commands;
+      const imageCommand = commands.find(cmd => cmd.name() === 'image');
+
+      expect(imageCommand).toBeDefined();
+      expect(imageCommand?.description()).toBe('Manage Nestbox images');
+    });
+
+    it('should register image list subcommand', () => {
+      registerImageCommands(program);
+
+      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
+      const subCommands = imageCommand?.commands || [];
+      const listCommand = subCommands.find(cmd => cmd.name() === 'list');
+
+      expect(listCommand).toBeDefined();
+      expect(listCommand?.description()).toBe('List images for a project');
+      
+      // Check options
+      const options = listCommand?.options || [];
+      const projectOption = options.find(opt => opt.long === '--project');
+      expect(projectOption).toBeDefined();
+      expect(projectOption?.description).toBe('Project ID or name (defaults to the current project)');
+    });
+
+    it('should have all expected image subcommands', () => {
+      registerImageCommands(program);
+
+      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
+      const subCommandNames = imageCommand?.commands.map(cmd => cmd.name()) || [];
+      
+      expect(subCommandNames).toContain('list');
+      expect(subCommandNames).toHaveLength(1);
+    });
+
+    it('should have proper action functions for all subcommands', () => {
+      registerImageCommands(program);
+
+      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
+      const subCommands = imageCommand?.commands || [];
+      
+      subCommands.forEach(cmd => {
+        expect(typeof cmd.action).toBe('function');
+      });
+    });
+
+    it('should register image list command with correct structure', () => {
+      registerImageCommands(program);
+
+      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
+      const listCommand = imageCommand?.commands.find(cmd => cmd.name() === 'list');
+      
+      expect(listCommand?.name()).toBe('list');
+      expect(listCommand?.description()).toBe('List images for a project');
+      expect(typeof listCommand?.action).toBe('function');
+    });
+
+    it('should have project option with correct configuration', () => {
+      registerImageCommands(program);
+
+      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
+      const listCommand = imageCommand?.commands.find(cmd => cmd.name() === 'list');
+      const options = listCommand?.options || [];
+      const projectOption = options.find(opt => opt.long === '--project');
+      
+      expect(projectOption).toBeDefined();
+      expect(projectOption?.description).toBe('Project ID or name (defaults to the current project)');
+      expect(projectOption?.long).toBe('--project');
+    });
+
+    it('should properly initialize when auth token is available', () => {
+      // This test verifies that the command registration doesn't fail when auth token is available
+      expect(() => {
+        registerImageCommands(program);
+      }).not.toThrow();
+      
+      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
+      expect(imageCommand).toBeDefined();
+    });
+
+    it('should handle the case when createApis function is called within command actions', () => {
+      registerImageCommands(program);
+
+      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
+      const listCommand = imageCommand?.commands.find(cmd => cmd.name() === 'list');
+      
+      // Verify that the action function exists and is callable
+      expect(listCommand?.action).toBeDefined();
+      expect(typeof listCommand?.action).toBe('function');
+    });
+  });
+});

package/test/mocks.ts

@@ -0,0 +1,122 @@
+import { vi } from 'vitest';
+
+// Mock external dependencies that are commonly used across all test files
+export const setupCommonMocks = () => {
+  // Mock utils/error
+  vi.mock('../src/utils/error', () => ({
+    withTokenRefresh: vi.fn(),
+    handle401Error: vi.fn()
+  }));
+
+  // Mock utils/auth
+  vi.mock('../src/utils/auth', () => ({
+    getAuthToken: vi.fn().mockReturnValue({
+      token: 'mock-token',
+      serverUrl: 'http://localhost:3000'
+    }),
+    listCredentials: vi.fn(),
+    removeCredentials: vi.fn()
+  }));
+
+  // Mock @nestbox-ai/admin
+  vi.mock('@nestbox-ai/admin', () => ({
+    Configuration: vi.fn(),
+    AuthApi: vi.fn(),
+    ProjectsApi: vi.fn(),
+    MachineAgentApi: vi.fn(),
+    MachineInstancesApi: vi.fn(),
+    MiscellaneousApi: vi.fn(),
+    DocumentsApi: vi.fn(),
+    OAuthLoginRequestDTOTypeEnum: {}
+  }));
+
+  // Mock utils/project
+  vi.mock('../src/utils/project', () => ({
+    resolveProject: vi.fn()
+  }));
+
+  // Mock utils/agent
+  vi.mock('../src/utils/agent', () => ({
+    createNestboxConfig: vi.fn(),
+    createZipFromDirectory: vi.fn(),
+    extractZip: vi.fn(),
+    findProjectRoot: vi.fn(),
+    isTypeScriptProject: vi.fn(),
+    loadNestboxConfig: vi.fn(),
+    runPredeployScripts: vi.fn()
+  }));
+
+  // Mock utils/user
+  vi.mock('../src/utils/user', () => ({
+    userData: vi.fn()
+  }));
+
+  // Mock chalk
+  vi.mock('chalk', () => ({
+    default: {
+      green: vi.fn((text) => text),
+      red: vi.fn((text) => text),
+      yellow: vi.fn((text) => text),
+      blue: vi.fn((text) => text)
+    }
+  }));
+
+  // Mock ora
+  vi.mock('ora', () => ({
+    default: vi.fn(() => ({
+      start: vi.fn().mockReturnThis(),
+      succeed: vi.fn().mockReturnThis(),
+      fail: vi.fn().mockReturnThis(),
+      text: ''
+    }))
+  }));
+
+  // Mock cli-table3
+  vi.mock('cli-table3', () => ({
+    default: vi.fn()
+  }));
+
+  // Mock inquirer
+  vi.mock('inquirer', () => ({
+    default: {
+      prompt: vi.fn()
+    }
+  }));
+
+  // Mock fs
+  vi.mock('fs', () => ({
+    default: {
+      existsSync: vi.fn(),
+      readFileSync: vi.fn(),
+      writeFileSync: vi.fn()
+    }
+  }));
+
+  // Mock yaml
+  vi.mock('yaml', () => ({
+    default: {
+      load: vi.fn()
+    }
+  }));
+
+  // Mock axios
+  vi.mock('axios', () => ({
+    default: {
+      get: vi.fn(),
+      post: vi.fn()
+    }
+  }));
+
+  // Mock open
+  vi.mock('open', () => ({
+    default: vi.fn()
+  }));
+
+  // Mock path
+  vi.mock('path', () => ({
+    default: {
+      join: vi.fn(),
+      resolve: vi.fn()
+    }
+  }));
+};

package/test/projects.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+import { registerProjectCommands } from '../src/commands/projects';
+
+describe('Project Commands', () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    vi.clearAllMocks();
+  });
+
+  describe('registerProjectCommands', () => {
+    it('should register project command group', () => {
+      registerProjectCommands(program);
+
+      const commands = program.commands;
+      const projectCommand = commands.find(cmd => cmd.name() === 'project');
+
+      expect(projectCommand).toBeDefined();
+      expect(projectCommand?.description()).toBe('Manage Nestbox projects');
+    });
+
+    it('should register project use subcommand', () => {
+      registerProjectCommands(program);
+
+      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
+      const subCommands = projectCommand?.commands || [];
+      const useCommand = subCommands.find(cmd => cmd.name() === 'use');
+
+      expect(useCommand).toBeDefined();
+      expect(useCommand?.description()).toBe('Set default project for all commands');
+      
+      // The command uses a required argument <project-name> which is part of the command definition
+      expect(useCommand?.name()).toBe('use');
+    });
+
+    it('should register project add subcommand', () => {
+      registerProjectCommands(program);
+
+      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
+      const subCommands = projectCommand?.commands || [];
+      const addCommand = subCommands.find(cmd => cmd.name() === 'add');
+
+      expect(addCommand).toBeDefined();
+      expect(addCommand?.description()).toBe('Add a project with optional alias');
+      
+      // The command uses required and optional arguments which are part of the command definition
+      expect(addCommand?.name()).toBe('add');
+    });
+
+    it('should register project list subcommand', () => {
+      registerProjectCommands(program);
+
+      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
+      const subCommands = projectCommand?.commands || [];
+      const listCommand = subCommands.find(cmd => cmd.name() === 'list');
+
+      expect(listCommand).toBeDefined();
+      expect(listCommand?.description()).toBe('List all projects');
+    });
+
+    it('should have all expected project subcommands', () => {
+      registerProjectCommands(program);
+
+      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
+      const subCommandNames = projectCommand?.commands.map(cmd => cmd.name()) || [];
+      
+      expect(subCommandNames).toContain('use');
+      expect(subCommandNames).toContain('add');
+      expect(subCommandNames).toContain('list');
+      expect(subCommandNames).toHaveLength(3);
+    });
+
+    it('should have proper action functions for all commands', () => {
+      registerProjectCommands(program);
+
+      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
+      const subCommands = projectCommand?.commands || [];
+      
+      subCommands.forEach(cmd => {
+        expect(typeof cmd.action).toBe('function');
+      });
+    });
+
+    it('should register project use command with correct structure', () => {
+      registerProjectCommands(program);
+
+      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
+      const useCommand = projectCommand?.commands.find(cmd => cmd.name() === 'use');
+      
+      expect(useCommand?.name()).toBe('use');
+      expect(useCommand?.description()).toBe('Set default project for all commands');
+      expect(typeof useCommand?.action).toBe('function');
+    });
+
+    it('should register project add command with correct structure', () => {
+      registerProjectCommands(program);
+
+      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
+      const addCommand = projectCommand?.commands.find(cmd => cmd.name() === 'add');
+      
+      expect(addCommand?.name()).toBe('add');
+      expect(addCommand?.description()).toBe('Add a project with optional alias');
+      expect(typeof addCommand?.action).toBe('function');
+    });
+  });
+});