@memnexus-ai/cli 0.1.0 → 0.1.2

package/tests/__mocks__/cli-table3.ts

@@ -1,37 +0,0 @@
-// 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

@@ -1,38 +0,0 @@
-// 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

@@ -1,179 +0,0 @@
-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

@@ -1,194 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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',
-      });
-    });
-  });
-});
-