@ai-devkit/agent-manager 0.1.0 → 0.2.0

package/dist/terminal/index.d.ts

@@ -1,3 +1,4 @@
 export { TerminalFocusManager } from './TerminalFocusManager';
+export { TerminalType } from './TerminalFocusManager';
 export type { TerminalLocation } from './TerminalFocusManager';
 //# sourceMappingURL=index.d.ts.map

package/dist/terminal/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/terminal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/terminal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/terminal/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TerminalFocusManager = void 0;
+exports.TerminalType = exports.TerminalFocusManager = void 0;
 var TerminalFocusManager_1 = require("./TerminalFocusManager");
 Object.defineProperty(exports, "TerminalFocusManager", { enumerable: true, get: function () { return TerminalFocusManager_1.TerminalFocusManager; } });
+var TerminalFocusManager_2 = require("./TerminalFocusManager");
+Object.defineProperty(exports, "TerminalType", { enumerable: true, get: function () { return TerminalFocusManager_2.TerminalType; } });
 //# sourceMappingURL=index.js.map

package/dist/terminal/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/terminal/index.ts"],"names":[],"mappings":";;;AAAA,+DAA8D;AAArD,4HAAA,oBAAoB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/terminal/index.ts"],"names":[],"mappings":";;;AAAA,+DAA8D;AAArD,4HAAA,oBAAoB,OAAA;AAC7B,+DAAsD;AAA7C,oHAAA,YAAY,OAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-devkit/agent-manager",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Standalone agent detection and management utilities for AI DevKit",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/__tests__/adapters/ClaudeCodeAdapter.test.ts

@@ -127,7 +127,7 @@ describe('ClaudeCodeAdapter', () => {
             expect(agents[0].summary).toContain('Investigate failing tests in package');
         });
 
-        it('should return empty list when process cwd has no matching session', async () => {
+        it('should include process-only entry when process cwd has no matching session', async () => {
             mockedListProcesses.mockReturnValue([
                 {
                     pid: 777,
@@ -148,7 +148,125 @@ describe('ClaudeCodeAdapter', () => {
             jest.spyOn(adapter as unknown as AdapterPrivates, 'readHistory').mockReturnValue([]);
 
             const agents = await adapter.detectAgents();
-            expect(agents).toEqual([]);
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'claude',
+                status: AgentStatus.RUNNING,
+                pid: 777,
+                projectPath: '/project/without-session',
+                sessionId: 'pid-777',
+                summary: 'Claude process running',
+            });
+        });
+
+        it('should match process in subdirectory to project-root session', async () => {
+            mockedListProcesses.mockReturnValue([
+                {
+                    pid: 888,
+                    command: 'claude',
+                    cwd: '/Users/test/my-project/packages/cli',
+                    tty: 'ttys009',
+                },
+            ]);
+            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([
+                {
+                    sessionId: 'session-3',
+                    projectPath: '/Users/test/my-project',
+                    sessionLogPath: '/mock/path/session-3.jsonl',
+                    slug: 'gentle-otter',
+                    lastEntry: { type: 'assistant' },
+                    lastActive: new Date(),
+                },
+            ]);
+            jest.spyOn(adapter as unknown as AdapterPrivates, 'readHistory').mockReturnValue([
+                {
+                    display: 'Refactor CLI command flow',
+                    timestamp: Date.now(),
+                    project: '/Users/test/my-project',
+                    sessionId: 'session-3',
+                },
+            ]);
+
+            const agents = await adapter.detectAgents();
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'claude',
+                pid: 888,
+                sessionId: 'session-3',
+                projectPath: '/Users/test/my-project',
+                summary: 'Refactor CLI command flow',
+            });
+        });
+
+        it('should use latest history entry for process-only fallback session id', async () => {
+            mockedListProcesses.mockReturnValue([
+                {
+                    pid: 97529,
+                    command: 'claude',
+                    cwd: '/Users/test/my-project/packages/cli',
+                    tty: 'ttys021',
+                },
+            ]);
+            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([]);
+            jest.spyOn(adapter as unknown as AdapterPrivates, 'readHistory').mockReturnValue([
+                {
+                    display: '/status',
+                    timestamp: 1772122701536,
+                    project: '/Users/test/my-project/packages/cli',
+                    sessionId: '69237415-b0c3-4990-ba53-15882616509e',
+                },
+            ]);
+
+            const agents = await adapter.detectAgents();
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'claude',
+                pid: 97529,
+                projectPath: '/Users/test/my-project/packages/cli',
+                sessionId: '69237415-b0c3-4990-ba53-15882616509e',
+                summary: '/status',
+                status: AgentStatus.RUNNING,
+            });
+            expect(agents[0].lastActive.toISOString()).toBe('2026-02-26T16:18:21.536Z');
+        });
+
+        it('should prefer exact-cwd history session over parent-project session match', async () => {
+            mockedListProcesses.mockReturnValue([
+                {
+                    pid: 97529,
+                    command: 'claude',
+                    cwd: '/Users/test/my-project/packages/cli',
+                    tty: 'ttys021',
+                },
+            ]);
+            jest.spyOn(adapter as unknown as AdapterPrivates, 'readSessions').mockReturnValue([
+                {
+                    sessionId: 'old-parent-session',
+                    projectPath: '/Users/test/my-project',
+                    sessionLogPath: '/mock/path/old-parent-session.jsonl',
+                    slug: 'fluffy-brewing-kazoo',
+                    lastEntry: { type: 'assistant' },
+                    lastActive: new Date('2026-02-23T17:24:50.996Z'),
+                },
+            ]);
+            jest.spyOn(adapter as unknown as AdapterPrivates, 'readHistory').mockReturnValue([
+                {
+                    display: '/status',
+                    timestamp: 1772122701536,
+                    project: '/Users/test/my-project/packages/cli',
+                    sessionId: '69237415-b0c3-4990-ba53-15882616509e',
+                },
+            ]);
+
+            const agents = await adapter.detectAgents();
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'claude',
+                pid: 97529,
+                sessionId: '69237415-b0c3-4990-ba53-15882616509e',
+                projectPath: '/Users/test/my-project/packages/cli',
+                summary: '/status',
+            });
         });
     });
 

package/src/__tests__/adapters/CodexAdapter.test.ts

@@ -0,0 +1,319 @@
+import { beforeEach, describe, expect, it, jest } from '@jest/globals';
+import { CodexAdapter } from '../../adapters/CodexAdapter';
+import type { ProcessInfo } from '../../adapters/AgentAdapter';
+import { AgentStatus } from '../../adapters/AgentAdapter';
+import { listProcesses } from '../../utils/process';
+
+jest.mock('../../utils/process', () => ({
+    listProcesses: jest.fn(),
+}));
+
+const mockedListProcesses = listProcesses as jest.MockedFunction<typeof listProcesses>;
+
+interface MockSession {
+    sessionId: string;
+    projectPath: string;
+    summary: string;
+    sessionStart?: Date;
+    lastActive: Date;
+    lastPayloadType?: string;
+}
+
+describe('CodexAdapter', () => {
+    let adapter: CodexAdapter;
+
+    beforeEach(() => {
+        adapter = new CodexAdapter();
+        mockedListProcesses.mockReset();
+    });
+
+    it('should expose codex type', () => {
+        expect(adapter.type).toBe('codex');
+    });
+
+    it('should match codex commands in canHandle', () => {
+        expect(
+            adapter.canHandle({
+                pid: 1,
+                command: 'codex',
+                cwd: '/repo',
+                tty: 'ttys001',
+            }),
+        ).toBe(true);
+
+        expect(
+            adapter.canHandle({
+                pid: 2,
+                command: '/usr/local/bin/CODEX --sandbox workspace-write',
+                cwd: '/repo',
+                tty: 'ttys002',
+            }),
+        ).toBe(true);
+
+        expect(
+            adapter.canHandle({
+                pid: 4,
+                command: 'node /worktrees/feature-codex-adapter-agent-manager-package/node_modules/nx/src/daemon/server/start.js',
+                cwd: '/repo',
+                tty: 'ttys004',
+            }),
+        ).toBe(false);
+
+        expect(
+            adapter.canHandle({
+                pid: 3,
+                command: 'node app.js',
+                cwd: '/repo',
+                tty: 'ttys003',
+            }),
+        ).toBe(false);
+    });
+
+    it('should return empty list when no codex process is running', async () => {
+        mockedListProcesses.mockReturnValue([]);
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toEqual([]);
+    });
+
+    it('should map active codex sessions to matching processes by cwd', async () => {
+        mockedListProcesses.mockReturnValue([
+            { pid: 100, command: 'codex', cwd: '/repo-a', tty: 'ttys001' },
+        ] as ProcessInfo[]);
+
+        jest.spyOn(adapter as any, 'readSessions').mockReturnValue([
+            {
+                sessionId: 'abc12345-session',
+                projectPath: '/repo-a',
+                summary: 'Implement adapter flow',
+                sessionStart: new Date('2026-02-26T15:00:00.000Z'),
+                lastActive: new Date(),
+                lastPayloadType: 'token_count',
+            } as MockSession,
+        ]);
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toHaveLength(1);
+        expect(agents[0]).toMatchObject({
+            name: 'repo-a',
+            type: 'codex',
+            status: AgentStatus.RUNNING,
+            summary: 'Implement adapter flow',
+            pid: 100,
+            projectPath: '/repo-a',
+            sessionId: 'abc12345-session',
+        });
+    });
+
+    it('should still map sessions with task_complete as waiting when process is running', async () => {
+        mockedListProcesses.mockReturnValue([
+            { pid: 101, command: 'codex', cwd: '/repo-b', tty: 'ttys001' },
+        ] as ProcessInfo[]);
+
+        jest.spyOn(adapter as any, 'readSessions').mockReturnValue([
+            {
+                sessionId: 'ended-1111',
+                projectPath: '/repo-b',
+                summary: 'Ended turn but process still alive',
+                sessionStart: new Date('2026-02-26T15:00:00.000Z'),
+                lastActive: new Date(),
+                lastPayloadType: 'task_complete',
+            } as MockSession,
+        ]);
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toHaveLength(1);
+        expect(agents[0].sessionId).toBe('ended-1111');
+        expect(agents[0].status).toBe(AgentStatus.WAITING);
+    });
+
+    it('should use codex-session-id-prefix fallback name when cwd is missing', async () => {
+        mockedListProcesses.mockReturnValue([
+            { pid: 102, command: 'codex', cwd: '', tty: 'ttys009' },
+        ] as ProcessInfo[]);
+
+        jest.spyOn(adapter as any, 'readSessions').mockReturnValue([
+            {
+                sessionId: 'abcdef123456',
+                projectPath: '',
+                summary: 'No cwd available',
+                sessionStart: new Date('2026-02-26T15:00:00.000Z'),
+                lastActive: new Date(),
+                lastPayloadType: 'agent_reasoning',
+            } as MockSession,
+        ]);
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toHaveLength(1);
+        expect(agents[0].name).toBe('codex-abcdef12');
+    });
+
+    it('should report waiting status for recent agent_message events', async () => {
+        mockedListProcesses.mockReturnValue([
+            { pid: 103, command: 'codex', cwd: '/repo-c', tty: 'ttys010' },
+        ] as ProcessInfo[]);
+
+        jest.spyOn(adapter as any, 'readSessions').mockReturnValue([
+            {
+                sessionId: 'waiting-1234',
+                projectPath: '/repo-c',
+                summary: 'Waiting',
+                sessionStart: new Date('2026-02-26T15:00:00.000Z'),
+                lastActive: new Date(),
+                lastPayloadType: 'agent_message',
+            } as MockSession,
+        ]);
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toHaveLength(1);
+        expect(agents[0].status).toBe(AgentStatus.WAITING);
+    });
+
+    it('should report idle status when session exceeds shared threshold', async () => {
+        mockedListProcesses.mockReturnValue([
+            { pid: 104, command: 'codex', cwd: '/repo-d', tty: 'ttys011' },
+        ] as ProcessInfo[]);
+
+        jest.spyOn(adapter as any, 'readSessions').mockReturnValue([
+            {
+                sessionId: 'idle-5678',
+                projectPath: '/repo-d',
+                summary: 'Idle',
+                sessionStart: new Date('2026-02-26T15:00:00.000Z'),
+                lastActive: new Date(Date.now() - 10 * 60 * 1000),
+                lastPayloadType: 'token_count',
+            } as MockSession,
+        ]);
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toHaveLength(1);
+        expect(agents[0].status).toBe(AgentStatus.IDLE);
+    });
+
+    it('should list unmatched running codex process even when no session matches', async () => {
+        mockedListProcesses.mockReturnValue([
+            { pid: 105, command: 'codex', cwd: '/repo-x', tty: 'ttys012' },
+        ] as ProcessInfo[]);
+
+        jest.spyOn(adapter as any, 'readSessions').mockReturnValue([
+            {
+                sessionId: 'other-session',
+                projectPath: '/repo-y',
+                summary: 'Other repo',
+                sessionStart: new Date('2026-02-26T15:00:00.000Z'),
+                lastActive: new Date(),
+                lastPayloadType: 'agent_message',
+            } as MockSession,
+        ]);
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toHaveLength(1);
+        expect(agents[0].pid).toBe(105);
+    });
+
+    it('should list process when session metadata is unavailable', async () => {
+        mockedListProcesses.mockReturnValue([
+            { pid: 106, command: 'codex', cwd: '/repo-z', tty: 'ttys013' },
+        ] as ProcessInfo[]);
+        jest.spyOn(adapter as any, 'readSessions').mockReturnValue([]);
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toHaveLength(1);
+        expect(agents[0].pid).toBe(106);
+        expect(agents[0].summary).toContain('No Codex session metadata');
+    });
+
+    it('should choose same-cwd session closest to process start time', async () => {
+        mockedListProcesses.mockReturnValue([
+            { pid: 107, command: 'codex', cwd: '/repo-time', tty: 'ttys014' },
+        ] as ProcessInfo[]);
+
+        jest.spyOn(adapter as any, 'readSessions').mockReturnValue([
+            {
+                sessionId: 'far-session',
+                projectPath: '/repo-time',
+                summary: 'Far start time',
+                sessionStart: new Date('2026-02-26T14:00:00.000Z'),
+                lastActive: new Date('2026-02-26T15:10:00.000Z'),
+                lastPayloadType: 'agent_message',
+            } as MockSession,
+            {
+                sessionId: 'near-session',
+                projectPath: '/repo-time',
+                summary: 'Near start time',
+                sessionStart: new Date('2026-02-26T15:00:20.000Z'),
+                lastActive: new Date('2026-02-26T15:11:00.000Z'),
+                lastPayloadType: 'agent_message',
+            } as MockSession,
+        ]);
+        jest.spyOn(adapter as any, 'getProcessStartTimes').mockReturnValue(
+            new Map([[107, new Date('2026-02-26T15:00:00.000Z')]]),
+        );
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toHaveLength(1);
+        expect(agents[0].sessionId).toBe('near-session');
+    });
+
+    it('should prefer missing-cwd session before any-session fallback for unmatched process', async () => {
+        mockedListProcesses.mockReturnValue([
+            { pid: 108, command: 'codex', cwd: '/repo-missing-cwd', tty: 'ttys015' },
+        ] as ProcessInfo[]);
+
+        jest.spyOn(adapter as any, 'readSessions').mockReturnValue([
+            {
+                sessionId: 'any-session',
+                projectPath: '/another-repo',
+                summary: 'Any session fallback',
+                sessionStart: new Date('2026-02-26T15:00:00.000Z'),
+                lastActive: new Date('2026-02-26T15:12:00.000Z'),
+                lastPayloadType: 'agent_message',
+            } as MockSession,
+            {
+                sessionId: 'missing-cwd-session',
+                projectPath: '',
+                summary: 'Missing cwd session',
+                sessionStart: new Date('2026-02-26T15:00:10.000Z'),
+                lastActive: new Date('2026-02-26T15:11:00.000Z'),
+                lastPayloadType: 'agent_message',
+            } as MockSession,
+        ]);
+        jest.spyOn(adapter as any, 'getProcessStartTimes').mockReturnValue(
+            new Map([[108, new Date('2026-02-26T15:00:00.000Z')]]),
+        );
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toHaveLength(1);
+        expect(agents[0].sessionId).toBe('missing-cwd-session');
+    });
+
+    it('should not reuse the same session for multiple running processes', async () => {
+        mockedListProcesses.mockReturnValue([
+            { pid: 109, command: 'codex', cwd: '/repo-shared', tty: 'ttys016' },
+            { pid: 110, command: 'codex', cwd: '/repo-shared', tty: 'ttys017' },
+        ] as ProcessInfo[]);
+
+        jest.spyOn(adapter as any, 'readSessions').mockReturnValue([
+            {
+                sessionId: 'shared-session',
+                projectPath: '/repo-shared',
+                summary: 'Only one session exists',
+                sessionStart: new Date('2026-02-26T15:00:00.000Z'),
+                lastActive: new Date('2026-02-26T15:11:00.000Z'),
+                lastPayloadType: 'agent_message',
+            } as MockSession,
+        ]);
+        jest.spyOn(adapter as any, 'getProcessStartTimes').mockReturnValue(
+            new Map([
+                [109, new Date('2026-02-26T15:00:00.000Z')],
+                [110, new Date('2026-02-26T15:00:30.000Z')],
+            ]),
+        );
+
+        const agents = await adapter.detectAgents();
+        expect(agents).toHaveLength(2);
+        const mappedAgents = agents.filter((agent) => agent.sessionId === 'shared-session');
+        expect(mappedAgents).toHaveLength(1);
+        expect(agents.some((agent) => agent.sessionId.startsWith('pid-'))).toBe(true);
+    });
+});