@memnexus-ai/cli 0.1.0

package/tests/commands/system.test.ts

@@ -0,0 +1,172 @@
+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('System Commands', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockClient = {
+      system: {
+        health: jest.fn(),
+        status: jest.fn(),
+        stats: jest.fn(),
+        clearCache: jest.fn(),
+      },
+    };
+
+    (getApiClient as jest.Mock).mockReturnValue(mockClient);
+  });
+
+  describe('system health', () => {
+    it('should check system health', async () => {
+      const mockResult = {
+        status: 'healthy',
+        components: {
+          database: { status: 'healthy' },
+          cache: { status: 'healthy' },
+          api: { status: 'healthy' },
+        },
+      };
+
+      mockClient.system.health.mockResolvedValue(mockResult);
+
+      const result = await mockClient.system.health();
+
+      expect(mockClient.system.health).toHaveBeenCalled();
+      expect(result.status).toBe('healthy');
+      expect(Object.keys(result.components)).toHaveLength(3);
+    });
+
+    it('should report unhealthy status', async () => {
+      const mockResult = {
+        status: 'unhealthy',
+        components: {
+          database: { status: 'healthy' },
+          cache: { status: 'unhealthy', error: 'Connection timeout' },
+          api: { status: 'healthy' },
+        },
+      };
+
+      mockClient.system.health.mockResolvedValue(mockResult);
+
+      const result = await mockClient.system.health();
+
+      expect(result.status).toBe('unhealthy');
+      expect(result.components.cache.status).toBe('unhealthy');
+    });
+  });
+
+  describe('system status', () => {
+    it('should get system status', async () => {
+      const mockResult = {
+        uptime: 86400,
+        version: '1.0.0',
+        environment: 'production',
+        timestamp: '2024-01-01T00:00:00Z',
+      };
+
+      mockClient.system.status.mockResolvedValue(mockResult);
+
+      const result = await mockClient.system.status();
+
+      expect(mockClient.system.status).toHaveBeenCalled();
+      expect(result.version).toBe('1.0.0');
+      expect(result.environment).toBe('production');
+    });
+  });
+
+  describe('system stats', () => {
+    it('should get system statistics', async () => {
+      const mockResult = {
+        period: '24h',
+        metrics: {
+          requestCount: 10000,
+          averageResponseTime: 150,
+          errorRate: 0.01,
+          memoryUsage: 2048,
+        },
+      };
+
+      mockClient.system.stats.mockResolvedValue(mockResult);
+
+      const result = await mockClient.system.stats({ period: '24h' });
+
+      expect(mockClient.system.stats).toHaveBeenCalledWith({ period: '24h' });
+      expect(result.metrics.requestCount).toBe(10000);
+    });
+
+    it('should support different time periods', async () => {
+      const mockResult = {
+        period: '7d',
+        metrics: {},
+      };
+
+      mockClient.system.stats.mockResolvedValue(mockResult);
+
+      const result = await mockClient.system.stats({ period: '7d' });
+
+      expect(mockClient.system.stats).toHaveBeenCalledWith({ period: '7d' });
+      expect(result.period).toBe('7d');
+    });
+  });
+
+  describe('system clear-cache', () => {
+    it('should clear all cache', async () => {
+      const mockResult = {
+        itemsCleared: 1000,
+        spaceFreed: '512MB',
+      };
+
+      mockClient.system.clearCache.mockResolvedValue(mockResult);
+
+      const result = await mockClient.system.clearCache({ cacheType: 'all' });
+
+      expect(mockClient.system.clearCache).toHaveBeenCalledWith({ cacheType: 'all' });
+      expect(result.itemsCleared).toBe(1000);
+    });
+
+    it('should clear specific cache type', async () => {
+      const mockResult = {
+        itemsCleared: 500,
+        spaceFreed: '256MB',
+      };
+
+      mockClient.system.clearCache.mockResolvedValue(mockResult);
+
+      const result = await mockClient.system.clearCache({ cacheType: 'redis' });
+
+      expect(mockClient.system.clearCache).toHaveBeenCalledWith({ cacheType: 'redis' });
+      expect(result.itemsCleared).toBe(500);
+    });
+  });
+});
+

package/tests/commands/topics.test.ts

@@ -0,0 +1,274 @@
+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('Topics Commands', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockClient = {
+      topics: {
+        list: jest.fn(),
+        get: jest.fn(),
+        merge: jest.fn(),
+        discoverRelated: jest.fn(),
+        similarity: jest.fn(),
+        findSimilar: jest.fn(),
+        cluster: jest.fn(),
+        detectCommunities: jest.fn(),
+      },
+    };
+
+    (getApiClient as jest.Mock).mockReturnValue(mockClient);
+  });
+
+  describe('topics list', () => {
+    it('should list topics with default pagination', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'topic_1',
+            name: 'Test Topic 1',
+            memoryCount: 5,
+            createdAt: '2024-01-01T00:00:00Z',
+          },
+          {
+            id: 'topic_2',
+            name: 'Test Topic 2',
+            memoryCount: 3,
+            createdAt: '2024-01-02T00:00:00Z',
+          },
+        ],
+        pagination: {
+          limit: 20,
+          offset: 0,
+          count: 2,
+        },
+      };
+
+      mockClient.topics.list.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.topics.list({ limit: 20, offset: 0 });
+
+      expect(mockClient.topics.list).toHaveBeenCalledWith({ limit: 20, offset: 0 });
+      expect(result.data).toHaveLength(2);
+      expect(result.pagination.count).toBe(2);
+    });
+
+    it('should handle context filter', async () => {
+      const mockResponse = {
+        data: [],
+        pagination: { limit: 20, offset: 0, count: 0 },
+      };
+
+      mockClient.topics.list.mockResolvedValue(mockResponse);
+
+      await mockClient.topics.list({ limit: 20, offset: 0, contextId: 'ctx_123' });
+
+      expect(mockClient.topics.list).toHaveBeenCalledWith({
+        limit: 20,
+        offset: 0,
+        contextId: 'ctx_123',
+      });
+    });
+  });
+
+  describe('topics get', () => {
+    it('should get topic details', async () => {
+      const mockTopic = {
+        id: 'topic_1',
+        name: 'Test Topic',
+        memoryCount: 5,
+        createdAt: '2024-01-01T00:00:00Z',
+      };
+
+      mockClient.topics.get.mockResolvedValue(mockTopic);
+
+      const result = await mockClient.topics.get('topic_1');
+
+      expect(mockClient.topics.get).toHaveBeenCalledWith('topic_1');
+      expect(result.id).toBe('topic_1');
+      expect(result.name).toBe('Test Topic');
+    });
+  });
+
+  describe('topics merge', () => {
+    it('should merge two topics', async () => {
+      const mockResult = {
+        id: 'topic_2',
+        name: 'Test Topic 2',
+        memoryCount: 8,
+      };
+
+      mockClient.topics.merge.mockResolvedValue(mockResult);
+
+      const result = await mockClient.topics.merge({
+        sourceId: 'topic_1',
+        targetId: 'topic_2',
+      });
+
+      expect(mockClient.topics.merge).toHaveBeenCalledWith({
+        sourceId: 'topic_1',
+        targetId: 'topic_2',
+      });
+      expect(result.memoryCount).toBe(8);
+    });
+  });
+
+  describe('topics discover-related', () => {
+    it('should discover related topics', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'topic_2',
+            name: 'Related Topic',
+            relationshipType: 'similar',
+            strength: 0.85,
+          },
+        ],
+      };
+
+      mockClient.topics.discoverRelated.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.topics.discoverRelated({
+        topicId: 'topic_1',
+        limit: 20,
+      });
+
+      expect(mockClient.topics.discoverRelated).toHaveBeenCalledWith({
+        topicId: 'topic_1',
+        limit: 20,
+      });
+      expect(result.data).toHaveLength(1);
+      expect(result.data[0].strength).toBe(0.85);
+    });
+  });
+
+  describe('topics similarity', () => {
+    it('should calculate similarity between topics', async () => {
+      const mockResult = {
+        topicId1: 'topic_1',
+        topicId2: 'topic_2',
+        similarityScore: 0.78,
+      };
+
+      mockClient.topics.similarity.mockResolvedValue(mockResult);
+
+      const result = await mockClient.topics.similarity({
+        topicId1: 'topic_1',
+        topicId2: 'topic_2',
+      });
+
+      expect(mockClient.topics.similarity).toHaveBeenCalledWith({
+        topicId1: 'topic_1',
+        topicId2: 'topic_2',
+      });
+      expect(result.similarityScore).toBe(0.78);
+    });
+  });
+
+  describe('topics find-similar', () => {
+    it('should find similar topics', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'topic_2',
+            name: 'Similar Topic',
+            similarityScore: 0.85,
+          },
+        ],
+      };
+
+      mockClient.topics.findSimilar.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.topics.findSimilar({
+        topicId: 'topic_1',
+        threshold: 0.7,
+        limit: 20,
+      });
+
+      expect(mockClient.topics.findSimilar).toHaveBeenCalledWith({
+        topicId: 'topic_1',
+        threshold: 0.7,
+        limit: 20,
+      });
+      expect(result.data).toHaveLength(1);
+    });
+  });
+
+  describe('topics cluster', () => {
+    it('should cluster topics', async () => {
+      const mockResult = {
+        clusters: [
+          { id: 0, topics: ['topic_1', 'topic_2'] },
+          { id: 1, topics: ['topic_3', 'topic_4'] },
+        ],
+      };
+
+      mockClient.topics.cluster.mockResolvedValue(mockResult);
+
+      const result = await mockClient.topics.cluster({
+        algorithm: 'kmeans',
+        numClusters: 2,
+      });
+
+      expect(mockClient.topics.cluster).toHaveBeenCalledWith({
+        algorithm: 'kmeans',
+        numClusters: 2,
+      });
+      expect(result.clusters).toHaveLength(2);
+    });
+  });
+
+  describe('topics detect-communities', () => {
+    it('should detect communities', async () => {
+      const mockResult = {
+        communities: [
+          { id: 0, topics: ['topic_1', 'topic_2', 'topic_3'], modularity: 0.45 },
+        ],
+      };
+
+      mockClient.topics.detectCommunities.mockResolvedValue(mockResult);
+
+      const result = await mockClient.topics.detectCommunities({
+        algorithm: 'louvain',
+        minSize: 2,
+      });
+
+      expect(mockClient.topics.detectCommunities).toHaveBeenCalledWith({
+        algorithm: 'louvain',
+        minSize: 2,
+      });
+      expect(result.communities).toHaveLength(1);
+    });
+  });
+});
+

package/tests/lib/auth.test.ts

@@ -0,0 +1,77 @@
+import {
+  storeApiKey,
+  removeApiKey,
+  hasApiKey,
+  getApiKeyStatus,
+  encryptApiKey,
+  decryptApiKey,
+} from '../../src/lib/auth';
+import { config } from '../../src/lib/config';
+
+describe('Authentication Helpers', () => {
+  beforeEach(() => {
+    config.reset();
+    delete process.env.MX_API_KEY;
+    // Mock console.log to avoid output during tests
+    jest.spyOn(console, 'log').mockImplementation();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should store API key', () => {
+    storeApiKey('test-key-123');
+    expect(hasApiKey()).toBe(true);
+  });
+
+  it('should reject empty API key', () => {
+    expect(() => storeApiKey('')).toThrow('API key cannot be empty');
+    expect(() => storeApiKey('   ')).toThrow('API key cannot be empty');
+  });
+
+  it('should remove API key', () => {
+    storeApiKey('test-key');
+    expect(hasApiKey()).toBe(true);
+    removeApiKey();
+    expect(hasApiKey()).toBe(false);
+  });
+
+  it('should detect API key source - none', () => {
+    const status = getApiKeyStatus();
+    expect(status.configured).toBe(false);
+    expect(status.source).toBe('none');
+  });
+
+  it('should detect API key source - config', () => {
+    storeApiKey('config-key');
+    const status = getApiKeyStatus();
+    expect(status.configured).toBe(true);
+    expect(status.source).toBe('config');
+  });
+
+  it('should detect API key source - env', () => {
+    process.env.MX_API_KEY = 'env-key';
+    const status = getApiKeyStatus();
+    expect(status.configured).toBe(true);
+    expect(status.source).toBe('env');
+  });
+
+  it('should prioritize env over config', () => {
+    storeApiKey('config-key');
+    process.env.MX_API_KEY = 'env-key';
+    const status = getApiKeyStatus();
+    expect(status.source).toBe('env');
+  });
+
+  // Placeholder tests for encryption (to be implemented)
+  it('should encrypt API key (placeholder)', () => {
+    const encrypted = encryptApiKey('test-key');
+    expect(encrypted).toBeDefined();
+  });
+
+  it('should decrypt API key (placeholder)', () => {
+    const decrypted = decryptApiKey('encrypted-key');
+    expect(decrypted).toBeDefined();
+  });
+});

package/tests/lib/config.test.ts

@@ -0,0 +1,50 @@
+import { config } from '../../src/lib/config';
+
+describe('ConfigManager', () => {
+  beforeEach(() => {
+    config.reset();
+    delete process.env.MX_API_URL;
+    delete process.env.MX_API_KEY;
+    delete process.env.MX_OUTPUT_FORMAT;
+  });
+
+  it('should return default config', () => {
+    const cfg = config.get();
+    expect(cfg).toHaveProperty('apiUrl');
+    expect(cfg).toHaveProperty('defaultFormat');
+    expect(cfg).toHaveProperty('defaultPageSize');
+  });
+
+  it('should set and get values', () => {
+    config.set('apiUrl', 'http://localhost:3000');
+    expect(config.get('apiUrl')).toBe('http://localhost:3000');
+  });
+
+  it('should respect environment variables for API URL', () => {
+    process.env.MX_API_URL = 'http://env-url:3000';
+    expect(config.getApiUrl()).toBe('http://env-url:3000');
+  });
+
+  it('should respect environment variables for API key', () => {
+    process.env.MX_API_KEY = 'env-api-key';
+    expect(config.getApiKey()).toBe('env-api-key');
+  });
+
+  it('should reset to defaults', () => {
+    config.set('apiUrl', 'http://custom:3000');
+    config.reset();
+    expect(config.get('apiUrl')).toBe('https://api.memnexus.io');
+  });
+
+  it('should check if API key exists', () => {
+    expect(config.hasApiKey()).toBe(false);
+    config.setApiKey('test-key');
+    expect(config.hasApiKey()).toBe(true);
+  });
+
+  it('should get format from config or env', () => {
+    expect(config.getFormat()).toBe('table');
+    process.env.MX_OUTPUT_FORMAT = 'json';
+    expect(config.getFormat()).toBe('json');
+  });
+});

package/tests/lib/errors.test.ts

@@ -0,0 +1,126 @@
+import { CLIError, handleError } from '../../src/lib/errors';
+
+describe('Error Handling', () => {
+  let exitSpy: jest.SpyInstance;
+  let consoleErrorSpy: jest.SpyInstance;
+  let consoleLogSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    exitSpy = jest
+      .spyOn(process, 'exit')
+      .mockImplementation(((code?: string | number | null) => {
+        throw new Error(`process.exit: ${code}`);
+      }) as any);
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('CLIError', () => {
+    it('should create error with default exit code', () => {
+      const error = new CLIError('Test error');
+      expect(error.message).toBe('Test error');
+      expect(error.exitCode).toBe(1);
+      expect(error.name).toBe('CLIError');
+    });
+
+    it('should create error with custom exit code', () => {
+      const error = new CLIError('Test error', 2);
+      expect(error.exitCode).toBe(2);
+    });
+
+    it('should store details', () => {
+      const error = new CLIError('Test error', 1, { foo: 'bar' });
+      expect(error.details).toEqual({ foo: 'bar' });
+    });
+  });
+
+  describe('handleError', () => {
+    it('should handle CLIError', () => {
+      const error = new CLIError('Test error', 2);
+      expect(() => handleError(error)).toThrow('process.exit: 2');
+      expect(consoleErrorSpy).toHaveBeenCalled();
+    });
+
+    it('should handle 401 API errors', () => {
+      const error = {
+        isAxiosError: true,
+        response: {
+          status: 401,
+          statusText: 'Unauthorized',
+          data: {},
+        },
+      };
+
+      expect(() => handleError(error)).toThrow('process.exit: 3');
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Authentication Error')
+      );
+    });
+
+    it('should handle 404 API errors', () => {
+      const error = {
+        isAxiosError: true,
+        response: {
+          status: 404,
+          statusText: 'Not Found',
+          data: {},
+        },
+      };
+
+      expect(() => handleError(error)).toThrow('process.exit: 1');
+      expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Not Found'));
+    });
+
+    it('should handle 422 validation errors', () => {
+      const error = {
+        isAxiosError: true,
+        response: {
+          status: 422,
+          statusText: 'Unprocessable Entity',
+          data: { message: 'Invalid input' },
+        },
+      };
+
+      expect(() => handleError(error)).toThrow('process.exit: 2');
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Validation Error')
+      );
+    });
+
+    it('should handle 429 rate limit errors', () => {
+      const error = {
+        isAxiosError: true,
+        response: {
+          status: 429,
+          statusText: 'Too Many Requests',
+          data: {},
+        },
+      };
+
+      expect(() => handleError(error)).toThrow('process.exit: 5');
+      expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Rate Limit'));
+    });
+
+    it('should handle network errors', () => {
+      const error = {
+        isAxiosError: true,
+        response: undefined,
+      };
+
+      expect(() => handleError(error)).toThrow('process.exit: 4');
+      expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Network Error'));
+    });
+
+    it('should handle unknown errors', () => {
+      const error = new Error('Unknown error');
+      expect(() => handleError(error)).toThrow('process.exit: 1');
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('unexpected error')
+      );
+    });
+  });
+});