claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/__tests__/agent.test.js

@@ -1,291 +1,279 @@
 /**
  * Tests for agent command
- */
-
-import { jest } from '@jest/globals';
-import { agentCommand } from '../agent.js';
-import fs from 'fs-extra';
-import path from 'path';
-import chalk from 'chalk';
-import ora from 'ora';
-
+ */ import { jest } from "@jest/globals";
+import { agentCommand } from "../agent.js";
+import fs from "fs-extra";
+import path from "path";
+import ora from "ora";
 jest.mock('fs-extra');
 jest.mock('ora');
-jest.mock('chalk', () => ({
-  default: {
-    blue: jest.fn((str) => str),
-    green: jest.fn((str) => str),
-    yellow: jest.fn((str) => str),
-    red: jest.fn((str) => str),
-    cyan: jest.fn((str) => str),
-    dim: jest.fn((str) => str),
-    bold: jest.fn((str) => str),
-  },
-}));
-
-describe('Agent Command', () => {
-  let consoleLogSpy;
-  let consoleErrorSpy;
-  let mockSpinner;
-
-  beforeEach(() => {
-    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
-    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-
-    mockSpinner = {
-      start: jest.fn().mockReturnThis(),
-      succeed: jest.fn().mockReturnThis(),
-      fail: jest.fn().mockReturnThis(),
-      info: jest.fn().mockReturnThis(),
-      text: '',
-    };
-    ora.mockReturnValue(mockSpinner);
-
-    jest.clearAllMocks();
-  });
-
-  afterEach(() => {
-    consoleLogSpy.mockRestore();
-    consoleErrorSpy.mockRestore();
-  });
-
-  describe('list subcommand', () => {
-    test('should list available agent types', async () => {
-      await agentCommand(['list'], {});
-
-      expect(consoleLogSpy).toHaveBeenCalled();
-      const output = consoleLogSpy.mock.calls.flat().join('\n');
-
-      expect(output).toContain('Available Agent Types');
-      expect(output).toContain('researcher');
-      expect(output).toContain('coder');
-      expect(output).toContain('analyst');
-      expect(output).toContain('architect');
-      expect(output).toContain('tester');
-      expect(output).toContain('coordinator');
+jest.mock('chalk', ()=>({
+        default: {
+            blue: jest.fn((str)=>str),
+            green: jest.fn((str)=>str),
+            yellow: jest.fn((str)=>str),
+            red: jest.fn((str)=>str),
+            cyan: jest.fn((str)=>str),
+            dim: jest.fn((str)=>str),
+            bold: jest.fn((str)=>str)
+        }
+    }));
+describe('Agent Command', ()=>{
+    let consoleLogSpy;
+    let consoleErrorSpy;
+    let mockSpinner;
+    beforeEach(()=>{
+        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+        mockSpinner = {
+            start: jest.fn().mockReturnThis(),
+            succeed: jest.fn().mockReturnThis(),
+            fail: jest.fn().mockReturnThis(),
+            info: jest.fn().mockReturnThis(),
+            text: ''
+        };
+        ora.mockReturnValue(mockSpinner);
+        jest.clearAllMocks();
     });
-  });
-
-  describe('spawn subcommand', () => {
-    test('should spawn an agent with type', async () => {
-      const swarmDir = path.join(process.cwd(), '.claude', 'swarm');
-      fs.pathExists.mockResolvedValue(true);
-      fs.readJson.mockResolvedValue({
-        id: 'swarm-123',
-        agents: [],
-        status: 'active',
-      });
-      fs.writeJson.mockResolvedValue(undefined);
-
-      await agentCommand(['spawn', 'researcher'], {});
-
-      expect(mockSpinner.start).toHaveBeenCalledWith('Spawning researcher agent...');
-      expect(mockSpinner.succeed).toHaveBeenCalled();
-      expect(fs.writeJson).toHaveBeenCalled();
-
-      const writeCall = fs.writeJson.mock.calls[0];
-      expect(writeCall[1].agents).toHaveLength(1);
-      expect(writeCall[1].agents[0].type).toBe('researcher');
+    afterEach(()=>{
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
     });
-
-    test('should spawn agent with custom name', async () => {
-      fs.pathExists.mockResolvedValue(true);
-      fs.readJson.mockResolvedValue({
-        id: 'swarm-123',
-        agents: [],
-        status: 'active',
-      });
-      fs.writeJson.mockResolvedValue(undefined);
-
-      await agentCommand(['spawn', 'coder'], { name: 'CustomCoder' });
-
-      const writeCall = fs.writeJson.mock.calls[0];
-      expect(writeCall[1].agents[0].name).toBe('CustomCoder');
+    describe('list subcommand', ()=>{
+        test('should list available agent types', async ()=>{
+            await agentCommand([
+                'list'
+            ], {});
+            expect(consoleLogSpy).toHaveBeenCalled();
+            const output = consoleLogSpy.mock.calls.flat().join('\n');
+            expect(output).toContain('Available Agent Types');
+            expect(output).toContain('researcher');
+            expect(output).toContain('coder');
+            expect(output).toContain('analyst');
+            expect(output).toContain('architect');
+            expect(output).toContain('tester');
+            expect(output).toContain('coordinator');
+        });
     });
-
-    test('should error if swarm not initialized', async () => {
-      fs.pathExists.mockResolvedValue(false);
-
-      await agentCommand(['spawn', 'researcher'], {});
-
-      expect(mockSpinner.fail).toHaveBeenCalledWith(
-        expect.stringContaining('No active swarm found'),
-      );
+    describe('spawn subcommand', ()=>{
+        test('should spawn an agent with type', async ()=>{
+            const swarmDir = path.join(process.cwd(), '.claude', 'swarm');
+            fs.pathExists.mockResolvedValue(true);
+            fs.readJson.mockResolvedValue({
+                id: 'swarm-123',
+                agents: [],
+                status: 'active'
+            });
+            fs.writeJson.mockResolvedValue(undefined);
+            await agentCommand([
+                'spawn',
+                'researcher'
+            ], {});
+            expect(mockSpinner.start).toHaveBeenCalledWith('Spawning researcher agent...');
+            expect(mockSpinner.succeed).toHaveBeenCalled();
+            expect(fs.writeJson).toHaveBeenCalled();
+            const writeCall = fs.writeJson.mock.calls[0];
+            expect(writeCall[1].agents).toHaveLength(1);
+            expect(writeCall[1].agents[0].type).toBe('researcher');
+        });
+        test('should spawn agent with custom name', async ()=>{
+            fs.pathExists.mockResolvedValue(true);
+            fs.readJson.mockResolvedValue({
+                id: 'swarm-123',
+                agents: [],
+                status: 'active'
+            });
+            fs.writeJson.mockResolvedValue(undefined);
+            await agentCommand([
+                'spawn',
+                'coder'
+            ], {
+                name: 'CustomCoder'
+            });
+            const writeCall = fs.writeJson.mock.calls[0];
+            expect(writeCall[1].agents[0].name).toBe('CustomCoder');
+        });
+        test('should error if swarm not initialized', async ()=>{
+            fs.pathExists.mockResolvedValue(false);
+            await agentCommand([
+                'spawn',
+                'researcher'
+            ], {});
+            expect(mockSpinner.fail).toHaveBeenCalledWith(expect.stringContaining('No active swarm found'));
+        });
+        test('should error for invalid agent type', async ()=>{
+            fs.pathExists.mockResolvedValue(true);
+            fs.readJson.mockResolvedValue({
+                agents: []
+            });
+            await agentCommand([
+                'spawn',
+                'invalid-type'
+            ], {});
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid agent type'));
+        });
     });
-
-    test('should error for invalid agent type', async () => {
-      fs.pathExists.mockResolvedValue(true);
-      fs.readJson.mockResolvedValue({ agents: [] });
-
-      await agentCommand(['spawn', 'invalid-type'], {});
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid agent type'));
+    describe('status subcommand', ()=>{
+        test('should show agent status', async ()=>{
+            const mockSwarmData = {
+                id: 'swarm-123',
+                agents: [
+                    {
+                        id: 'agent-1',
+                        name: 'Researcher',
+                        type: 'researcher',
+                        status: 'active',
+                        created: new Date().toISOString(),
+                        tasksCompleted: 5,
+                        currentTask: 'Analyzing data'
+                    },
+                    {
+                        id: 'agent-2',
+                        name: 'Coder',
+                        type: 'coder',
+                        status: 'idle',
+                        created: new Date().toISOString(),
+                        tasksCompleted: 3,
+                        currentTask: null
+                    }
+                ]
+            };
+            fs.pathExists.mockResolvedValue(true);
+            fs.readJson.mockResolvedValue(mockSwarmData);
+            await agentCommand([
+                'status'
+            ], {});
+            const output = consoleLogSpy.mock.calls.flat().join('\n');
+            expect(output).toContain('Active Agents');
+            expect(output).toContain('Researcher');
+            expect(output).toContain('active');
+            expect(output).toContain('Analyzing data');
+            expect(output).toContain('Coder');
+            expect(output).toContain('idle');
+        });
+        test('should show specific agent status', async ()=>{
+            const mockSwarmData = {
+                agents: [
+                    {
+                        id: 'agent-1',
+                        name: 'Researcher',
+                        type: 'researcher',
+                        status: 'active',
+                        metrics: {
+                            tasksCompleted: 10,
+                            avgCompletionTime: 5000,
+                            successRate: 0.95
+                        }
+                    }
+                ]
+            };
+            fs.pathExists.mockResolvedValue(true);
+            fs.readJson.mockResolvedValue(mockSwarmData);
+            await agentCommand([
+                'status',
+                'agent-1'
+            ], {});
+            const output = consoleLogSpy.mock.calls.flat().join('\n');
+            expect(output).toContain('Agent Details');
+            expect(output).toContain('Researcher');
+            expect(output).toContain('Tasks Completed: 10');
+            expect(output).toContain('Success Rate: 95%');
+        });
     });
-  });
-
-  describe('status subcommand', () => {
-    test('should show agent status', async () => {
-      const mockSwarmData = {
-        id: 'swarm-123',
-        agents: [
-          {
-            id: 'agent-1',
-            name: 'Researcher',
-            type: 'researcher',
-            status: 'active',
-            created: new Date().toISOString(),
-            tasksCompleted: 5,
-            currentTask: 'Analyzing data',
-          },
-          {
-            id: 'agent-2',
-            name: 'Coder',
-            type: 'coder',
-            status: 'idle',
-            created: new Date().toISOString(),
-            tasksCompleted: 3,
-            currentTask: null,
-          },
-        ],
-      };
-
-      fs.pathExists.mockResolvedValue(true);
-      fs.readJson.mockResolvedValue(mockSwarmData);
-
-      await agentCommand(['status'], {});
-
-      const output = consoleLogSpy.mock.calls.flat().join('\n');
-      expect(output).toContain('Active Agents');
-      expect(output).toContain('Researcher');
-      expect(output).toContain('active');
-      expect(output).toContain('Analyzing data');
-      expect(output).toContain('Coder');
-      expect(output).toContain('idle');
+    describe('remove subcommand', ()=>{
+        test('should remove an agent', async ()=>{
+            const mockSwarmData = {
+                agents: [
+                    {
+                        id: 'agent-1',
+                        name: 'Researcher'
+                    },
+                    {
+                        id: 'agent-2',
+                        name: 'Coder'
+                    }
+                ]
+            };
+            fs.pathExists.mockResolvedValue(true);
+            fs.readJson.mockResolvedValue(mockSwarmData);
+            fs.writeJson.mockResolvedValue(undefined);
+            await agentCommand([
+                'remove',
+                'agent-1'
+            ], {});
+            expect(mockSpinner.succeed).toHaveBeenCalledWith(expect.stringContaining('Agent agent-1 removed'));
+            const writeCall = fs.writeJson.mock.calls[0];
+            expect(writeCall[1].agents).toHaveLength(1);
+            expect(writeCall[1].agents[0].id).toBe('agent-2');
+        });
+        test('should error if agent not found', async ()=>{
+            fs.pathExists.mockResolvedValue(true);
+            fs.readJson.mockResolvedValue({
+                agents: []
+            });
+            await agentCommand([
+                'remove',
+                'nonexistent'
+            ], {});
+            expect(mockSpinner.fail).toHaveBeenCalledWith(expect.stringContaining('Agent nonexistent not found'));
+        });
     });
-
-    test('should show specific agent status', async () => {
-      const mockSwarmData = {
-        agents: [
-          {
-            id: 'agent-1',
-            name: 'Researcher',
-            type: 'researcher',
-            status: 'active',
-            metrics: {
-              tasksCompleted: 10,
-              avgCompletionTime: 5000,
-              successRate: 0.95,
-            },
-          },
-        ],
-      };
-
-      fs.pathExists.mockResolvedValue(true);
-      fs.readJson.mockResolvedValue(mockSwarmData);
-
-      await agentCommand(['status', 'agent-1'], {});
-
-      const output = consoleLogSpy.mock.calls.flat().join('\n');
-      expect(output).toContain('Agent Details');
-      expect(output).toContain('Researcher');
-      expect(output).toContain('Tasks Completed: 10');
-      expect(output).toContain('Success Rate: 95%');
+    describe('assign subcommand', ()=>{
+        test('should assign task to agent', async ()=>{
+            const mockSwarmData = {
+                agents: [
+                    {
+                        id: 'agent-1',
+                        name: 'Researcher',
+                        currentTask: null
+                    }
+                ]
+            };
+            fs.pathExists.mockResolvedValue(true);
+            fs.readJson.mockResolvedValue(mockSwarmData);
+            fs.writeJson.mockResolvedValue(undefined);
+            await agentCommand([
+                'assign',
+                'agent-1',
+                'Research new algorithms'
+            ], {});
+            expect(mockSpinner.succeed).toHaveBeenCalledWith(expect.stringContaining('Task assigned to agent-1'));
+            const writeCall = fs.writeJson.mock.calls[0];
+            expect(writeCall[1].agents[0].currentTask).toBe('Research new algorithms');
+            expect(writeCall[1].agents[0].status).toBe('working');
+        });
     });
-  });
-
-  describe('remove subcommand', () => {
-    test('should remove an agent', async () => {
-      const mockSwarmData = {
-        agents: [
-          { id: 'agent-1', name: 'Researcher' },
-          { id: 'agent-2', name: 'Coder' },
-        ],
-      };
-
-      fs.pathExists.mockResolvedValue(true);
-      fs.readJson.mockResolvedValue(mockSwarmData);
-      fs.writeJson.mockResolvedValue(undefined);
-
-      await agentCommand(['remove', 'agent-1'], {});
-
-      expect(mockSpinner.succeed).toHaveBeenCalledWith(
-        expect.stringContaining('Agent agent-1 removed'),
-      );
-
-      const writeCall = fs.writeJson.mock.calls[0];
-      expect(writeCall[1].agents).toHaveLength(1);
-      expect(writeCall[1].agents[0].id).toBe('agent-2');
+    describe('help subcommand', ()=>{
+        test('should show help when no arguments', async ()=>{
+            await agentCommand([], {});
+            const output = consoleLogSpy.mock.calls.flat().join('\n');
+            expect(output).toContain('Agent Management');
+            expect(output).toContain('USAGE:');
+            expect(output).toContain('agent <subcommand>');
+            expect(output).toContain('SUBCOMMANDS:');
+        });
+        test('should show help for help subcommand', async ()=>{
+            await agentCommand([
+                'help'
+            ], {});
+            const output = consoleLogSpy.mock.calls.flat().join('\n');
+            expect(output).toContain('Agent Management');
+        });
     });
-
-    test('should error if agent not found', async () => {
-      fs.pathExists.mockResolvedValue(true);
-      fs.readJson.mockResolvedValue({ agents: [] });
-
-      await agentCommand(['remove', 'nonexistent'], {});
-
-      expect(mockSpinner.fail).toHaveBeenCalledWith(
-        expect.stringContaining('Agent nonexistent not found'),
-      );
+    describe('error handling', ()=>{
+        test('should handle file read errors gracefully', async ()=>{
+            fs.pathExists.mockResolvedValue(true);
+            fs.readJson.mockRejectedValue(new Error('Permission denied'));
+            await agentCommand([
+                'status'
+            ], {});
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'));
+        });
+        test('should handle invalid subcommands', async ()=>{
+            await agentCommand([
+                'invalid-subcommand'
+            ], {});
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown subcommand: invalid-subcommand'));
+        });
     });
-  });
-
-  describe('assign subcommand', () => {
-    test('should assign task to agent', async () => {
-      const mockSwarmData = {
-        agents: [{ id: 'agent-1', name: 'Researcher', currentTask: null }],
-      };
-
-      fs.pathExists.mockResolvedValue(true);
-      fs.readJson.mockResolvedValue(mockSwarmData);
-      fs.writeJson.mockResolvedValue(undefined);
-
-      await agentCommand(['assign', 'agent-1', 'Research new algorithms'], {});
-
-      expect(mockSpinner.succeed).toHaveBeenCalledWith(
-        expect.stringContaining('Task assigned to agent-1'),
-      );
-
-      const writeCall = fs.writeJson.mock.calls[0];
-      expect(writeCall[1].agents[0].currentTask).toBe('Research new algorithms');
-      expect(writeCall[1].agents[0].status).toBe('working');
-    });
-  });
-
-  describe('help subcommand', () => {
-    test('should show help when no arguments', async () => {
-      await agentCommand([], {});
-
-      const output = consoleLogSpy.mock.calls.flat().join('\n');
-      expect(output).toContain('Agent Management');
-      expect(output).toContain('USAGE:');
-      expect(output).toContain('agent <subcommand>');
-      expect(output).toContain('SUBCOMMANDS:');
-    });
-
-    test('should show help for help subcommand', async () => {
-      await agentCommand(['help'], {});
-
-      const output = consoleLogSpy.mock.calls.flat().join('\n');
-      expect(output).toContain('Agent Management');
-    });
-  });
-
-  describe('error handling', () => {
-    test('should handle file read errors gracefully', async () => {
-      fs.pathExists.mockResolvedValue(true);
-      fs.readJson.mockRejectedValue(new Error('Permission denied'));
-
-      await agentCommand(['status'], {});
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'));
-    });
-
-    test('should handle invalid subcommands', async () => {
-      await agentCommand(['invalid-subcommand'], {});
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Unknown subcommand: invalid-subcommand'),
-      );
-    });
-  });
 });

package/dist/src/cli/simple-commands/__tests__/memory.test.js

@@ -1,8 +1,7 @@
-import { describe, it, expect, jest } from '@jest/globals';
-
-describe('Memory Command', () => {
-  it('should handle memory command', () => {
-    // Placeholder test to prevent failures
-    expect(true).toBe(true);
-  });
+import { describe, it, expect } from "@jest/globals";
+describe('Memory Command', ()=>{
+    it('should handle memory command', ()=>{
+        // Placeholder test to prevent failures
+        expect(true).toBe(true);
+    });
 });