@memnexus-ai/cli 0.1.0

package/tests/commands/graphrag.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('GraphRAG Commands', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockClient = {
+      graphrag: {
+        query: jest.fn(),
+        explain: jest.fn(),
+        queryCommunities: jest.fn(),
+      },
+    };
+
+    (getApiClient as jest.Mock).mockReturnValue(mockClient);
+  });
+
+  describe('graphrag query', () => {
+    it('should execute GraphRAG query', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'result_1',
+            answer: 'This is the answer to your query',
+            sources: ['source_1', 'source_2'],
+            confidence: 0.92,
+          },
+        ],
+      };
+
+      mockClient.graphrag.query.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.graphrag.query({
+        query: 'What is the meaning of life?',
+        mode: 'hybrid',
+        maxDepth: 3,
+        limit: 20,
+      });
+
+      expect(mockClient.graphrag.query).toHaveBeenCalledWith({
+        query: 'What is the meaning of life?',
+        mode: 'hybrid',
+        maxDepth: 3,
+        limit: 20,
+      });
+      expect(result.data).toHaveLength(1);
+      expect(result.data[0].confidence).toBe(0.92);
+    });
+
+    it('should support different query modes', async () => {
+      const mockResponse = { data: [] };
+
+      mockClient.graphrag.query.mockResolvedValue(mockResponse);
+
+      await mockClient.graphrag.query({
+        query: 'test',
+        mode: 'local',
+        maxDepth: 2,
+        limit: 10,
+      });
+
+      expect(mockClient.graphrag.query).toHaveBeenCalledWith({
+        query: 'test',
+        mode: 'local',
+        maxDepth: 2,
+        limit: 10,
+      });
+    });
+
+    it('should support context filtering', async () => {
+      const mockResponse = { data: [] };
+
+      mockClient.graphrag.query.mockResolvedValue(mockResponse);
+
+      await mockClient.graphrag.query({
+        query: 'test',
+        contextId: 'ctx_123',
+        mode: 'hybrid',
+        maxDepth: 3,
+        limit: 20,
+      });
+
+      expect(mockClient.graphrag.query).toHaveBeenCalledWith({
+        query: 'test',
+        contextId: 'ctx_123',
+        mode: 'hybrid',
+        maxDepth: 3,
+        limit: 20,
+      });
+    });
+  });
+
+  describe('graphrag explain', () => {
+    it('should explain query result', async () => {
+      const mockResult = {
+        resultId: 'result_1',
+        explanation: 'This result was derived by traversing the knowledge graph...',
+        graphPath: ['node_1', 'node_2', 'node_3'],
+        reasoning: 'The system found connections between...',
+      };
+
+      mockClient.graphrag.explain.mockResolvedValue(mockResult);
+
+      const result = await mockClient.graphrag.explain('result_1');
+
+      expect(mockClient.graphrag.explain).toHaveBeenCalledWith('result_1');
+      expect(result.explanation).toBeDefined();
+      expect(result.graphPath).toHaveLength(3);
+    });
+  });
+
+  describe('graphrag query-communities', () => {
+    it('should query communities', async () => {
+      const mockResponse = {
+        data: [
+          {
+            communityId: 'comm_1',
+            communityName: 'Technology Community',
+            answer: 'Community-level answer to the query',
+            confidence: 0.88,
+          },
+          {
+            communityId: 'comm_2',
+            communityName: 'Science Community',
+            answer: 'Another community perspective',
+            confidence: 0.85,
+          },
+        ],
+      };
+
+      mockClient.graphrag.queryCommunities.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.graphrag.queryCommunities({
+        query: 'What are the latest trends?',
+        limit: 10,
+      });
+
+      expect(mockClient.graphrag.queryCommunities).toHaveBeenCalledWith({
+        query: 'What are the latest trends?',
+        limit: 10,
+      });
+      expect(result.data).toHaveLength(2);
+    });
+
+    it('should support context filtering in community queries', async () => {
+      const mockResponse = { data: [] };
+
+      mockClient.graphrag.queryCommunities.mockResolvedValue(mockResponse);
+
+      await mockClient.graphrag.queryCommunities({
+        query: 'test',
+        contextId: 'ctx_123',
+        limit: 10,
+      });
+
+      expect(mockClient.graphrag.queryCommunities).toHaveBeenCalledWith({
+        query: 'test',
+        contextId: 'ctx_123',
+        limit: 10,
+      });
+    });
+  });
+});
+

package/tests/commands/memories.test.ts

@@ -0,0 +1,215 @@
+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('Memories Commands', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockClient = {
+      memories: {
+        list: jest.fn(),
+        get: jest.fn(),
+        create: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn(),
+      },
+      search: {
+        query: jest.fn(),
+      },
+    };
+
+    (getApiClient as jest.Mock).mockReturnValue(mockClient);
+  });
+
+  describe('memories list', () => {
+    it('should list memories with default pagination', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'mem_1',
+            content: 'Test memory 1',
+            memoryType: 'episodic',
+            createdAt: '2024-01-01T00:00:00Z',
+          },
+          {
+            id: 'mem_2',
+            content: 'Test memory 2',
+            memoryType: 'semantic',
+            createdAt: '2024-01-02T00:00:00Z',
+          },
+        ],
+        pagination: {
+          limit: 20,
+          offset: 0,
+          count: 2,
+        },
+      };
+
+      mockClient.memories.list.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.memories.list({ limit: 20, offset: 0 });
+
+      expect(mockClient.memories.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.memories.list.mockResolvedValue(mockResponse);
+
+      await mockClient.memories.list({ limit: 10, offset: 20 });
+
+      expect(mockClient.memories.list).toHaveBeenCalledWith({ limit: 10, offset: 20 });
+    });
+  });
+
+  describe('memories get', () => {
+    it('should get a specific memory by ID', async () => {
+      const mockMemory = {
+        id: 'mem_123',
+        content: 'Test memory content',
+        memoryType: 'episodic',
+        createdAt: '2024-01-01T00:00:00Z',
+      };
+
+      mockClient.memories.get.mockResolvedValue(mockMemory);
+
+      const result = await mockClient.memories.get('mem_123');
+
+      expect(mockClient.memories.get).toHaveBeenCalledWith('mem_123');
+      expect(result.id).toBe('mem_123');
+    });
+
+    it('should handle 404 errors gracefully', async () => {
+      mockClient.memories.get.mockRejectedValue(new Error('Not found'));
+
+      await expect(mockClient.memories.get('invalid_id')).rejects.toThrow('Not found');
+    });
+  });
+
+  describe('memories create', () => {
+    it('should create a memory with required fields', async () => {
+      const memoryData = {
+        content: 'New memory content',
+        memoryType: 'episodic',
+      };
+
+      const mockCreated = {
+        id: 'mem_new',
+        ...memoryData,
+        createdAt: '2024-01-01T00:00:00Z',
+      };
+
+      mockClient.memories.create.mockResolvedValue(mockCreated);
+
+      const result = await mockClient.memories.create(memoryData);
+
+      expect(mockClient.memories.create).toHaveBeenCalledWith(memoryData);
+      expect(result.id).toBe('mem_new');
+      expect(result.content).toBe(memoryData.content);
+    });
+
+    it('should create a memory with optional fields', async () => {
+      const memoryData = {
+        content: 'New memory',
+        memoryType: 'semantic',
+        context: 'work',
+        topics: ['project-a', 'meeting'],
+        importance: 0.8,
+      };
+
+      mockClient.memories.create.mockResolvedValue({ id: 'mem_new', ...memoryData });
+
+      const result = await mockClient.memories.create(memoryData);
+
+      expect(result.topics).toEqual(['project-a', 'meeting']);
+      expect(result.importance).toBe(0.8);
+    });
+  });
+
+  describe('memories update', () => {
+    it('should update memory fields', async () => {
+      const updates = {
+        content: 'Updated content',
+        importance: 0.9,
+      };
+
+      const mockUpdated = {
+        id: 'mem_123',
+        ...updates,
+        memoryType: 'episodic',
+      };
+
+      mockClient.memories.update.mockResolvedValue(mockUpdated);
+
+      const result = await mockClient.memories.update('mem_123', updates);
+
+      expect(mockClient.memories.update).toHaveBeenCalledWith('mem_123', updates);
+      expect(result.content).toBe('Updated content');
+    });
+  });
+
+  describe('memories delete', () => {
+    it('should delete a memory', async () => {
+      mockClient.memories.delete.mockResolvedValue(undefined);
+
+      await mockClient.memories.delete('mem_123');
+
+      expect(mockClient.memories.delete).toHaveBeenCalledWith('mem_123');
+    });
+  });
+
+  describe('memories search', () => {
+    it('should search memories with query', async () => {
+      const mockResults = {
+        results: [
+          {
+            memory: { id: 'mem_1', content: 'Matching memory' },
+            score: 0.95,
+          },
+        ],
+      };
+
+      mockClient.search.query.mockResolvedValue(mockResults);
+
+      const result = await mockClient.search.query({
+        query: 'test query',
+        limit: 10,
+        threshold: 0.7,
+      });
+
+      expect(mockClient.search.query).toHaveBeenCalledWith({
+        query: 'test query',
+        limit: 10,
+        threshold: 0.7,
+      });
+      expect(result.results).toHaveLength(1);
+    });
+  });
+});
+

package/tests/commands/patterns.test.ts

@@ -0,0 +1,201 @@
+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('Patterns Commands', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockClient = {
+      patterns: {
+        list: jest.fn(),
+        compile: jest.fn(),
+        update: jest.fn(),
+        feedback: jest.fn(),
+        getBehaviorState: jest.fn(),
+        setBehaviorState: jest.fn(),
+      },
+    };
+
+    (getApiClient as jest.Mock).mockReturnValue(mockClient);
+  });
+
+  describe('patterns list', () => {
+    it('should list patterns with default pagination', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: 'pat_1',
+            type: 'behavioral',
+            description: 'Test pattern 1',
+            confidence: 0.85,
+            lastUpdated: '2024-01-01T00:00:00Z',
+          },
+        ],
+        pagination: {
+          limit: 20,
+          offset: 0,
+          count: 1,
+        },
+      };
+
+      mockClient.patterns.list.mockResolvedValue(mockResponse);
+
+      const result = await mockClient.patterns.list({ limit: 20, offset: 0 });
+
+      expect(mockClient.patterns.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.patterns.list.mockResolvedValue(mockResponse);
+
+      await mockClient.patterns.list({ limit: 20, offset: 0, type: 'behavioral' });
+
+      expect(mockClient.patterns.list).toHaveBeenCalledWith({
+        limit: 20,
+        offset: 0,
+        type: 'behavioral',
+      });
+    });
+  });
+
+  describe('patterns compile', () => {
+    it('should compile patterns', async () => {
+      const mockResult = {
+        compiled: 5,
+        patterns: [],
+      };
+
+      mockClient.patterns.compile.mockResolvedValue(mockResult);
+
+      const result = await mockClient.patterns.compile({
+        contextId: 'ctx_123',
+        force: false,
+      });
+
+      expect(mockClient.patterns.compile).toHaveBeenCalledWith({
+        contextId: 'ctx_123',
+        force: false,
+      });
+      expect(result.compiled).toBe(5);
+    });
+  });
+
+  describe('patterns update', () => {
+    it('should update pattern', async () => {
+      const mockResult = {
+        id: 'pat_1',
+        description: 'Updated description',
+        confidence: 0.9,
+      };
+
+      mockClient.patterns.update.mockResolvedValue(mockResult);
+
+      const result = await mockClient.patterns.update('pat_1', {
+        description: 'Updated description',
+        confidence: 0.9,
+      });
+
+      expect(mockClient.patterns.update).toHaveBeenCalledWith('pat_1', {
+        description: 'Updated description',
+        confidence: 0.9,
+      });
+      expect(result.confidence).toBe(0.9);
+    });
+  });
+
+  describe('patterns feedback', () => {
+    it('should record feedback', async () => {
+      mockClient.patterns.feedback.mockResolvedValue({ success: true });
+
+      const result = await mockClient.patterns.feedback({
+        patternId: 'pat_1',
+        feedbackType: 'positive',
+        comment: 'Good pattern',
+      });
+
+      expect(mockClient.patterns.feedback).toHaveBeenCalledWith({
+        patternId: 'pat_1',
+        feedbackType: 'positive',
+        comment: 'Good pattern',
+      });
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('patterns behavior-state', () => {
+    it('should get behavioral state', async () => {
+      const mockResult = {
+        contextId: 'ctx_123',
+        activePatterns: ['pat_1', 'pat_2'],
+        state: {},
+      };
+
+      mockClient.patterns.getBehaviorState.mockResolvedValue(mockResult);
+
+      const result = await mockClient.patterns.getBehaviorState({
+        contextId: 'ctx_123',
+      });
+
+      expect(mockClient.patterns.getBehaviorState).toHaveBeenCalledWith({
+        contextId: 'ctx_123',
+      });
+      expect(result.activePatterns).toHaveLength(2);
+    });
+  });
+
+  describe('patterns set-behavior-state', () => {
+    it('should set behavioral state', async () => {
+      const state = { key: 'value' };
+      mockClient.patterns.setBehaviorState.mockResolvedValue({ success: true });
+
+      const result = await mockClient.patterns.setBehaviorState({
+        contextId: 'ctx_123',
+        state,
+        merge: false,
+      });
+
+      expect(mockClient.patterns.setBehaviorState).toHaveBeenCalledWith({
+        contextId: 'ctx_123',
+        state,
+        merge: false,
+      });
+      expect(result.success).toBe(true);
+    });
+  });
+});
+