@ai-devkit/agent-manager 0.15.0 → 0.16.0

package/src/utils/AgentRegistry.ts

@@ -0,0 +1,139 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import type { AgentType } from '../adapters/AgentAdapter.js';
+
+export class RenameNotFoundError extends Error {
+    constructor(public agentName: string) {
+        super(`Agent "${agentName}" not found in registry.`);
+        this.name = 'RenameNotFoundError';
+    }
+}
+
+export class RenameConflictError extends Error {
+    constructor(public agentName: string) {
+        super(`Agent "${agentName}" is already in use.`);
+        this.name = 'RenameConflictError';
+    }
+}
+
+export interface RegistryEntry {
+    name: string;
+    type: AgentType;
+    pid: number;
+    tmuxSession: string;
+    cwd: string;
+    startedAt: string;  // ISO 8601
+    sessionId: string;
+    sessionFilePath: string;
+}
+
+interface RegistryFile {
+    entries: RegistryEntry[];
+}
+
+const DEFAULT_REGISTRY_PATH = path.join(os.homedir(), '.ai-devkit', 'agents.json');
+
+let defaultInstance: AgentRegistry | null = null;
+
+export class AgentRegistry {
+    private filePath: string;
+
+    constructor(filePath: string = DEFAULT_REGISTRY_PATH) {
+        this.filePath = filePath;
+    }
+
+    static default(): AgentRegistry {
+        if (!defaultInstance) {
+            defaultInstance = new AgentRegistry();
+        }
+        return defaultInstance;
+    }
+
+    private readFile(): RegistryFile {
+        try {
+            const raw = fs.readFileSync(this.filePath, 'utf8');
+            const parsed = JSON.parse(raw) as RegistryFile;
+            return { entries: Array.isArray(parsed.entries) ? parsed.entries : [] };
+        } catch {
+            return { entries: [] };
+        }
+    }
+
+    private writeFile(data: RegistryFile): void {
+        const dir = path.dirname(this.filePath);
+        fs.mkdirSync(dir, { recursive: true });
+        const tmp = `${this.filePath}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf8');
+        fs.renameSync(tmp, this.filePath);
+    }
+
+    private mergeEntry(incoming: RegistryEntry, existing: RegistryEntry | undefined): RegistryEntry {
+        if (!existing) return incoming;
+        return {
+            ...incoming,
+            tmuxSession: incoming.tmuxSession || existing.tmuxSession,
+        };
+    }
+
+    isAlive(entry: RegistryEntry): boolean {
+        try {
+            process.kill(entry.pid, 0);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    prune(): void {
+        const data = this.readFile();
+        const live = data.entries.filter((e) => this.isAlive(e));
+        if (live.length !== data.entries.length) {
+            this.writeFile({ entries: live });
+        }
+    }
+
+    register(entry: RegistryEntry): void {
+        this.registerBatch([entry]);
+    }
+
+    registerBatch(entries: RegistryEntry[]): void {
+        if (entries.length === 0) return;
+        const data = this.readFile();
+        for (const incoming of entries) {
+            const idx = data.entries.findIndex((e) => e.name === incoming.name);
+            if (idx >= 0) {
+                data.entries[idx] = this.mergeEntry(incoming, data.entries[idx]);
+            } else {
+                data.entries.push(incoming);
+            }
+        }
+        this.writeFile(data);
+    }
+
+    rename(currentName: string, newName: string): void {
+        const data = this.readFile();
+        const idx = data.entries.findIndex((e) => e.name === currentName);
+        if (idx < 0) {
+            throw new RenameNotFoundError(currentName);
+        }
+        const liveEntries = data.entries.filter((e) => this.isAlive(e));
+        const conflict = liveEntries.find((e) => e.name === newName);
+        if (conflict) {
+            throw new RenameConflictError(newName);
+        }
+        const pruned = liveEntries.map((e) =>
+            e.name === currentName ? { ...e, name: newName } : e,
+        );
+        this.writeFile({ entries: pruned });
+    }
+
+    lookup(name: string): RegistryEntry | null {
+        const data = this.readFile();
+        return data.entries.find((e) => e.name === name) ?? null;
+    }
+
+    list(): RegistryEntry[] {
+        return this.readFile().entries;
+    }
+}

package/src/utils/ClaudeSessionParser.ts

@@ -51,8 +51,23 @@ export interface ClaudeSession {
     firstUserMessage?: string;
 }
 
-/** Entry types that are metadata, not conversation state. */
-const METADATA_ENTRY_TYPES = new Set(['last-prompt', 'file-history-snapshot']);
+/**
+ * Top-level JSONL entry types that represent conversation/agent state.
+ *
+ * Only these types update `lastEntryType` for status determination. All
+ * other types Claude Code emits (`attachment`, `permission-mode`,
+ * `ai-title`, `queued_command`, `tools_changed`, `model_changed`,
+ * `hook_progress`, …) are UI-state events that must not overwrite the
+ * last conversation turn — otherwise polling between writes lands on a
+ * UI-state entry and `determineStatus` falls through to UNKNOWN.
+ */
+const CONVERSATION_ENTRY_TYPES = new Set([
+    'user',
+    'assistant',
+    'system',
+    'progress',
+    'thinking',
+]);
 
 /**
  * Parses Claude Code session JSONL files into structured data.
@@ -110,7 +125,7 @@ export class ClaudeSessionParser {
                     lastCwd = entry.cwd;
                 }
 
-                if (entry.type && !METADATA_ENTRY_TYPES.has(entry.type)) {
+                if (entry.type && CONVERSATION_ENTRY_TYPES.has(entry.type)) {
                     lastEntryType = entry.type;
 
                     if (entry.type === 'user') {
@@ -220,16 +235,12 @@ export class ClaudeSessionParser {
                 continue;
             }
 
-            const entryType = entry.type;
-            if (!entryType || METADATA_ENTRY_TYPES.has(entryType)) continue;
-            if (entryType === 'progress' || entryType === 'thinking') continue;
-
             let role: ConversationMessage['role'];
-            if (entryType === 'user') {
+            if (entry.type === 'user') {
                 role = 'user';
-            } else if (entryType === 'assistant') {
+            } else if (entry.type === 'assistant') {
                 role = 'assistant';
-            } else if (entryType === 'system') {
+            } else if (entry.type === 'system') {
                 role = 'system';
             } else {
                 continue;

package/src/utils/agents.ts

@@ -0,0 +1,41 @@
+import path from 'path';
+import type { AgentType } from '../adapters/AgentAdapter.js';
+
+export type StartableAgentType = Exclude<AgentType, 'other'>;
+
+export interface AgentConfig {
+    /** Shell command to launch the agent (sent to tmux via `send-keys`). */
+    command: string;
+    /** Returns true if the given `ps` command line belongs to this agent. */
+    matches: (psCommand: string) => boolean;
+}
+
+/**
+ * Per-agent configuration: launch command plus a matcher that recognizes the
+ * agent's process in `ps` output. Each matcher knows that agent's distribution
+ * quirks (e.g. gemini ships as a Node script so its real binary is in argv[1..]).
+ */
+export const AGENTS: Record<StartableAgentType, AgentConfig> = {
+    claude:     { command: 'claude',   matches: matchArgv0('claude') },
+    codex:      { command: 'codex',    matches: matchArgv0('codex') },
+    opencode:   { command: 'opencode', matches: matchArgv0('opencode') },
+    gemini_cli: { command: 'gemini',   matches: matchAnyToken('gemini') },
+};
+
+function matchArgv0(name: string): (psCommand: string) => boolean {
+    const lower = name.toLowerCase();
+    return (psCommand) => {
+        const token = psCommand.trim().split(/\s+/)[0];
+        return token ? path.basename(token).toLowerCase() === lower : false;
+    };
+}
+
+function matchAnyToken(name: string): (psCommand: string) => boolean {
+    const lower = name.toLowerCase();
+    return (psCommand) => {
+        for (const token of psCommand.trim().split(/\s+/)) {
+            if (path.basename(token).toLowerCase() === lower) return true;
+        }
+        return false;
+    };
+}