@memnexus-ai/cli 0.1.0

package/tests/commands/communities.test.ts

@@ -0,0 +1,154 @@
+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('Communities Commands', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockClient = {
+      communities: {
+        list: jest.fn(),
+        get: jest.fn(),
+        merge: jest.fn(),
+      },
+    };
+
+    (getApiClient as jest.Mock).mockReturnValue(mockClient);
+  });
+
+  describe('communities list', () => {
+    it('should list communities with default pagination', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'comm_1',
+            name: 'Community 1',
+            memberCount: 5,
+            topicCount: 3,
+            createdAt: '2024-01-01T00:00:00Z',
+          },
+          {
+            id: 'comm_2',
+            name: 'Community 2',
+            memberCount: 8,
+            topicCount: 5,
+            createdAt: '2024-01-02T00:00:00Z',
+          },
+        ],
+        pagination: {
+          limit: 20,
+          offset: 0,
+          count: 2,
+        },
+      };
+
+      mockClient.communities.list.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.communities.list({ limit: 20, offset: 0 });
+
+      expect(mockClient.communities.list).toHaveBeenCalledWith({ limit: 20, offset: 0 });
+      expect(result.data).toHaveLength(2);
+      expect(result.pagination.count).toBe(2);
+    });
+
+    it('should handle context and min-size filters', async () => {
+      const mockResponse = {
+        data: [],
+        pagination: { limit: 20, offset: 0, count: 0 },
+      };
+
+      mockClient.communities.list.mockResolvedValue(mockResponse);
+
+      await mockClient.communities.list({
+        limit: 20,
+        offset: 0,
+        contextId: 'ctx_123',
+        minSize: 3,
+      });
+
+      expect(mockClient.communities.list).toHaveBeenCalledWith({
+        limit: 20,
+        offset: 0,
+        contextId: 'ctx_123',
+        minSize: 3,
+      });
+    });
+  });
+
+  describe('communities get', () => {
+    it('should get community details', async () => {
+      const mockCommunity = {
+        id: 'comm_1',
+        name: 'Community 1',
+        memberCount: 5,
+        topicCount: 3,
+        createdAt: '2024-01-01T00:00:00Z',
+        members: ['topic_1', 'topic_2', 'topic_3'],
+      };
+
+      mockClient.communities.get.mockResolvedValue(mockCommunity);
+
+      const result = await mockClient.communities.get('comm_1');
+
+      expect(mockClient.communities.get).toHaveBeenCalledWith('comm_1');
+      expect(result.id).toBe('comm_1');
+      expect(result.name).toBe('Community 1');
+      expect(result.members).toHaveLength(3);
+    });
+  });
+
+  describe('communities merge', () => {
+    it('should merge two communities', async () => {
+      const mockResult = {
+        id: 'comm_2',
+        name: 'Community 2',
+        memberCount: 13,
+        topicCount: 8,
+      };
+
+      mockClient.communities.merge.mockResolvedValue(mockResult);
+
+      const result = await mockClient.communities.merge({
+        sourceId: 'comm_1',
+        targetId: 'comm_2',
+      });
+
+      expect(mockClient.communities.merge).toHaveBeenCalledWith({
+        sourceId: 'comm_1',
+        targetId: 'comm_2',
+      });
+      expect(result.memberCount).toBe(13);
+      expect(result.topicCount).toBe(8);
+    });
+  });
+});
+

package/tests/commands/config.test.ts

@@ -0,0 +1,154 @@
+import { config } from '../../src/lib/config';
+
+// Mock configstore
+jest.mock('configstore');
+
+// 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,
+}));
+
+describe('Config Commands', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Clear environment variables
+    delete process.env.MX_API_URL;
+    delete process.env.MX_OUTPUT_FORMAT;
+  });
+
+  describe('config.get', () => {
+    it('should get a specific config value', () => {
+      const mockGet = jest.spyOn(config, 'get');
+      mockGet.mockReturnValue('https://api.memnexus.io');
+
+      const value = config.get('apiUrl');
+
+      expect(value).toBe('https://api.memnexus.io');
+      expect(mockGet).toHaveBeenCalledWith('apiUrl');
+
+      mockGet.mockRestore();
+    });
+
+    it('should return all config when no key provided', () => {
+      const mockGet = jest.spyOn(config, 'get');
+      const mockConfig = {
+        apiUrl: 'https://api.memnexus.io',
+        defaultFormat: 'table',
+        defaultPageSize: 20,
+      };
+      mockGet.mockReturnValue(mockConfig);
+
+      const value = config.get();
+
+      expect(value).toEqual(mockConfig);
+
+      mockGet.mockRestore();
+    });
+  });
+
+  describe('config.set', () => {
+    it('should set a valid config value', () => {
+      const mockSet = jest.spyOn(config, 'set');
+
+      config.set('apiUrl', 'https://custom.api.com');
+
+      expect(mockSet).toHaveBeenCalledWith('apiUrl', 'https://custom.api.com');
+
+      mockSet.mockRestore();
+    });
+
+    it('should set defaultPageSize as number', () => {
+      const mockSet = jest.spyOn(config, 'set');
+
+      config.set('defaultPageSize', 50);
+
+      expect(mockSet).toHaveBeenCalledWith('defaultPageSize', 50);
+
+      mockSet.mockRestore();
+    });
+  });
+
+  describe('config.reset', () => {
+    it('should reset config to defaults', () => {
+      const mockReset = jest.spyOn(config, 'reset');
+
+      config.reset();
+
+      expect(mockReset).toHaveBeenCalled();
+
+      mockReset.mockRestore();
+    });
+  });
+
+  describe('config.getApiUrl', () => {
+    it('should return environment variable if set', () => {
+      process.env.MX_API_URL = 'https://env.api.com';
+
+      const url = config.getApiUrl();
+
+      expect(url).toBe('https://env.api.com');
+    });
+
+    it('should return default value if no environment variable or config', () => {
+      delete process.env.MX_API_URL;
+
+      const url = config.getApiUrl();
+
+      // Should return the default API URL
+      expect(url).toBe('https://api.memnexus.io');
+    });
+  });
+
+  describe('config.getFormat', () => {
+    it('should return environment variable if set', () => {
+      process.env.MX_OUTPUT_FORMAT = 'json';
+
+      const format = config.getFormat();
+
+      expect(format).toBe('json');
+    });
+
+    it('should return default format if no override', () => {
+      const format = config.getFormat();
+
+      expect(['json', 'table', 'yaml']).toContain(format);
+    });
+  });
+
+  describe('config validation', () => {
+    it('should validate URL format', () => {
+      const validUrl = 'https://api.example.com';
+      expect(() => new URL(validUrl)).not.toThrow();
+    });
+
+    it('should reject invalid URL format', () => {
+      const invalidUrl = 'not-a-url';
+      expect(() => new URL(invalidUrl)).toThrow();
+    });
+
+    it('should validate format values', () => {
+      const validFormats = ['json', 'table', 'yaml'];
+      validFormats.forEach((format) => {
+        expect(validFormats).toContain(format);
+      });
+    });
+
+    it('should validate page size range', () => {
+      const validPageSize = 50;
+      expect(validPageSize).toBeGreaterThanOrEqual(1);
+      expect(validPageSize).toBeLessThanOrEqual(100);
+    });
+  });
+});
+

package/tests/commands/conversations.test.ts

@@ -0,0 +1,136 @@
+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,
+}));
+
+describe('Conversations Commands', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockClient = {
+      conversations: {
+        list: jest.fn(),
+        create: jest.fn(),
+      },
+    };
+
+    (getApiClient as jest.Mock).mockReturnValue(mockClient);
+  });
+
+  describe('conversations list', () => {
+    it('should list conversations with default pagination', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'conv_1',
+            title: 'Test Conversation 1',
+            messageCount: 5,
+            createdAt: '2024-01-01T00:00:00Z',
+          },
+          {
+            id: 'conv_2',
+            title: 'Test Conversation 2',
+            messageCount: 3,
+            createdAt: '2024-01-02T00:00:00Z',
+          },
+        ],
+        pagination: {
+          limit: 20,
+          offset: 0,
+          count: 2,
+        },
+      };
+
+      mockClient.conversations.list.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.conversations.list({ limit: 20, offset: 0 });
+
+      expect(mockClient.conversations.list).toHaveBeenCalledWith({ limit: 20, offset: 0 });
+      expect(result.data).toHaveLength(2);
+      expect(result.pagination.count).toBe(2);
+    });
+
+    it('should handle pagination parameters', async () => {
+      const mockResponse = {
+        data: [],
+        pagination: { limit: 10, offset: 20, count: 0 },
+      };
+
+      mockClient.conversations.list.mockResolvedValue(mockResponse);
+
+      await mockClient.conversations.list({ limit: 10, offset: 20 });
+
+      expect(mockClient.conversations.list).toHaveBeenCalledWith({ limit: 10, offset: 20 });
+    });
+  });
+
+  describe('conversations create', () => {
+    it('should create a conversation', async () => {
+      const conversationData = {
+        title: 'New Conversation',
+      };
+
+      const mockCreated = {
+        id: 'conv_new',
+        ...conversationData,
+        messageCount: 0,
+        createdAt: '2024-01-01T00:00:00Z',
+      };
+
+      mockClient.conversations.create.mockResolvedValue(mockCreated);
+
+      const result = await mockClient.conversations.create(conversationData);
+
+      expect(mockClient.conversations.create).toHaveBeenCalledWith(conversationData);
+      expect(result.id).toBe('conv_new');
+      expect(result.title).toBe('New Conversation');
+    });
+  });
+
+  describe('conversations get', () => {
+    it('should note that get endpoint is not yet implemented', () => {
+      // This is a placeholder test since the get endpoint is not yet in the SDK
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('conversations timeline', () => {
+    it('should note that timeline endpoint is not yet implemented', () => {
+      // This is a placeholder test since the timeline endpoint is not yet in the API
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('conversations search', () => {
+    it('should note that search endpoint is not yet implemented', () => {
+      // This is a placeholder test since the search endpoint is not yet in the API
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('conversations by-topic', () => {
+    it('should note that by-topic endpoint is not yet implemented', () => {
+      // This is a placeholder test since the by-topic endpoint is not yet in the API
+      expect(true).toBe(true);
+    });
+  });
+});
+

package/tests/commands/facts.test.ts

@@ -0,0 +1,210 @@
+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,
+}));
+
+describe('Facts Commands', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockClient = {
+      facts: {
+        list: jest.fn(),
+        get: jest.fn(),
+        create: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn(),
+        search: jest.fn(),
+      },
+    };
+
+    (getApiClient as jest.Mock).mockReturnValue(mockClient);
+  });
+
+  describe('facts list', () => {
+    it('should list facts with default pagination', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'fact_1',
+            subject: 'Machine Learning',
+            predicate: 'is_a',
+            object: 'AI Field',
+            confidence: 0.95,
+          },
+          {
+            id: 'fact_2',
+            subject: 'Python',
+            predicate: 'used_for',
+            object: 'Data Science',
+            confidence: 0.9,
+          },
+        ],
+        pagination: {
+          limit: 20,
+          offset: 0,
+          count: 2,
+        },
+      };
+
+      mockClient.facts.list.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.facts.list({ limit: 20, offset: 0 });
+
+      expect(mockClient.facts.list).toHaveBeenCalledWith({ limit: 20, offset: 0 });
+      expect(result.data).toHaveLength(2);
+      expect(result.pagination.count).toBe(2);
+    });
+  });
+
+  describe('facts get', () => {
+    it('should get a specific fact by ID', async () => {
+      const mockFact = {
+        id: 'fact_123',
+        subject: 'TypeScript',
+        predicate: 'is_a',
+        object: 'Programming Language',
+        confidence: 1.0,
+      };
+
+      mockClient.facts.get.mockResolvedValue(mockFact);
+
+      const result = await mockClient.facts.get('fact_123');
+
+      expect(mockClient.facts.get).toHaveBeenCalledWith('fact_123');
+      expect(result.id).toBe('fact_123');
+      expect(result.subject).toBe('TypeScript');
+    });
+  });
+
+  describe('facts create', () => {
+    it('should create a fact with required fields', async () => {
+      const factData = {
+        subject: 'Node.js',
+        predicate: 'is_a',
+        object: 'JavaScript Runtime',
+        confidence: 1.0,
+      };
+
+      const mockCreated = {
+        id: 'fact_new',
+        ...factData,
+        createdAt: '2024-01-01T00:00:00Z',
+      };
+
+      mockClient.facts.create.mockResolvedValue(mockCreated);
+
+      const result = await mockClient.facts.create(factData);
+
+      expect(mockClient.facts.create).toHaveBeenCalledWith(factData);
+      expect(result.id).toBe('fact_new');
+      expect(result.subject).toBe('Node.js');
+    });
+
+    it('should create a fact with optional memoryId', async () => {
+      const factData = {
+        subject: 'React',
+        predicate: 'is_a',
+        object: 'UI Library',
+        confidence: 0.95,
+        memoryId: 'mem_123',
+      };
+
+      mockClient.facts.create.mockResolvedValue({ id: 'fact_new', ...factData });
+
+      const result = await mockClient.facts.create(factData);
+
+      expect(result.memoryId).toBe('mem_123');
+    });
+
+    it('should validate confidence range', () => {
+      const validConfidence = 0.75;
+      expect(validConfidence).toBeGreaterThanOrEqual(0);
+      expect(validConfidence).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('facts update', () => {
+    it('should update fact fields', async () => {
+      const updates = {
+        confidence: 0.85,
+        object: 'Updated Object',
+      };
+
+      const mockUpdated = {
+        id: 'fact_123',
+        subject: 'Test',
+        predicate: 'is_a',
+        ...updates,
+      };
+
+      mockClient.facts.update.mockResolvedValue(mockUpdated);
+
+      const result = await mockClient.facts.update('fact_123', updates);
+
+      expect(mockClient.facts.update).toHaveBeenCalledWith('fact_123', updates);
+      expect(result.confidence).toBe(0.85);
+      expect(result.object).toBe('Updated Object');
+    });
+  });
+
+  describe('facts delete', () => {
+    it('should delete a fact', async () => {
+      mockClient.facts.delete.mockResolvedValue(undefined);
+
+      await mockClient.facts.delete('fact_123');
+
+      expect(mockClient.facts.delete).toHaveBeenCalledWith('fact_123');
+    });
+  });
+
+  describe('facts search', () => {
+    it('should search facts with query', async () => {
+      const mockResults = {
+        data: [
+          {
+            id: 'fact_1',
+            subject: 'Machine Learning',
+            predicate: 'is_a',
+            object: 'AI',
+            confidence: 0.95,
+          },
+        ],
+        count: 1,
+      };
+
+      mockClient.facts.search.mockResolvedValue(mockResults);
+
+      const result = await mockClient.facts.search({
+        query: 'machine learning',
+        limit: 10,
+      });
+
+      expect(mockClient.facts.search).toHaveBeenCalledWith({
+        query: 'machine learning',
+        limit: 10,
+      });
+      expect(result.data).toHaveLength(1);
+      expect(result.count).toBe(1);
+    });
+  });
+});
+