@ai-devkit/agent-manager 0.32.0 → 0.33.1

package/dist/__tests__/adapters/CopilotAdapter.test.js

@@ -1,630 +0,0 @@
-/**
- * Tests for CopilotAdapter
- */ import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { CopilotAdapter } from '../../adapters/CopilotAdapter.js';
-import { AgentStatus } from '../../adapters/AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from '../../utils/process.js';
-import { generateAgentName } from '../../utils/matching.js';
-import { AgentRegistry } from '../../utils/AgentRegistry.js';
-vi.mock('../../utils/process.js', async (importOriginal)=>{
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        listAgentProcesses: vi.fn(),
-        enrichProcesses: vi.fn(),
-        captureProcessSnapshot: vi.fn()
-    };
-});
-vi.mock('../../utils/matching.js', ()=>({
-        generateAgentName: vi.fn()
-    }));
-const mockedListAgentProcesses = listAgentProcesses;
-const mockedEnrichProcesses = enrichProcesses;
-const mockedCaptureProcessSnapshot = captureProcessSnapshot;
-const mockedGenerateAgentName = generateAgentName;
-describe('CopilotAdapter', ()=>{
-    let adapter;
-    let tmpDir;
-    let sessionStateDir;
-    beforeEach(()=>{
-        adapter = new CopilotAdapter();
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'copilot-test-'));
-        sessionStateDir = path.join(tmpDir, 'session-state');
-        fs.mkdirSync(sessionStateDir, {
-            recursive: true
-        });
-        adapter.sessionStateDir = sessionStateDir;
-        mockedListAgentProcesses.mockReset();
-        mockedEnrichProcesses.mockReset();
-        mockedCaptureProcessSnapshot.mockReset();
-        mockedGenerateAgentName.mockReset();
-        mockedEnrichProcesses.mockImplementation((procs)=>procs);
-        // Compatibility shim for standalone adapter discovery; the manager captures once and slices by name.
-        mockedCaptureProcessSnapshot.mockImplementation(async (names)=>enrichProcesses(names.flatMap((name)=>listAgentProcesses(name))));
-        mockedGenerateAgentName.mockImplementation((cwd, pid)=>`${path.basename(cwd) || 'unknown'} (${pid})`);
-    });
-    afterEach(()=>{
-        fs.rmSync(tmpDir, {
-            recursive: true,
-            force: true
-        });
-    });
-    function writeSession(sessionId, options) {
-        const sessionDir = path.join(sessionStateDir, sessionId);
-        fs.mkdirSync(sessionDir, {
-            recursive: true
-        });
-        if (options.events) {
-            const lines = options.events.map((entry)=>typeof entry === 'string' ? entry : JSON.stringify(entry));
-            fs.writeFileSync(path.join(sessionDir, 'events.jsonl'), lines.join('\n'));
-        }
-        if (options.workspace) {
-            const lines = Object.entries(options.workspace).map(([key, value])=>`${key}: ${value}`);
-            fs.writeFileSync(path.join(sessionDir, 'workspace.yaml'), lines.join('\n'));
-        }
-        if (options.lockPid !== undefined) {
-            fs.writeFileSync(path.join(sessionDir, `inuse.${options.lockPid}.lock`), '');
-        }
-        return sessionDir;
-    }
-    function sessionStart(sessionId, cwd, startTime = '2026-06-09T09:50:00.000Z') {
-        return {
-            type: 'session.start',
-            data: {
-                sessionId,
-                startTime,
-                context: {
-                    cwd,
-                    gitRoot: cwd,
-                    branch: 'main'
-                }
-            },
-            timestamp: startTime
-        };
-    }
-    describe('initialization', ()=>{
-        it('exposes copilot type', ()=>{
-            expect(adapter.type).toBe('copilot');
-        });
-    });
-    describe('canHandle', ()=>{
-        it('returns true for copilot commands', ()=>{
-            expect(adapter.canHandle({
-                pid: 1,
-                command: 'copilot',
-                cwd: '/repo',
-                tty: 'ttys001'
-            })).toBe(true);
-        });
-        it('returns true for full-path Homebrew copilot commands', ()=>{
-            expect(adapter.canHandle({
-                pid: 2,
-                command: '/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot',
-                cwd: '/repo',
-                tty: 'ttys002'
-            })).toBe(true);
-        });
-        it('returns true for copilot.exe commands', ()=>{
-            expect(adapter.canHandle({
-                pid: 3,
-                command: '/usr/bin/copilot.exe',
-                cwd: '/repo',
-                tty: 'ttys003'
-            })).toBe(true);
-        });
-        it('returns false when copilot appears only in an argument', ()=>{
-            expect(adapter.canHandle({
-                pid: 4,
-                command: 'node /repo/copilot-plugin/index.js',
-                cwd: '/repo',
-                tty: 'ttys004'
-            })).toBe(false);
-        });
-    });
-    describe('detectAgents', ()=>{
-        it('returns empty list when no copilot process is running', async ()=>{
-            mockedListAgentProcesses.mockReturnValue([]);
-            const agents = await adapter.detectAgents();
-            expect(agents).toEqual([]);
-            expect(mockedListAgentProcesses).toHaveBeenCalledWith('copilot');
-        });
-        it('maps matching inuse lock and events to an active agent', async ()=>{
-            const processes = [
-                {
-                    pid: 14096,
-                    command: '/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot',
-                    cwd: '/repo',
-                    tty: 'ttys001'
-                }
-            ];
-            mockedListAgentProcesses.mockReturnValue(processes);
-            mockedEnrichProcesses.mockReturnValue(processes);
-            writeSession('sess-a', {
-                lockPid: 14096,
-                events: [
-                    sessionStart('sess-a', '/repo', '2026-06-09T09:50:00.000Z'),
-                    {
-                        type: 'user.message',
-                        data: {
-                            content: 'Build the Copilot adapter'
-                        },
-                        timestamp: new Date().toISOString()
-                    },
-                    {
-                        type: 'assistant.message',
-                        data: {
-                            content: 'I will inspect the code.'
-                        },
-                        timestamp: new Date().toISOString()
-                    }
-                ],
-                workspace: {
-                    id: 'sess-a',
-                    cwd: '/fallback',
-                    name: 'Fallback Name',
-                    created_at: '2026-06-09T09:49:00.000Z',
-                    updated_at: '2026-06-09T09:51:00.000Z'
-                }
-            });
-            const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                type: 'copilot',
-                status: AgentStatus.WAITING,
-                pid: 14096,
-                projectPath: '/repo',
-                sessionId: 'sess-a',
-                summary: 'Build the Copilot adapter',
-                sessionFilePath: path.join(sessionStateDir, 'sess-a', 'events.jsonl')
-            });
-        });
-        it('ignores invalid and unmatched lock PIDs', async ()=>{
-            const processes = [
-                {
-                    pid: 100,
-                    command: 'copilot',
-                    cwd: '/repo',
-                    tty: 'ttys001'
-                }
-            ];
-            mockedListAgentProcesses.mockReturnValue(processes);
-            mockedEnrichProcesses.mockReturnValue(processes);
-            writeSession('invalid', {
-                lockPid: 'not-a-pid',
-                events: [
-                    sessionStart('invalid', '/invalid')
-                ]
-            });
-            writeSession('unmatched', {
-                lockPid: 999999,
-                events: [
-                    sessionStart('unmatched', '/unmatched')
-                ]
-            });
-            const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                pid: 100,
-                sessionId: 'pid-100',
-                summary: 'Copilot process running'
-            });
-        });
-        it('falls back to process-only agent when no session lock matches', async ()=>{
-            const processes = [
-                {
-                    pid: 200,
-                    command: 'copilot',
-                    cwd: '/repo-b',
-                    tty: 'ttys002'
-                }
-            ];
-            mockedListAgentProcesses.mockReturnValue(processes);
-            mockedEnrichProcesses.mockReturnValue(processes);
-            const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                type: 'copilot',
-                status: AgentStatus.RUNNING,
-                pid: 200,
-                projectPath: '/repo-b',
-                sessionId: 'pid-200',
-                summary: 'Copilot process running'
-            });
-        });
-        it('suppresses wrapper process-only agents before the session lock exists', async ()=>{
-            const processes = [
-                {
-                    pid: 86800,
-                    command: 'copilot',
-                    cwd: '/repo',
-                    tty: 'ttys001',
-                    ppid: 84174
-                },
-                {
-                    pid: 86810,
-                    command: '/custom/install/copilot',
-                    cwd: '/repo',
-                    tty: 'ttys001',
-                    ppid: 86800
-                }
-            ];
-            mockedListAgentProcesses.mockReturnValue(processes);
-            mockedEnrichProcesses.mockReturnValue(processes);
-            const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                pid: 86810,
-                sessionId: 'pid-86810',
-                summary: 'Copilot process running'
-            });
-        });
-        it('carries the managed wrapper name to a process-only child before the session lock exists', async ()=>{
-            const registry = new AgentRegistry(path.join(tmpDir, 'agents.json'));
-            adapter = new CopilotAdapter(registry);
-            adapter.sessionStateDir = sessionStateDir;
-            const processes = [
-                {
-                    pid: 86800,
-                    command: 'copilot',
-                    cwd: '/repo',
-                    tty: 'ttys001',
-                    ppid: 84174
-                },
-                {
-                    pid: 86810,
-                    command: '/custom/install/copilot',
-                    cwd: '/repo',
-                    tty: 'ttys001',
-                    ppid: 86800
-                }
-            ];
-            registry.register({
-                name: 'copilot-started',
-                type: 'copilot',
-                pid: 86800,
-                tmuxSession: 'copilot-started',
-                cwd: '/repo',
-                startedAt: '2026-06-13T19:15:16.211Z',
-                sessionId: 'pid-86800',
-                sessionFilePath: ''
-            });
-            mockedListAgentProcesses.mockReturnValue(processes);
-            mockedEnrichProcesses.mockReturnValue(processes);
-            const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                name: 'copilot-started',
-                pid: 86810,
-                sessionId: 'pid-86810'
-            });
-        });
-        it('does not add duplicate process-only agent for wrapper process in the same terminal', async ()=>{
-            const processes = [
-                {
-                    pid: 14095,
-                    command: 'copilot',
-                    cwd: '/repo',
-                    tty: 'ttys001'
-                },
-                {
-                    pid: 14096,
-                    command: '/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot',
-                    cwd: '/repo',
-                    tty: 'ttys001'
-                }
-            ];
-            mockedListAgentProcesses.mockReturnValue(processes);
-            mockedEnrichProcesses.mockReturnValue(processes);
-            writeSession('sess-wrapper', {
-                lockPid: 14096,
-                events: [
-                    sessionStart('sess-wrapper', '/repo', '2026-06-09T09:50:00.000Z'),
-                    {
-                        type: 'user.message',
-                        data: {
-                            content: 'hello'
-                        },
-                        timestamp: new Date().toISOString()
-                    }
-                ]
-            });
-            const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                pid: 14096,
-                sessionId: 'sess-wrapper'
-            });
-        });
-        it('carries the managed wrapper name to a lock-backed child process', async ()=>{
-            const registry = new AgentRegistry(path.join(tmpDir, 'agents.json'));
-            adapter = new CopilotAdapter(registry);
-            adapter.sessionStateDir = sessionStateDir;
-            const processes = [
-                {
-                    pid: 14095,
-                    command: 'copilot',
-                    cwd: '/repo',
-                    tty: 'ttys001',
-                    ppid: 84174
-                },
-                {
-                    pid: 14096,
-                    command: '/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot',
-                    cwd: '/repo',
-                    tty: 'ttys001',
-                    ppid: 14095
-                }
-            ];
-            registry.register({
-                name: 'copilot-started',
-                type: 'copilot',
-                pid: 14095,
-                tmuxSession: 'copilot-started',
-                cwd: '/repo',
-                startedAt: '2026-06-13T19:15:16.211Z',
-                sessionId: 'pid-14095',
-                sessionFilePath: ''
-            });
-            mockedListAgentProcesses.mockReturnValue(processes);
-            mockedEnrichProcesses.mockReturnValue(processes);
-            writeSession('sess-wrapper', {
-                lockPid: 14096,
-                events: [
-                    sessionStart('sess-wrapper', '/repo', '2026-06-09T09:50:00.000Z'),
-                    {
-                        type: 'user.message',
-                        data: {
-                            content: 'hello'
-                        },
-                        timestamp: new Date().toISOString()
-                    }
-                ]
-            });
-            const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                name: 'copilot-started',
-                pid: 14096,
-                sessionId: 'sess-wrapper'
-            });
-        });
-        it('uses workspace metadata when events are missing', async ()=>{
-            const processes = [
-                {
-                    pid: 300,
-                    command: 'copilot',
-                    cwd: '/proc-cwd',
-                    tty: 'ttys003'
-                }
-            ];
-            mockedListAgentProcesses.mockReturnValue(processes);
-            mockedEnrichProcesses.mockReturnValue(processes);
-            writeSession('workspace-only', {
-                lockPid: 300,
-                workspace: {
-                    id: 'workspace-only',
-                    cwd: '/workspace-cwd',
-                    name: 'Workspace Session',
-                    created_at: '2026-06-09T09:00:00.000Z',
-                    updated_at: '2026-06-09T09:10:00.000Z'
-                }
-            });
-            const agents = await adapter.detectAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0]).toMatchObject({
-                pid: 300,
-                projectPath: '/workspace-cwd',
-                sessionId: 'workspace-only',
-                summary: 'Workspace Session'
-            });
-        });
-    });
-    describe('getConversation', ()=>{
-        it('parses user and assistant message events', ()=>{
-            const sessionDir = writeSession('conv', {
-                events: [
-                    sessionStart('conv', '/repo'),
-                    {
-                        type: 'user.message',
-                        data: {
-                            content: 'hello'
-                        },
-                        timestamp: '2026-06-09T09:50:01.000Z'
-                    },
-                    {
-                        type: 'assistant.message',
-                        data: {
-                            content: 'Hi there'
-                        },
-                        timestamp: '2026-06-09T09:50:02.000Z'
-                    }
-                ]
-            });
-            const messages = adapter.getConversation(path.join(sessionDir, 'events.jsonl'));
-            expect(messages).toEqual([
-                {
-                    role: 'user',
-                    content: 'hello',
-                    timestamp: '2026-06-09T09:50:01.000Z'
-                },
-                {
-                    role: 'assistant',
-                    content: 'Hi there',
-                    timestamp: '2026-06-09T09:50:02.000Z'
-                }
-            ]);
-        });
-        it('includes system/info/warning messages only in verbose mode', ()=>{
-            const sessionDir = writeSession('verbose', {
-                events: [
-                    {
-                        type: 'session.warning',
-                        data: {
-                            message: 'MCP failed'
-                        },
-                        timestamp: '2026-06-09T09:50:01.000Z'
-                    },
-                    {
-                        type: 'tool.execution_complete',
-                        data: {
-                            result: {
-                                content: 'Tool result'
-                            }
-                        },
-                        timestamp: '2026-06-09T09:50:02.000Z'
-                    }
-                ]
-            });
-            const filePath = path.join(sessionDir, 'events.jsonl');
-            expect(adapter.getConversation(filePath)).toEqual([]);
-            expect(adapter.getConversation(filePath, {
-                verbose: true
-            })).toEqual([
-                {
-                    role: 'system',
-                    content: 'MCP failed',
-                    timestamp: '2026-06-09T09:50:01.000Z'
-                },
-                {
-                    role: 'system',
-                    content: 'Tool result',
-                    timestamp: '2026-06-09T09:50:02.000Z'
-                }
-            ]);
-        });
-        it('skips malformed JSONL lines and missing text', ()=>{
-            const sessionDir = writeSession('malformed', {
-                events: [
-                    'not json',
-                    {
-                        type: 'user.message',
-                        data: {
-                            content: 'valid'
-                        },
-                        timestamp: '2026-06-09T09:50:01.000Z'
-                    },
-                    {
-                        type: 'assistant.message',
-                        data: {},
-                        timestamp: '2026-06-09T09:50:02.000Z'
-                    }
-                ]
-            });
-            const messages = adapter.getConversation(path.join(sessionDir, 'events.jsonl'));
-            expect(messages).toEqual([
-                {
-                    role: 'user',
-                    content: 'valid',
-                    timestamp: '2026-06-09T09:50:01.000Z'
-                }
-            ]);
-        });
-        it('returns empty array for missing file', ()=>{
-            expect(adapter.getConversation(path.join(tmpDir, 'missing.jsonl'))).toEqual([]);
-        });
-    });
-    describe('listSessions', ()=>{
-        it('returns historical sessions without active locks', async ()=>{
-            writeSession('history-a', {
-                events: [
-                    sessionStart('history-a', '/repo-a', '2026-06-09T09:00:00.000Z'),
-                    {
-                        type: 'user.message',
-                        data: {
-                            content: 'first user'
-                        },
-                        timestamp: '2026-06-09T09:00:01.000Z'
-                    },
-                    {
-                        type: 'assistant.message',
-                        data: {
-                            content: 'answer'
-                        },
-                        timestamp: '2026-06-09T09:00:02.000Z'
-                    }
-                ]
-            });
-            writeSession('history-b', {
-                events: [
-                    sessionStart('history-b', '/repo-b', '2026-06-09T10:00:00.000Z'),
-                    {
-                        type: 'user.message',
-                        data: {
-                            content: 'other user'
-                        },
-                        timestamp: '2026-06-09T10:00:01.000Z'
-                    }
-                ]
-            });
-            const sessions = await adapter.listSessions();
-            expect(sessions).toHaveLength(2);
-            const byId = Object.fromEntries(sessions.map((session)=>[
-                    session.sessionId,
-                    session
-                ]));
-            expect(byId['history-a']).toMatchObject({
-                type: 'copilot',
-                cwd: '/repo-a',
-                firstUserMessage: 'first user',
-                sessionFilePath: path.join(sessionStateDir, 'history-a', 'events.jsonl')
-            });
-            expect(byId['history-b']).toMatchObject({
-                type: 'copilot',
-                cwd: '/repo-b',
-                firstUserMessage: 'other user'
-            });
-        });
-        it('applies strict cwd filter', async ()=>{
-            writeSession('keep', {
-                events: [
-                    sessionStart('keep', '/repo')
-                ]
-            });
-            writeSession('drop', {
-                events: [
-                    sessionStart('drop', '/other')
-                ]
-            });
-            const sessions = await adapter.listSessions({
-                cwd: '/repo'
-            });
-            expect(sessions).toHaveLength(1);
-            expect(sessions[0].sessionId).toBe('keep');
-        });
-        it('uses workspace fallback for historical sessions without events', async ()=>{
-            writeSession('workspace-history', {
-                workspace: {
-                    id: 'workspace-history',
-                    cwd: '/workspace-repo',
-                    name: 'Workspace History',
-                    created_at: '2026-06-09T08:00:00.000Z',
-                    updated_at: '2026-06-09T08:10:00.000Z'
-                }
-            });
-            const sessions = await adapter.listSessions();
-            expect(sessions).toHaveLength(1);
-            expect(sessions[0]).toMatchObject({
-                type: 'copilot',
-                sessionId: 'workspace-history',
-                cwd: '/workspace-repo',
-                firstUserMessage: '',
-                sessionFilePath: path.join(sessionStateDir, 'workspace-history', 'events.jsonl')
-            });
-        });
-        it('skips session directories without events or workspace metadata', async ()=>{
-            fs.mkdirSync(path.join(sessionStateDir, 'empty'), {
-                recursive: true
-            });
-            const sessions = await adapter.listSessions();
-            expect(sessions).toEqual([]);
-        });
-        it('returns empty when session-state directory does not exist', async ()=>{
-            adapter.sessionStateDir = path.join(tmpDir, 'missing');
-            await expect(adapter.listSessions()).resolves.toEqual([]);
-        });
-    });
-});
-
-//# sourceMappingURL=CopilotAdapter.test.js.map