@memnexus-ai/cli 0.1.0

package/tests/__mocks__/cli-table3.ts

@@ -0,0 +1,37 @@
+// Mock cli-table3 for Jest tests
+interface TableOptions {
+  head?: string[];
+  colWidths?: number[];
+  wordWrap?: boolean;
+}
+
+class MockTable {
+  private rows: unknown[][] = [];
+  private headers: string[] = [];
+
+  constructor(options?: TableOptions) {
+    if (options?.head) {
+      this.headers = options.head;
+    }
+  }
+
+  push(row: unknown[]): void {
+    this.rows.push(row);
+  }
+
+  toString(): string {
+    const lines: string[] = [];
+
+    // Add header row if present
+    if (this.headers.length > 0) {
+      lines.push(this.headers.join(' | '));
+    }
+
+    // Add data rows
+    lines.push(...this.rows.map((row) => row.join(' | ')));
+
+    return lines.join('\n');
+  }
+}
+
+export default MockTable;

package/tests/__mocks__/configstore.ts

@@ -0,0 +1,38 @@
+// Mock Configstore for Jest tests
+class MockConfigstore {
+  private store: Record<string, unknown> = {};
+  private defaults: Record<string, unknown> = {};
+
+  constructor(_name: string, defaults?: Record<string, unknown>) {
+    if (defaults) {
+      this.defaults = { ...defaults };
+      this.store = { ...defaults };
+    }
+  }
+
+  get all() {
+    return this.store;
+  }
+
+  set all(value: Record<string, unknown>) {
+    this.store = { ...value };
+  }
+
+  get(key: string): unknown {
+    return this.store[key];
+  }
+
+  set(key: string, value: unknown): void {
+    this.store[key] = value;
+  }
+
+  delete(key: string): void {
+    delete this.store[key];
+  }
+
+  clear(): void {
+    this.store = {};
+  }
+}
+
+export default MockConfigstore;

package/tests/commands/apikeys.test.ts

@@ -0,0 +1,179 @@
+import { getApiClient } from '../../src/lib/api-client';
+
+// Mock the API client
+jest.mock('../../src/lib/api-client');
+
+// Mock chalk
+jest.mock('chalk', () => ({
+  default: {
+    green: (str: string) => str,
+    red: (str: string) => str,
+    yellow: (str: string) => str,
+    cyan: (str: string) => str,
+    gray: (str: string) => str,
+  },
+  green: (str: string) => str,
+  red: (str: string) => str,
+  yellow: (str: string) => str,
+  cyan: (str: string) => str,
+  gray: (str: string) => str,
+}));
+
+// Mock ora
+jest.mock('ora', () => {
+  return jest.fn(() => ({
+    start: jest.fn(function() { return this; }),
+    succeed: jest.fn(function() { return this; }),
+    fail: jest.fn(function() { return this; }),
+  }));
+});
+
+describe('API Keys Commands', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockClient = {
+      apikeys: {
+        list: jest.fn(),
+        get: jest.fn(),
+        create: jest.fn(),
+        delete: jest.fn(),
+      },
+    };
+
+    (getApiClient as jest.Mock).mockReturnValue(mockClient);
+  });
+
+  describe('apikeys list', () => {
+    it('should list API keys with metadata only', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'key_1',
+            name: 'Production Key',
+            status: 'active',
+            createdAt: '2024-01-01T00:00:00Z',
+            lastUsed: '2024-01-10T00:00:00Z',
+          },
+        ],
+        pagination: {
+          limit: 20,
+          offset: 0,
+          count: 1,
+        },
+      };
+
+      mockClient.apikeys.list.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.apikeys.list({ limit: 20, offset: 0 });
+
+      expect(mockClient.apikeys.list).toHaveBeenCalledWith({ limit: 20, offset: 0 });
+      expect(result.data).toHaveLength(1);
+      expect(result.data[0].name).toBe('Production Key');
+    });
+  });
+
+  describe('apikeys get', () => {
+    it('should get API key metadata without value', async () => {
+      const mockKey = {
+        id: 'key_1',
+        name: 'Production Key',
+        status: 'active',
+        createdAt: '2024-01-01T00:00:00Z',
+        value: 'sk_live_secret_key_value', // Should not be returned
+      };
+
+      mockClient.apikeys.get.mockResolvedValue(mockKey);
+
+      const result = await mockClient.apikeys.get('key_1');
+
+      expect(mockClient.apikeys.get).toHaveBeenCalledWith('key_1');
+      expect(result.id).toBe('key_1');
+      expect(result.name).toBe('Production Key');
+      // Value should be present in mock but should be filtered in actual command
+      expect(result.value).toBeDefined();
+    });
+  });
+
+  describe('apikeys create', () => {
+    it('should create API key and show value once', async () => {
+      const mockResult = {
+        id: 'key_1',
+        name: 'New Key',
+        value: 'sk_live_new_secret_key_value',
+        status: 'active',
+        createdAt: '2024-01-01T00:00:00Z',
+        scopes: ['read', 'write'],
+      };
+
+      mockClient.apikeys.create.mockResolvedValue(mockResult);
+
+      const result = await mockClient.apikeys.create({
+        name: 'New Key',
+        scopes: ['read', 'write'],
+      });
+
+      expect(mockClient.apikeys.create).toHaveBeenCalledWith({
+        name: 'New Key',
+        scopes: ['read', 'write'],
+      });
+      expect(result.id).toBe('key_1');
+      expect(result.value).toBe('sk_live_new_secret_key_value');
+    });
+
+    it('should create API key with expiration', async () => {
+      const mockResult = {
+        id: 'key_1',
+        name: 'Temporary Key',
+        value: 'sk_live_temp_key_value',
+        expiresAt: '2024-02-01T00:00:00Z',
+      };
+
+      mockClient.apikeys.create.mockResolvedValue(mockResult);
+
+      const result = await mockClient.apikeys.create({
+        name: 'Temporary Key',
+        expiresIn: 30,
+      });
+
+      expect(mockClient.apikeys.create).toHaveBeenCalledWith({
+        name: 'Temporary Key',
+        expiresIn: 30,
+      });
+      expect(result.expiresAt).toBeDefined();
+    });
+  });
+
+  describe('apikeys delete', () => {
+    it('should delete API key', async () => {
+      mockClient.apikeys.delete.mockResolvedValue({ success: true });
+
+      const result = await mockClient.apikeys.delete('key_1');
+
+      expect(mockClient.apikeys.delete).toHaveBeenCalledWith('key_1');
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('security considerations', () => {
+    it('should never store or log key values', async () => {
+      const mockKey = {
+        id: 'key_1',
+        name: 'Secure Key',
+        value: 'sk_live_secret_value',
+      };
+
+      mockClient.apikeys.get.mockResolvedValue(mockKey);
+
+      const result = await mockClient.apikeys.get('key_1');
+
+      // The actual command should filter out the value
+      // This test verifies the mock returns it, but the command filters it
+      expect(result.value).toBeDefined();
+      expect(result.id).toBe('key_1');
+    });
+  });
+});
+

package/tests/commands/artifacts.test.ts

@@ -0,0 +1,194 @@
+import { getApiClient } from '../../src/lib/api-client';
+
+// Mock the API client
+jest.mock('../../src/lib/api-client');
+
+// Mock chalk
+jest.mock('chalk', () => ({
+  default: {
+    green: (str: string) => str,
+    red: (str: string) => str,
+    yellow: (str: string) => str,
+    cyan: (str: string) => str,
+    gray: (str: string) => str,
+  },
+  green: (str: string) => str,
+  red: (str: string) => str,
+  yellow: (str: string) => str,
+  cyan: (str: string) => str,
+  gray: (str: string) => str,
+}));
+
+// Mock ora
+jest.mock('ora', () => {
+  return jest.fn(() => ({
+    start: jest.fn(function() { return this; }),
+    succeed: jest.fn(function() { return this; }),
+    fail: jest.fn(function() { return this; }),
+  }));
+});
+
+describe('Artifacts Commands', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockClient = {
+      artifacts: {
+        list: jest.fn(),
+        get: jest.fn(),
+        create: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn(),
+      },
+    };
+
+    (getApiClient as jest.Mock).mockReturnValue(mockClient);
+  });
+
+  describe('artifacts list', () => {
+    it('should list artifacts with default pagination', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'art_1',
+            name: 'Artifact 1',
+            type: 'document',
+            size: 1024,
+            createdAt: '2024-01-01T00:00:00Z',
+          },
+        ],
+        pagination: {
+          limit: 20,
+          offset: 0,
+          count: 1,
+        },
+      };
+
+      mockClient.artifacts.list.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.artifacts.list({ limit: 20, offset: 0 });
+
+      expect(mockClient.artifacts.list).toHaveBeenCalledWith({ limit: 20, offset: 0 });
+      expect(result.data).toHaveLength(1);
+    });
+
+    it('should filter by type', async () => {
+      const mockResponse = {
+        data: [],
+        pagination: { limit: 20, offset: 0, count: 0 },
+      };
+
+      mockClient.artifacts.list.mockResolvedValue(mockResponse);
+
+      await mockClient.artifacts.list({ limit: 20, offset: 0, type: 'document' });
+
+      expect(mockClient.artifacts.list).toHaveBeenCalledWith({
+        limit: 20,
+        offset: 0,
+        type: 'document',
+      });
+    });
+  });
+
+  describe('artifacts get', () => {
+    it('should get artifact details', async () => {
+      const mockArtifact = {
+        id: 'art_1',
+        name: 'Artifact 1',
+        type: 'document',
+        size: 1024,
+        createdAt: '2024-01-01T00:00:00Z',
+      };
+
+      mockClient.artifacts.get.mockResolvedValue(mockArtifact);
+
+      const result = await mockClient.artifacts.get('art_1');
+
+      expect(mockClient.artifacts.get).toHaveBeenCalledWith('art_1');
+      expect(result.id).toBe('art_1');
+    });
+  });
+
+  describe('artifacts create', () => {
+    it('should create artifact', async () => {
+      const mockResult = {
+        id: 'art_1',
+        name: 'New Artifact',
+        type: 'document',
+        createdAt: '2024-01-01T00:00:00Z',
+      };
+
+      mockClient.artifacts.create.mockResolvedValue(mockResult);
+
+      const result = await mockClient.artifacts.create({
+        name: 'New Artifact',
+        type: 'document',
+      });
+
+      expect(mockClient.artifacts.create).toHaveBeenCalledWith({
+        name: 'New Artifact',
+        type: 'document',
+      });
+      expect(result.id).toBe('art_1');
+    });
+
+    it('should create artifact with metadata', async () => {
+      const mockResult = {
+        id: 'art_1',
+        name: 'New Artifact',
+        type: 'document',
+        metadata: { key: 'value' },
+      };
+
+      mockClient.artifacts.create.mockResolvedValue(mockResult);
+
+      const result = await mockClient.artifacts.create({
+        name: 'New Artifact',
+        type: 'document',
+        metadata: { key: 'value' },
+      });
+
+      expect(mockClient.artifacts.create).toHaveBeenCalledWith({
+        name: 'New Artifact',
+        type: 'document',
+        metadata: { key: 'value' },
+      });
+      expect(result.metadata).toEqual({ key: 'value' });
+    });
+  });
+
+  describe('artifacts update', () => {
+    it('should update artifact', async () => {
+      const mockResult = {
+        id: 'art_1',
+        name: 'Updated Artifact',
+        type: 'document',
+      };
+
+      mockClient.artifacts.update.mockResolvedValue(mockResult);
+
+      const result = await mockClient.artifacts.update('art_1', {
+        name: 'Updated Artifact',
+      });
+
+      expect(mockClient.artifacts.update).toHaveBeenCalledWith('art_1', {
+        name: 'Updated Artifact',
+      });
+      expect(result.name).toBe('Updated Artifact');
+    });
+  });
+
+  describe('artifacts delete', () => {
+    it('should delete artifact', async () => {
+      mockClient.artifacts.delete.mockResolvedValue({ success: true });
+
+      const result = await mockClient.artifacts.delete('art_1');
+
+      expect(mockClient.artifacts.delete).toHaveBeenCalledWith('art_1');
+      expect(result.success).toBe(true);
+    });
+  });
+});
+

package/tests/commands/auth.test.ts

@@ -0,0 +1,120 @@
+import { storeApiKey, removeApiKey, getApiKeyStatus } from '../../src/lib/auth';
+import { config } from '../../src/lib/config';
+
+// Mock the config module
+jest.mock('../../src/lib/config', () => ({
+  config: {
+    setApiKey: jest.fn(),
+    delete: jest.fn(),
+    get: jest.fn(),
+  },
+}));
+
+// Mock chalk to avoid color codes in tests
+jest.mock('chalk', () => ({
+  default: {
+    green: (str: string) => str,
+    red: (str: string) => str,
+    yellow: (str: string) => str,
+    cyan: (str: string) => str,
+    gray: (str: string) => str,
+  },
+  green: (str: string) => str,
+  red: (str: string) => str,
+  yellow: (str: string) => str,
+  cyan: (str: string) => str,
+  gray: (str: string) => str,
+}));
+
+describe('Auth Commands', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Clear environment variables
+    delete process.env.MX_API_KEY;
+  });
+
+  describe('storeApiKey', () => {
+    it('should store a valid API key', () => {
+      const apiKey = 'test_api_key_12345';
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      storeApiKey(apiKey);
+
+      expect(config.setApiKey).toHaveBeenCalledWith(apiKey);
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('API key saved successfully'));
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should throw error for empty API key', () => {
+      expect(() => storeApiKey('')).toThrow('API key cannot be empty');
+      expect(config.setApiKey).not.toHaveBeenCalled();
+    });
+
+    it('should throw error for whitespace-only API key', () => {
+      expect(() => storeApiKey('   ')).toThrow('API key cannot be empty');
+      expect(config.setApiKey).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('removeApiKey', () => {
+    it('should remove stored API key', () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      removeApiKey();
+
+      expect(config.delete).toHaveBeenCalledWith('apiKey');
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('API key removed'));
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('getApiKeyStatus', () => {
+    it('should return env source when API key is in environment', () => {
+      process.env.MX_API_KEY = 'env_api_key';
+
+      const status = getApiKeyStatus();
+
+      expect(status).toEqual({
+        configured: true,
+        source: 'env',
+      });
+    });
+
+    it('should return config source when API key is in config file', () => {
+      (config.get as jest.Mock).mockReturnValue('config_api_key');
+
+      const status = getApiKeyStatus();
+
+      expect(status).toEqual({
+        configured: true,
+        source: 'config',
+      });
+    });
+
+    it('should return none when no API key is configured', () => {
+      (config.get as jest.Mock).mockReturnValue(undefined);
+
+      const status = getApiKeyStatus();
+
+      expect(status).toEqual({
+        configured: false,
+        source: 'none',
+      });
+    });
+
+    it('should prioritize environment variable over config file', () => {
+      process.env.MX_API_KEY = 'env_api_key';
+      (config.get as jest.Mock).mockReturnValue('config_api_key');
+
+      const status = getApiKeyStatus();
+
+      expect(status).toEqual({
+        configured: true,
+        source: 'env',
+      });
+    });
+  });
+});
+