@deimoscloud/coreai 0.1.9 → 0.1.10

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

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