@deimoscloud/coreai 0.1.0

package/src/knowledge-library/manager.test.ts

@@ -0,0 +1,536 @@
+/**
+ * KnowledgeLibrary Manager Tests
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import {
+  DEFAULT_KNOWLEDGE_LIBRARY_PATH,
+  STANDARD_FILES,
+  AGENT_DIRECTORIES,
+  CONTROL_FILES,
+  getAgentDirectories,
+  initKnowledgeLibrary,
+  initAgentKnowledgeLibrary,
+  agentKnowledgeLibraryExists,
+  getAgentKnowledgeState,
+  generateMessageFilename,
+  readInboxMessages,
+  writeInboxMessage,
+  markMessageProcessed,
+  getKnowledgeLibraryState,
+  updateAgentContext,
+  formatKnowledgeLibraryState,
+  formatAgentKnowledgeState,
+} from './manager.js';
+
+describe('KnowledgeLibrary Manager', () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `kl-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await fs.mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('constants', () => {
+    it('should have correct default path', () => {
+      expect(DEFAULT_KNOWLEDGE_LIBRARY_PATH).toBe('KnowledgeLibrary');
+    });
+
+    it('should have correct standard files', () => {
+      expect(STANDARD_FILES.context).toBe('context.txt');
+      expect(STANDARD_FILES.architecture).toBe('architecture.txt');
+      expect(STANDARD_FILES.prd).toBe('prd.txt');
+    });
+
+    it('should have correct agent directories', () => {
+      expect(AGENT_DIRECTORIES).toContain('inbox');
+      expect(AGENT_DIRECTORIES).toContain('inbox/processed');
+      expect(AGENT_DIRECTORIES).toContain('outbox');
+      expect(AGENT_DIRECTORIES).toContain('context');
+      expect(AGENT_DIRECTORIES).toContain('control');
+      expect(AGENT_DIRECTORIES).toContain('history');
+      expect(AGENT_DIRECTORIES).toContain('tech');
+    });
+
+    it('should have correct control files', () => {
+      expect(CONTROL_FILES.objectives).toBe('objectives.txt');
+      expect(CONTROL_FILES.decisions).toBe('decisions.txt');
+      expect(CONTROL_FILES.dependencies).toBe('dependencies.txt');
+    });
+  });
+
+  describe('getAgentDirectories', () => {
+    it('should return correct paths', () => {
+      const basePath = '/project/KnowledgeLibrary';
+      const dirs = getAgentDirectories(basePath, 'backend-engineer');
+
+      expect(dirs.root).toBe('/project/KnowledgeLibrary/backend-engineer');
+      expect(dirs.inbox).toBe('/project/KnowledgeLibrary/backend-engineer/inbox');
+      expect(dirs.inboxProcessed).toBe(
+        '/project/KnowledgeLibrary/backend-engineer/inbox/processed'
+      );
+      expect(dirs.outbox).toBe('/project/KnowledgeLibrary/backend-engineer/outbox');
+      expect(dirs.context).toBe('/project/KnowledgeLibrary/backend-engineer/context');
+      expect(dirs.control).toBe('/project/KnowledgeLibrary/backend-engineer/control');
+      expect(dirs.history).toBe('/project/KnowledgeLibrary/backend-engineer/history');
+      expect(dirs.tech).toBe('/project/KnowledgeLibrary/backend-engineer/tech');
+    });
+  });
+
+  describe('initKnowledgeLibrary', () => {
+    it('should create base directory', () => {
+      const result = initKnowledgeLibrary({ projectRoot: testDir });
+
+      expect(result.success).toBe(true);
+      expect(result.createdDirs.length).toBeGreaterThan(0);
+    });
+
+    it('should create default files', async () => {
+      const result = initKnowledgeLibrary({ projectRoot: testDir, createDefaults: true });
+
+      expect(result.success).toBe(true);
+      expect(result.createdFiles.length).toBe(3);
+
+      const basePath = join(testDir, DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+      const contextExists = await fs
+        .stat(join(basePath, 'context.txt'))
+        .then(() => true)
+        .catch(() => false);
+      const archExists = await fs
+        .stat(join(basePath, 'architecture.txt'))
+        .then(() => true)
+        .catch(() => false);
+      const prdExists = await fs
+        .stat(join(basePath, 'prd.txt'))
+        .then(() => true)
+        .catch(() => false);
+
+      expect(contextExists).toBe(true);
+      expect(archExists).toBe(true);
+      expect(prdExists).toBe(true);
+    });
+
+    it('should not create files when createDefaults is false', () => {
+      const result = initKnowledgeLibrary({ projectRoot: testDir, createDefaults: false });
+
+      expect(result.success).toBe(true);
+      expect(result.createdFiles.length).toBe(0);
+    });
+
+    it('should use custom base path', () => {
+      const result = initKnowledgeLibrary({
+        projectRoot: testDir,
+        basePath: 'CustomKL',
+        createDefaults: false,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.createdDirs).toContain(join(testDir, 'CustomKL'));
+    });
+  });
+
+  describe('initAgentKnowledgeLibrary', () => {
+    it('should create agent directories', async () => {
+      const result = initAgentKnowledgeLibrary('backend-engineer', {
+        projectRoot: testDir,
+      });
+
+      expect(result.success).toBe(true);
+
+      const basePath = join(testDir, DEFAULT_KNOWLEDGE_LIBRARY_PATH, 'backend-engineer');
+      for (const dir of AGENT_DIRECTORIES) {
+        const exists = await fs
+          .stat(join(basePath, dir))
+          .then(() => true)
+          .catch(() => false);
+        expect(exists).toBe(true);
+      }
+    });
+
+    it('should create default control files', async () => {
+      const result = initAgentKnowledgeLibrary('backend-engineer', {
+        projectRoot: testDir,
+        createDefaults: true,
+      });
+
+      expect(result.success).toBe(true);
+
+      const basePath = join(testDir, DEFAULT_KNOWLEDGE_LIBRARY_PATH, 'backend-engineer');
+      const objectivesExists = await fs
+        .stat(join(basePath, 'control', 'objectives.txt'))
+        .then(() => true)
+        .catch(() => false);
+      const decisionsExists = await fs
+        .stat(join(basePath, 'control', 'decisions.txt'))
+        .then(() => true)
+        .catch(() => false);
+      const depsExists = await fs
+        .stat(join(basePath, 'control', 'dependencies.txt'))
+        .then(() => true)
+        .catch(() => false);
+
+      expect(objectivesExists).toBe(true);
+      expect(decisionsExists).toBe(true);
+      expect(depsExists).toBe(true);
+    });
+
+    it('should create current context file', async () => {
+      const result = initAgentKnowledgeLibrary('backend-engineer', {
+        projectRoot: testDir,
+        createDefaults: true,
+      });
+
+      expect(result.success).toBe(true);
+
+      const contextPath = join(
+        testDir,
+        DEFAULT_KNOWLEDGE_LIBRARY_PATH,
+        'backend-engineer',
+        'context',
+        'current.txt'
+      );
+      const exists = await fs
+        .stat(contextPath)
+        .then(() => true)
+        .catch(() => false);
+      expect(exists).toBe(true);
+    });
+  });
+
+  describe('agentKnowledgeLibraryExists', () => {
+    it('should return false for non-existent agent', () => {
+      const exists = agentKnowledgeLibraryExists('unknown-agent', { projectRoot: testDir });
+      expect(exists).toBe(false);
+    });
+
+    it('should return true for initialized agent', () => {
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      const exists = agentKnowledgeLibraryExists('backend-engineer', { projectRoot: testDir });
+      expect(exists).toBe(true);
+    });
+  });
+
+  describe('generateMessageFilename', () => {
+    it('should generate filename with timestamp and subject', () => {
+      const filename = generateMessageFilename('engineering-manager', 'Task Assignment');
+
+      expect(filename).toMatch(/^\d{12}-engineering-manager-task-assignment\.md$/);
+    });
+
+    it('should sanitize subject', () => {
+      const filename = generateMessageFilename('em', 'Special!@#$Characters');
+
+      expect(filename).toMatch(/^\d{12}-em-special-characters\.md$/);
+    });
+
+    it('should truncate long subjects', () => {
+      const filename = generateMessageFilename(
+        'em',
+        'This is a very long subject that should be truncated'
+      );
+
+      expect(filename.length).toBeLessThan(70);
+    });
+  });
+
+  describe('writeInboxMessage and readInboxMessages', () => {
+    beforeEach(() => {
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('engineering-manager', { projectRoot: testDir });
+    });
+
+    it('should write message to recipient inbox', () => {
+      const result = writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'engineering-manager',
+        to: 'backend-engineer',
+        subject: 'Implement Feature X',
+        body: 'Please implement feature X as described in the ticket.',
+        ticket: 'PROJ-123',
+        priority: 'P1',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.path).toBeDefined();
+    });
+
+    it('should read message from inbox', () => {
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'engineering-manager',
+        to: 'backend-engineer',
+        subject: 'Implement Feature X',
+        body: 'Please implement feature X.',
+        ticket: 'PROJ-123',
+        priority: 'P1',
+      });
+
+      const messages = readInboxMessages('backend-engineer', { projectRoot: testDir });
+
+      expect(messages.length).toBe(1);
+      expect(messages[0]?.metadata.type).toBe('task-assignment');
+      expect(messages[0]?.metadata.from).toBe('engineering-manager');
+      expect(messages[0]?.metadata.ticket).toBe('PROJ-123');
+      expect(messages[0]?.metadata.priority).toBe('P1');
+    });
+
+    it('should filter messages by type', () => {
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Task 1',
+        body: 'Body 1',
+      });
+
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'feedback',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Feedback 1',
+        body: 'Body 2',
+      });
+
+      const tasks = readInboxMessages('backend-engineer', {
+        projectRoot: testDir,
+        type: 'task-assignment',
+      });
+
+      expect(tasks.length).toBe(1);
+      expect(tasks[0]?.metadata.type).toBe('task-assignment');
+    });
+
+    it('should filter messages by sender', () => {
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Task from EM',
+        body: 'Body',
+      });
+
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'review-request',
+        from: 'qa-engineer',
+        to: 'backend-engineer',
+        subject: 'Review request',
+        body: 'Body',
+      });
+
+      const fromEM = readInboxMessages('backend-engineer', {
+        projectRoot: testDir,
+        from: 'em',
+      });
+
+      expect(fromEM.length).toBe(1);
+      expect(fromEM[0]?.metadata.from).toBe('em');
+    });
+
+    it('should copy message to sender outbox', async () => {
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'engineering-manager',
+        to: 'backend-engineer',
+        subject: 'Test Task',
+        body: 'Body',
+      });
+
+      const outboxPath = join(
+        testDir,
+        DEFAULT_KNOWLEDGE_LIBRARY_PATH,
+        'engineering-manager',
+        'outbox'
+      );
+      const files = await fs.readdir(outboxPath);
+      expect(files.length).toBe(1);
+    });
+  });
+
+  describe('markMessageProcessed', () => {
+    beforeEach(() => {
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('engineering-manager', { projectRoot: testDir });
+    });
+
+    it('should move message to processed folder', async () => {
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Task',
+        body: 'Body',
+      });
+
+      const messages = readInboxMessages('backend-engineer', { projectRoot: testDir });
+      expect(messages.length).toBe(1);
+
+      const filename = messages[0]?.filename ?? '';
+      const result = markMessageProcessed('backend-engineer', filename, { projectRoot: testDir });
+
+      expect(result.success).toBe(true);
+
+      // Should not appear in inbox anymore
+      const inboxMessages = readInboxMessages('backend-engineer', { projectRoot: testDir });
+      expect(inboxMessages.length).toBe(0);
+
+      // Should appear in processed
+      const processedMessages = readInboxMessages('backend-engineer', {
+        projectRoot: testDir,
+        includeProcessed: true,
+      });
+      expect(processedMessages.length).toBe(1);
+    });
+
+    it('should fail for non-existent message', () => {
+      const result = markMessageProcessed('backend-engineer', 'nonexistent.md', {
+        projectRoot: testDir,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not found');
+    });
+  });
+
+  describe('getAgentKnowledgeState', () => {
+    it('should return uninitialized state for new agent', () => {
+      const state = getAgentKnowledgeState('unknown-agent', { projectRoot: testDir });
+
+      expect(state.initialized).toBe(false);
+      expect(state.pendingMessages).toEqual([]);
+    });
+
+    it('should return correct state for initialized agent', () => {
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('em', { projectRoot: testDir });
+
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Task',
+        body: 'Body',
+      });
+
+      const state = getAgentKnowledgeState('backend-engineer', { projectRoot: testDir });
+
+      expect(state.initialized).toBe(true);
+      expect(state.agentName).toBe('backend-engineer');
+      expect(state.pendingMessages.length).toBe(1);
+      expect(state.context).toBeDefined();
+    });
+  });
+
+  describe('updateAgentContext', () => {
+    beforeEach(() => {
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+    });
+
+    it('should update agent context', () => {
+      const result = updateAgentContext(
+        'backend-engineer',
+        {
+          status: 'working',
+          currentTask: 'Implementing feature X',
+          currentTicket: 'PROJ-123',
+        },
+        { projectRoot: testDir }
+      );
+
+      expect(result.success).toBe(true);
+
+      const state = getAgentKnowledgeState('backend-engineer', { projectRoot: testDir });
+      expect(state.context?.status).toBe('working');
+      expect(state.context?.currentTask).toBe('Implementing feature X');
+      expect(state.context?.currentTicket).toBe('PROJ-123');
+    });
+  });
+
+  describe('getKnowledgeLibraryState', () => {
+    it('should return null for uninitialized library', () => {
+      const state = getKnowledgeLibraryState({ projectRoot: testDir });
+      expect(state).toBeNull();
+    });
+
+    it('should return state with agents', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('frontend-engineer', { projectRoot: testDir });
+
+      const state = getKnowledgeLibraryState({ projectRoot: testDir });
+
+      expect(state).not.toBeNull();
+      expect(state?.agents).toContain('backend-engineer');
+      expect(state?.agents).toContain('frontend-engineer');
+    });
+  });
+
+  describe('formatKnowledgeLibraryState', () => {
+    it('should format null state', () => {
+      const output = formatKnowledgeLibraryState(null);
+      expect(output).toContain('not initialized');
+    });
+
+    it('should format initialized state', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+
+      const state = getKnowledgeLibraryState({ projectRoot: testDir });
+      const output = formatKnowledgeLibraryState(state);
+
+      expect(output).toContain('KnowledgeLibrary');
+      expect(output).toContain('context.txt');
+      expect(output).toContain('backend-engineer');
+    });
+  });
+
+  describe('formatAgentKnowledgeState', () => {
+    it('should format agent state', () => {
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      const state = getAgentKnowledgeState('backend-engineer', { projectRoot: testDir });
+
+      const output = formatAgentKnowledgeState(state);
+
+      expect(output).toContain('backend-engineer');
+      expect(output).toContain('Initialized');
+    });
+
+    it('should show pending messages', () => {
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('em', { projectRoot: testDir });
+
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Test Task',
+        body: 'Body',
+      });
+
+      const state = getAgentKnowledgeState('backend-engineer', { projectRoot: testDir });
+      const output = formatAgentKnowledgeState(state);
+
+      expect(output).toContain('Pending Messages (1)');
+      expect(output).toContain('task-assignment');
+    });
+  });
+});