@deimoscloud/coreai 0.1.0

package/src/cli/commands/status.test.ts

@@ -0,0 +1,392 @@
+/**
+ * Status Command Tests
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { status, formatStatusResult, formatStatusSummary } from './status.js';
+import {
+  initKnowledgeLibrary,
+  initAgentKnowledgeLibrary,
+  writeInboxMessage,
+  updateAgentContext,
+} from '../../knowledge-library/index.js';
+
+describe('Status Command', () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(
+      tmpdir(),
+      `status-cmd-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('status', () => {
+    it('should warn when KnowledgeLibrary not initialized', () => {
+      const result = status({ projectRoot: testDir });
+
+      expect(result.success).toBe(true);
+      expect(result.agents).toEqual([]);
+      expect(result.warnings).toBeDefined();
+      expect(result.warnings?.some((w) => w.includes('not initialized'))).toBe(true);
+    });
+
+    it('should initialize KnowledgeLibrary with init option', () => {
+      const result = status({ projectRoot: testDir, init: true });
+
+      expect(result.success).toBe(true);
+      expect(result.knowledgeLibrary).toBeDefined();
+    });
+
+    it('should show agents from KnowledgeLibrary', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('frontend-engineer', { projectRoot: testDir });
+
+      const result = status({ projectRoot: testDir });
+
+      expect(result.success).toBe(true);
+      expect(result.agents.length).toBe(2);
+      expect(result.agents.map((a) => a.name)).toContain('backend-engineer');
+      expect(result.agents.map((a) => a.name)).toContain('frontend-engineer');
+    });
+
+    it('should show agents from config', async () => {
+      // Create config with agents
+      const configContent = `
+version: "1.0"
+project:
+  name: test-project
+team:
+  agents:
+    - backend-engineer
+    - qa-engineer
+`;
+      await fs.writeFile(join(testDir, 'coreai.config.yaml'), configContent);
+
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+
+      const result = status({ projectRoot: testDir });
+
+      expect(result.success).toBe(true);
+      // Should include both configured and initialized agents
+      expect(result.agents.map((a) => a.name)).toContain('backend-engineer');
+      expect(result.agents.map((a) => a.name)).toContain('qa-engineer');
+    });
+
+    it('should show status for specific agent', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('frontend-engineer', { projectRoot: testDir });
+
+      const result = status({ projectRoot: testDir, agent: 'backend-engineer' });
+
+      expect(result.success).toBe(true);
+      expect(result.agents.length).toBe(1);
+      expect(result.agents[0]?.name).toBe('backend-engineer');
+    });
+
+    it('should show pending message count', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('em', { projectRoot: testDir });
+
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Task 1',
+        body: 'Body 1',
+      });
+
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Task 2',
+        body: 'Body 2',
+      });
+
+      const result = status({ projectRoot: testDir });
+
+      expect(result.success).toBe(true);
+      const beAgent = result.agents.find((a) => a.name === 'backend-engineer');
+      expect(beAgent?.pendingMessages).toBe(2);
+    });
+
+    it('should show agent context', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+
+      updateAgentContext(
+        'backend-engineer',
+        {
+          status: 'working',
+          currentTask: 'Implementing feature X',
+          currentTicket: 'PROJ-123',
+        },
+        { projectRoot: testDir }
+      );
+
+      const result = status({ projectRoot: testDir });
+
+      expect(result.success).toBe(true);
+      const beAgent = result.agents.find((a) => a.name === 'backend-engineer');
+      expect(beAgent?.status).toBe('working');
+      expect(beAgent?.currentTask).toBe('Implementing feature X');
+      expect(beAgent?.currentTicket).toBe('PROJ-123');
+    });
+
+    it('should include message details in detailed mode', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('em', { projectRoot: testDir });
+
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Implement Feature X',
+        body: 'Details',
+      });
+
+      const result = status({ projectRoot: testDir, detailed: true });
+
+      expect(result.success).toBe(true);
+      const beAgent = result.agents.find((a) => a.name === 'backend-engineer');
+      expect(beAgent?.messageDetails).toBeDefined();
+      expect(beAgent?.messageDetails?.length).toBe(1);
+      expect(beAgent?.messageDetails?.[0]?.type).toBe('task-assignment');
+      expect(beAgent?.messageDetails?.[0]?.from).toBe('em');
+    });
+
+    it('should sort agents by pending messages', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('frontend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('em', { projectRoot: testDir });
+
+      // frontend-engineer gets more messages
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'frontend-engineer',
+        subject: 'Task 1',
+        body: 'Body',
+      });
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'frontend-engineer',
+        subject: 'Task 2',
+        body: 'Body',
+      });
+
+      // backend-engineer gets one message
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Task 1',
+        body: 'Body',
+      });
+
+      const result = status({ projectRoot: testDir });
+
+      expect(result.success).toBe(true);
+      // frontend-engineer should be first (2 messages)
+      expect(result.agents[0]?.name).toBe('frontend-engineer');
+      expect(result.agents[0]?.pendingMessages).toBe(2);
+    });
+
+    it('should show uninitialized agents from config', async () => {
+      const configContent = `
+version: "1.0"
+project:
+  name: test-project
+team:
+  agents:
+    - backend-engineer
+    - qa-engineer
+`;
+      await fs.writeFile(join(testDir, 'coreai.config.yaml'), configContent);
+
+      initKnowledgeLibrary({ projectRoot: testDir });
+      // Don't initialize any agents
+
+      const result = status({ projectRoot: testDir });
+
+      expect(result.success).toBe(true);
+      expect(result.agents.length).toBe(2);
+      expect(result.agents.every((a) => !a.initialized)).toBe(true);
+    });
+  });
+
+  describe('formatStatusResult', () => {
+    it('should format empty result', () => {
+      const result = status({ projectRoot: testDir, init: true });
+      const output = formatStatusResult(result);
+
+      expect(output).toContain('No agents found');
+    });
+
+    it('should format agents with pending messages', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      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 result = status({ projectRoot: testDir });
+      const output = formatStatusResult(result);
+
+      expect(output).toContain('backend-engineer');
+      expect(output).toContain('Pending messages: 1');
+    });
+
+    it('should format agents with current task', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+
+      updateAgentContext(
+        'backend-engineer',
+        {
+          status: 'working',
+          currentTask: 'Implementing feature X',
+        },
+        { projectRoot: testDir }
+      );
+
+      const result = status({ projectRoot: testDir });
+      const output = formatStatusResult(result);
+
+      expect(output).toContain('backend-engineer');
+      expect(output).toContain('Status: working');
+      expect(output).toContain('Implementing feature X');
+    });
+
+    it('should show error result', () => {
+      const result = {
+        success: false,
+        agents: [],
+        error: 'Something went wrong',
+      };
+
+      const output = formatStatusResult(result);
+      expect(output).toContain('Error');
+      expect(output).toContain('Something went wrong');
+    });
+
+    it('should show warnings', () => {
+      const result = {
+        success: true,
+        agents: [],
+        warnings: ['Warning 1', 'Warning 2'],
+      };
+
+      const output = formatStatusResult(result);
+      expect(output).toContain('Warning 1');
+      expect(output).toContain('Warning 2');
+    });
+
+    it('should show summary counts', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('frontend-engineer', { projectRoot: testDir });
+
+      updateAgentContext('backend-engineer', { status: 'working' }, { projectRoot: testDir });
+
+      const result = status({ projectRoot: testDir });
+      const output = formatStatusResult(result);
+
+      expect(output).toContain('Total agents: 2');
+      expect(output).toContain('Active: 1');
+    });
+
+    it('should show message details in detailed mode', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('em', { projectRoot: testDir });
+
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'backend-engineer',
+        subject: 'Implement Feature X',
+        body: 'Details',
+      });
+
+      const result = status({ projectRoot: testDir, detailed: true });
+      const output = formatStatusResult(result);
+
+      expect(output).toContain('task-assignment');
+      expect(output).toContain('from em');
+      expect(output).toContain('Implement Feature X');
+    });
+  });
+
+  describe('formatStatusSummary', () => {
+    it('should format compact summary', () => {
+      initKnowledgeLibrary({ projectRoot: testDir });
+      initAgentKnowledgeLibrary('backend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('frontend-engineer', { projectRoot: testDir });
+      initAgentKnowledgeLibrary('em', { projectRoot: testDir });
+
+      updateAgentContext('backend-engineer', { status: 'working' }, { projectRoot: testDir });
+
+      writeInboxMessage({
+        projectRoot: testDir,
+        type: 'task-assignment',
+        from: 'em',
+        to: 'frontend-engineer',
+        subject: 'Task',
+        body: 'Body',
+      });
+
+      const result = status({ projectRoot: testDir });
+      const summary = formatStatusSummary(result);
+
+      expect(summary).toContain('3 agents');
+      expect(summary).toContain('1 active');
+      expect(summary).toContain('1 pending messages');
+    });
+
+    it('should format error', () => {
+      const result = {
+        success: false,
+        agents: [],
+        error: 'Something went wrong',
+      };
+
+      const summary = formatStatusSummary(result);
+      expect(summary).toContain('Error');
+      expect(summary).toContain('Something went wrong');
+    });
+  });
+});