codex-linux 1.0.0

package/tests/unit/AgentOrchestrator.test.ts

@@ -0,0 +1,274 @@
+import { AgentOrchestrator } from '../../src/main/agents/AgentOrchestrator';
+import { AIProviderManager } from '../../src/main/providers/AIProviderManager';
+import { GitWorktreeManager } from '../../src/main/git/GitWorktreeManager';
+import { SkillsManager } from '../../src/main/skills/SkillsManager';
+import { DatabaseManager } from '../../src/main/DatabaseManager';
+import { SettingsManager } from '../../src/main/SettingsManager';
+import { AgentStatus, TaskStatus } from '../../src/shared/types';
+
+describe('AgentOrchestrator', () => {
+  let orchestrator: AgentOrchestrator;
+  let mockAIProviderManager: jest.Mocked<AIProviderManager>;
+  let mockGitWorktreeManager: jest.Mocked<GitWorktreeManager>;
+  let mockSkillsManager: jest.Mocked<SkillsManager>;
+  let mockDbManager: jest.Mocked<DatabaseManager>;
+  let mockSettingsManager: jest.Mocked<SettingsManager>;
+
+  beforeEach(() => {
+    mockAIProviderManager = {
+      getProvider: jest.fn(),
+    } as any;
+
+    mockGitWorktreeManager = {
+      createWorktree: jest.fn(),
+      removeWorktree: jest.fn(),
+    } as any;
+
+    mockSkillsManager = {
+      getSkill: jest.fn(),
+    } as any;
+
+    mockDbManager = {
+      getAllAgents: jest.fn().mockResolvedValue([]),
+      createAgent: jest.fn().mockResolvedValue(undefined),
+      updateAgent: jest.fn().mockResolvedValue(undefined),
+      deleteAgent: jest.fn().mockResolvedValue(undefined),
+      getAgent: jest.fn(),
+    } as any;
+
+    mockSettingsManager = {} as any;
+
+    orchestrator = new AgentOrchestrator(
+      mockAIProviderManager,
+      mockGitWorktreeManager,
+      mockSkillsManager,
+      mockDbManager
+    );
+  });
+
+  describe('createAgent', () => {
+    it('should create a new agent with worktree', async () => {
+      const config = {
+        name: 'Test Agent',
+        projectPath: '/test/project',
+        providerId: 'openai',
+        model: 'gpt-4o',
+      };
+
+      mockGitWorktreeManager.createWorktree.mockResolvedValue({
+        name: 'codex-agent-test123',
+        path: '/test/project/.codex/worktrees/codex-agent-test123',
+        commit: 'abc123',
+        branch: 'codex/codex-agent-test123',
+        isMain: false,
+        agents: [],
+        createdAt: new Date(),
+      });
+
+      const agent = await orchestrator.createAgent(config);
+
+      expect(agent).toBeDefined();
+      expect(agent.name).toBe(config.name);
+      expect(agent.status).toBe(AgentStatus.IDLE);
+      expect(agent.worktreeName).toContain('codex-agent-');
+      expect(mockGitWorktreeManager.createWorktree).toHaveBeenCalledWith(
+        config.projectPath,
+        expect.stringContaining('codex-agent-')
+      );
+      expect(mockDbManager.createAgent).toHaveBeenCalled();
+    });
+
+    it('should apply skills when creating agent', async () => {
+      const config = {
+        name: 'Test Agent',
+        projectPath: '/test/project',
+        providerId: 'openai',
+        model: 'gpt-4o',
+        skills: ['skill-1', 'skill-2'],
+      };
+
+      mockGitWorktreeManager.createWorktree.mockResolvedValue({
+        name: 'codex-agent-test',
+        path: '/test/project/.codex/worktrees/codex-agent-test',
+        commit: 'abc123',
+        branch: 'codex/codex-agent-test',
+        isMain: false,
+        agents: [],
+        createdAt: new Date(),
+      });
+
+      mockSkillsManager.getSkill.mockResolvedValue({
+        id: 'skill-1',
+        name: 'Test Skill',
+        files: [{ path: 'instructions.md', content: 'Test instructions', type: 'instruction' }],
+      } as any);
+
+      const agent = await orchestrator.createAgent(config);
+
+      expect(agent.skills).toEqual(config.skills);
+      expect(mockSkillsManager.getSkill).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw error if project path is invalid', async () => {
+      const config = {
+        name: 'Test Agent',
+        projectPath: '',
+        providerId: 'openai',
+        model: 'gpt-4o',
+      };
+
+      mockGitWorktreeManager.createWorktree.mockRejectedValue(
+        new Error('Invalid project path')
+      );
+
+      await expect(orchestrator.createAgent(config)).rejects.toThrow('Invalid project path');
+    });
+  });
+
+  describe('sendMessage', () => {
+    it('should send message and receive response', async () => {
+      const mockProvider = {
+        sendMessage: jest.fn().mockResolvedValue({
+          content: 'Test response',
+          metadata: { usage: { total_tokens: 100 } },
+        }),
+      };
+
+      mockAIProviderManager.getProvider.mockReturnValue(mockProvider as any);
+      mockDbManager.getAgent.mockResolvedValue({
+        id: 'agent-1',
+        name: 'Test Agent',
+        status: AgentStatus.IDLE,
+        messages: [],
+        providerId: 'openai',
+        model: 'gpt-4o',
+      } as any);
+
+      const response = await orchestrator.sendMessage('agent-1', 'Hello');
+
+      expect(response.content).toBe('Test response');
+      expect(mockProvider.sendMessage).toHaveBeenCalled();
+      expect(mockDbManager.updateAgent).toHaveBeenCalled();
+    });
+
+    it('should throw error if agent not found', async () => {
+      mockDbManager.getAgent.mockResolvedValue(null);
+
+      await expect(orchestrator.sendMessage('non-existent', 'Hello')).rejects.toThrow(
+        'Agent non-existent not found'
+      );
+    });
+  });
+
+  describe('executeTask', () => {
+    it('should create and execute a task', async () => {
+      const mockProvider = {
+        sendMessage: jest.fn().mockResolvedValue({
+          content: 'Task completed',
+          metadata: {},
+        }),
+      };
+
+      mockAIProviderManager.getProvider.mockReturnValue(mockProvider as any);
+      mockDbManager.getAgent.mockResolvedValue({
+        id: 'agent-1',
+        name: 'Test Agent',
+        status: AgentStatus.IDLE,
+        messages: [],
+        tasks: [],
+        providerId: 'openai',
+        model: 'gpt-4o',
+        projectPath: '/test',
+        worktreeName: 'test-worktree',
+      } as any);
+
+      const task = await orchestrator.executeTask('agent-1', 'Refactor code');
+
+      expect(task.description).toBe('Refactor code');
+      expect(task.status).toBe(TaskStatus.RUNNING);
+    });
+  });
+
+  describe('pause/resume/stop', () => {
+    beforeEach(async () => {
+      mockDbManager.getAgent.mockResolvedValue({
+        id: 'agent-1',
+        name: 'Test Agent',
+        status: AgentStatus.RUNNING,
+        messages: [],
+        tasks: [],
+      } as any);
+    });
+
+    it('should pause running agent', async () => {
+      await orchestrator.pauseAgent('agent-1');
+
+      expect(mockDbManager.updateAgent).toHaveBeenCalledWith(
+        expect.objectContaining({ status: AgentStatus.PAUSED })
+      );
+    });
+
+    it('should resume paused agent', async () => {
+      await orchestrator.resumeAgent('agent-1');
+
+      expect(mockDbManager.updateAgent).toHaveBeenCalledWith(
+        expect.objectContaining({ status: AgentStatus.IDLE })
+      );
+    });
+
+    it('should stop agent and cleanup', async () => {
+      await orchestrator.stopAgent('agent-1');
+
+      expect(mockDbManager.updateAgent).toHaveBeenCalledWith(
+        expect.objectContaining({ status: AgentStatus.IDLE })
+      );
+    });
+  });
+
+  describe('deleteAgent', () => {
+    it('should delete agent and cleanup worktree', async () => {
+      mockDbManager.getAgent.mockResolvedValue({
+        id: 'agent-1',
+        name: 'Test Agent',
+        projectPath: '/test/project',
+        worktreeName: 'codex-agent-test',
+      } as any);
+
+      await orchestrator.deleteAgent('agent-1');
+
+      expect(mockGitWorktreeManager.removeWorktree).toHaveBeenCalledWith(
+        '/test/project',
+        'codex-agent-test'
+      );
+      expect(mockDbManager.deleteAgent).toHaveBeenCalledWith('agent-1');
+    });
+  });
+
+  describe('applySkills', () => {
+    it('should apply skills to agent', async () => {
+      mockDbManager.getAgent.mockResolvedValue({
+        id: 'agent-1',
+        name: 'Test Agent',
+        skills: [],
+        messages: [],
+      } as any);
+
+      mockSkillsManager.getSkill.mockResolvedValue({
+        id: 'skill-1',
+        name: 'Code Review',
+        files: [
+          {
+            path: 'instructions.md',
+            content: 'Review code for quality',
+            type: 'instruction',
+          },
+        ],
+      } as any);
+
+      await orchestrator.applySkills('agent-1', ['skill-1']);
+
+      expect(mockSkillsManager.getSkill).toHaveBeenCalledWith('skill-1');
+      expect(mockDbManager.updateAgent).toHaveBeenCalled();
+    });
+  });
+});

package/tests/unit/DatabaseManager.test.ts

@@ -0,0 +1,262 @@
+import { DatabaseManager } from '../../src/main/DatabaseManager';
+import Database from 'better-sqlite3';
+import { AgentStatus, ChangeStatus, TaskStatus } from '../../src/shared/types';
+
+jest.mock('better-sqlite3');
+
+describe('DatabaseManager', () => {
+  let dbManager: DatabaseManager;
+  let mockDb: any;
+  let mockSelectChangeGet: jest.Mock;
+  let mockSelectAgentGet: jest.Mock;
+  let mockSelectCheckpointGet: jest.Mock;
+  let mockSelectLastCheckpointGet: jest.Mock;
+  let mockUpdateRun: jest.Mock;
+  let mockUpdateCheckpointRun: jest.Mock;
+
+  beforeEach(() => {
+    mockSelectChangeGet = jest.fn();
+    mockSelectAgentGet = jest.fn();
+    mockSelectCheckpointGet = jest.fn();
+    mockSelectLastCheckpointGet = jest.fn();
+    mockUpdateRun = jest.fn();
+    mockUpdateCheckpointRun = jest.fn();
+
+    mockDb = {
+      pragma: jest.fn(),
+      exec: jest.fn(),
+      prepare: jest.fn(),
+      close: jest.fn(),
+    };
+    (Database as unknown as jest.Mock).mockReturnValue(mockDb);
+    dbManager = new DatabaseManager();
+
+    mockDb.prepare.mockImplementation((sql: string) => {
+      if (sql.startsWith('SELECT * FROM code_changes WHERE id')) {
+        return { get: mockSelectChangeGet };
+      }
+      if (sql.startsWith('SELECT * FROM agents WHERE id')) {
+        return { get: mockSelectAgentGet };
+      }
+      if (sql.startsWith('SELECT * FROM checkpoints WHERE id')) {
+        return { get: mockSelectCheckpointGet };
+      }
+      if (sql.startsWith('SELECT * FROM checkpoints WHERE agent_id')) {
+        return { get: mockSelectLastCheckpointGet };
+      }
+      if (sql.startsWith('UPDATE code_changes SET status')) {
+        return { run: mockUpdateRun };
+      }
+      if (sql.startsWith('UPDATE checkpoints SET restored_at')) {
+        return { run: mockUpdateCheckpointRun };
+      }
+      return {
+        run: jest.fn(),
+        all: jest.fn().mockReturnValue([]),
+        get: jest.fn(),
+      };
+    });
+  });
+
+  describe('initialize', () => {
+    it('should create database and tables', async () => {
+      await dbManager.initialize();
+
+      expect(Database).toHaveBeenCalled();
+      expect(mockDb.pragma).toHaveBeenCalledWith('journal_mode = WAL');
+      expect(mockDb.exec).toHaveBeenCalledTimes(10);
+    });
+  });
+
+  describe('createAgent', () => {
+    it('should insert agent into database', async () => {
+      await dbManager.initialize();
+
+      const agent = {
+        id: 'agent-1',
+        name: 'Test Agent',
+        status: AgentStatus.IDLE,
+        projectPath: '/test',
+        worktreeName: 'worktree-1',
+        providerId: 'openai',
+        model: 'gpt-4o',
+        skills: [],
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        lastActiveAt: null,
+        metadata: {},
+      };
+
+      await dbManager.createAgent(agent as any);
+
+      const stmt = mockDb.prepare.mock.results[0].value;
+      expect(stmt.run).toHaveBeenCalled();
+    });
+  });
+
+  describe('getCodeChanges', () => {
+    it('should return changes for specific agent', async () => {
+      await dbManager.initialize();
+
+      mockDb.prepare.mockReturnValue({
+        all: jest.fn().mockReturnValue([
+          {
+            id: 'change-1',
+            file_path: 'test.ts',
+            status: ChangeStatus.PENDING,
+            created_at: Date.now(),
+          },
+        ]),
+      });
+
+      const changes = await dbManager.getCodeChanges('agent-1');
+
+      expect(changes).toHaveLength(1);
+      expect(changes[0].filePath).toBe('test.ts');
+    });
+
+    it('should return all changes if no agentId specified', async () => {
+      await dbManager.initialize();
+
+      mockDb.prepare.mockReturnValue({
+        all: jest.fn().mockReturnValue([]),
+      });
+
+      await dbManager.getCodeChanges();
+
+      const prepareCall = mockDb.prepare.mock.calls.find(
+        (call: any[]) => call[0].includes('SELECT * FROM code_changes')
+      );
+      expect(prepareCall).toBeDefined();
+    });
+  });
+
+  describe('approveCodeChange', () => {
+    it('should update change status to approved', async () => {
+      await dbManager.initialize();
+
+      await dbManager.approveCodeChange('change-1');
+
+      const approvePrepareIndex = mockDb.prepare.mock.calls.findIndex(
+        (call: any[]) => typeof call[0] === 'string' && call[0].includes('UPDATE code_changes') && call[0].includes('reviewed_at')
+      );
+      expect(approvePrepareIndex).toBeGreaterThanOrEqual(0);
+
+      const stmt = mockDb.prepare.mock.results[approvePrepareIndex].value;
+      expect(stmt.run).toHaveBeenCalledWith(
+        ChangeStatus.APPROVED,
+        expect.any(Number),
+        'user',
+        'change-1'
+      );
+    });
+  });
+
+  describe('rejectCodeChange', () => {
+    it('should update change status to rejected with comment', async () => {
+      await dbManager.initialize();
+
+      await dbManager.rejectCodeChange('change-1', 'Needs improvement');
+
+      const rejectPrepareIndex = mockDb.prepare.mock.calls.findIndex(
+        (call: any[]) => typeof call[0] === 'string' && call[0].includes('UPDATE code_changes') && call[0].includes('comment')
+      );
+      expect(rejectPrepareIndex).toBeGreaterThanOrEqual(0);
+
+      const stmt = mockDb.prepare.mock.results[rejectPrepareIndex].value;
+      expect(stmt.run).toHaveBeenCalledWith(
+        ChangeStatus.REJECTED,
+        expect.any(Number),
+        'user',
+        'Needs improvement',
+        'change-1'
+      );
+    });
+  });
+
+  describe('applyCodeChange', () => {
+    it('should throw if change is not approved', async () => {
+      await dbManager.initialize();
+
+      mockSelectChangeGet.mockReturnValue({
+        id: 'change-1',
+        agent_id: 'agent-1',
+        file_path: 'src/a.ts',
+        new_content: 'x',
+        status: ChangeStatus.PENDING
+      });
+
+      await expect(dbManager.applyCodeChange('change-1')).rejects.toThrow('must be approved');
+    });
+
+    it('should write file to worktree and mark as applied when approved', async () => {
+      await dbManager.initialize();
+
+      const fs = require('fs');
+      jest.spyOn(fs.promises, 'mkdir').mockResolvedValue(undefined);
+      jest.spyOn(fs.promises, 'writeFile').mockResolvedValue(undefined);
+      jest.spyOn(fs.promises, 'readFile').mockRejectedValue(new Error('missing'));
+
+      mockSelectChangeGet.mockReturnValue({
+        id: 'change-1',
+        agent_id: 'agent-1',
+        file_path: 'src/a.ts',
+        new_content: 'new',
+        status: ChangeStatus.APPROVED
+      });
+
+      mockSelectAgentGet.mockReturnValue({
+        id: 'agent-1',
+        metadata: JSON.stringify({ worktreePath: '/tmp/worktree' })
+      });
+
+      await dbManager.applyCodeChange('change-1');
+
+      expect(fs.promises.mkdir).toHaveBeenCalled();
+      expect(fs.promises.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('/tmp/worktree'),
+        'new',
+        'utf-8'
+      );
+      expect(mockUpdateRun).toHaveBeenCalledWith(ChangeStatus.APPLIED, 'change-1');
+    });
+  });
+
+  describe('restoreLastCheckpoint', () => {
+    it('should restore last non-restored checkpoint for agent', async () => {
+      await dbManager.initialize();
+
+      const fs = require('fs');
+      jest.spyOn(fs.promises, 'mkdir').mockResolvedValue(undefined);
+      jest.spyOn(fs.promises, 'writeFile').mockResolvedValue(undefined);
+
+      mockSelectLastCheckpointGet.mockReturnValue({
+        id: 'cp-1',
+        agent_id: 'agent-1',
+        file_path: 'src/a.ts',
+        content: 'old'
+      });
+
+      mockSelectCheckpointGet.mockReturnValue({
+        id: 'cp-1',
+        agent_id: 'agent-1',
+        file_path: 'src/a.ts',
+        content: 'old'
+      });
+
+      mockSelectAgentGet.mockReturnValue({
+        id: 'agent-1',
+        metadata: JSON.stringify({ worktreePath: '/tmp/worktree' })
+      });
+
+      await dbManager.restoreLastCheckpoint('agent-1');
+
+      expect(fs.promises.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('/tmp/worktree'),
+        'old',
+        'utf-8'
+      );
+      expect(mockUpdateCheckpointRun).toHaveBeenCalled();
+    });
+  });
+});

package/tests/unit/GitWorktreeManager.test.ts

@@ -0,0 +1,150 @@
+import { GitWorktreeManager } from '../../src/main/git/GitWorktreeManager';
+import simpleGit from 'simple-git';
+
+jest.mock('fs/promises', () => ({
+  mkdir: jest.fn().mockResolvedValue(undefined),
+  rmdir: jest.fn().mockResolvedValue(undefined),
+}));
+
+jest.mock('simple-git');
+
+describe('GitWorktreeManager', () => {
+  let manager: GitWorktreeManager;
+  let mockGit: any;
+
+  beforeEach(() => {
+    manager = new GitWorktreeManager();
+    mockGit = {
+      checkIsRepo: jest.fn().mockResolvedValue(true),
+      branchLocal: jest.fn().mockResolvedValue({ all: [] }),
+      checkoutBranch: jest.fn().mockResolvedValue(undefined),
+      deleteLocalBranch: jest.fn().mockResolvedValue(undefined),
+      revparse: jest.fn().mockImplementation(async (args: string[]) => {
+        if (Array.isArray(args) && args.includes('--show-toplevel')) return '/repo';
+        if (Array.isArray(args) && args.includes('--abbrev-ref')) return 'main';
+        return 'abc123';
+      }),
+      raw: jest.fn().mockResolvedValue(''),
+      status: jest.fn().mockResolvedValue({
+        staged: [],
+        not_added: [],
+        modified: [],
+        deleted: [],
+      }),
+      add: jest.fn().mockResolvedValue(undefined),
+      commit: jest.fn().mockResolvedValue({ commit: 'def456' }),
+      diff: jest.fn().mockResolvedValue('diff content'),
+    };
+    (simpleGit as jest.Mock).mockReturnValue(mockGit);
+  });
+
+  describe('createWorktree', () => {
+    it('should create worktree with new branch', async () => {
+      const worktree = await manager.createWorktree('/repo', 'test-worktree');
+
+      expect(worktree).toBeDefined();
+      expect(worktree.name).toBe('test-worktree');
+      expect(worktree.branch).toBe('codex/test-worktree');
+      expect(mockGit.checkoutBranch).toHaveBeenCalledWith(
+        'codex/test-worktree',
+        'main'
+      );
+    });
+
+    it('should delete existing branch if it exists', async () => {
+      mockGit.branchLocal.mockResolvedValue({
+        all: ['codex/test-worktree'],
+      });
+
+      await manager.createWorktree('/repo', 'test-worktree');
+
+      expect(mockGit.deleteLocalBranch).toHaveBeenCalledWith(
+        'codex/test-worktree',
+        true
+      );
+    });
+
+    it('should throw error if not a git repo', async () => {
+      mockGit.checkIsRepo.mockResolvedValue(false);
+
+      await expect(manager.createWorktree('/not-a-repo', 'test')).rejects.toThrow(
+        'not a git repository'
+      );
+    });
+  });
+
+  describe('listWorktrees', () => {
+    it('should parse worktree list output', async () => {
+      mockGit.raw.mockResolvedValue(
+        'worktree /repo\nHEAD abc123\nbranch refs/heads/main\n\n' +
+        'worktree /repo/.codex/worktrees/test\nHEAD def456\nbranch refs/heads/codex/test'
+      );
+
+      const worktrees = await manager.listWorktrees('/repo');
+
+      expect(worktrees).toHaveLength(2);
+      expect(worktrees[0].isMain).toBe(true);
+      expect(worktrees[1].branch).toBe('codex/test');
+    });
+
+    it('should return empty array on error', async () => {
+      mockGit.raw.mockRejectedValue(new Error('Git error'));
+
+      const worktrees = await manager.listWorktrees('/repo');
+
+      expect(worktrees).toEqual([]);
+    });
+  });
+
+  describe('removeWorktree', () => {
+    it('should remove worktree and delete branch', async () => {
+      await manager.removeWorktree('/repo', 'test-worktree');
+
+      expect(mockGit.raw).toHaveBeenCalledWith([
+        'worktree',
+        'remove',
+        '--force',
+        expect.stringContaining('test-worktree'),
+      ]);
+      expect(mockGit.deleteLocalBranch).toHaveBeenCalledWith(
+        'codex/test-worktree',
+        true
+      );
+    });
+  });
+
+  describe('commitChanges', () => {
+    it('should stage all files and commit', async () => {
+      const commitHash = await manager.commitChanges(
+        '/repo',
+        'Test commit message'
+      );
+
+      expect(mockGit.add).toHaveBeenCalledWith('.');
+      expect(mockGit.commit).toHaveBeenCalledWith('Test commit message');
+      expect(commitHash).toBe('def456');
+    });
+
+    it('should stage specific files if provided', async () => {
+      await manager.commitChanges('/repo', 'Test commit', ['file1.ts', 'file2.ts']);
+
+      expect(mockGit.add).toHaveBeenCalledWith(['file1.ts', 'file2.ts']);
+    });
+  });
+
+  describe('getChanges', () => {
+    it('should return staged and unstaged files', async () => {
+      mockGit.status.mockResolvedValue({
+        staged: ['staged-file.ts'],
+        not_added: ['new-file.ts'],
+        modified: ['modified-file.ts'],
+        deleted: ['deleted-file.ts'],
+      });
+
+      const changes = await manager.getChanges('/repo');
+
+      expect(changes.staged).toEqual(['staged-file.ts']);
+      expect(changes.unstaged).toEqual(['new-file.ts', 'modified-file.ts', 'deleted-file.ts']);
+    });
+  });
+});