@ai-devkit/agent-manager 0.32.0 → 0.33.0

package/src/providers/claude/ClaudeAgentMapper.ts

@@ -1,62 +1,63 @@
-import type { AgentInfo, ProcessInfo } from '../../adapters/AgentAdapter.js';
-import { AgentStatus } from '../../adapters/AgentAdapter.js';
-import { generateAgentName } from '../../utils/matching.js';
-import type { SessionFile } from '../../utils/session.js';
-import { ClaudeSessionParser, type ClaudeSession } from './ClaudeSessionParser.js';
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import type { SessionFile } from "../../utils/session.js";
+import { ClaudeSessionParser, type ClaudeSession } from "./ClaudeSessionParser.js";
 
 export interface ClaudeAgentLiveInfo {
-    pidStatus?: AgentStatus;
-    waitingFor?: string;
+  pidStatus?: AgentStatus;
+  waitingFor?: string;
 }
 
 export interface ClaudeSessionAgentInput {
-    session: ClaudeSession;
-    processInfo: ProcessInfo;
-    sessionFile: SessionFile;
-    liveInfo?: ClaudeAgentLiveInfo;
+  session: ClaudeSession;
+  processInfo: ProcessInfo;
+  sessionFile: SessionFile;
+  liveInfo?: ClaudeAgentLiveInfo;
 }
 
 export class ClaudeAgentMapper {
-    constructor(private readonly parser: ClaudeSessionParser = new ClaudeSessionParser()) {}
+  constructor(private readonly parser: ClaudeSessionParser = new ClaudeSessionParser()) {}
 
-    mapSessionToAgent({
-        session,
-        processInfo,
-        sessionFile,
-        liveInfo,
-    }: ClaudeSessionAgentInput): AgentInfo {
-        // Live PID-file status is authoritative when present — JSONL-derived
-        // status mis-classifies sessions whose latest entry is a UI-state
-        // event like `permission-mode` or `ai-title`.
-        const status = liveInfo?.pidStatus ?? this.parser.determineStatus(session);
-        const baseSummary = session.lastUserMessage || 'Session started';
-        const summary = status === AgentStatus.WAITING && liveInfo?.waitingFor
-            ? `${baseSummary} — waiting for ${liveInfo.waitingFor}`
-            : baseSummary;
+  mapSessionToAgent({
+    session,
+    processInfo,
+    sessionFile,
+    liveInfo,
+  }: ClaudeSessionAgentInput): AgentInfo {
+    // Live PID-file status is authoritative when present — JSONL-derived
+    // status mis-classifies sessions whose latest entry is a UI-state
+    // event like `permission-mode` or `ai-title`.
+    const status = liveInfo?.pidStatus ?? this.parser.determineStatus(session);
+    const baseSummary = session.lastUserMessage || "Session started";
+    const summary =
+      status === AgentStatus.WAITING && liveInfo?.waitingFor
+        ? `${baseSummary} — waiting for ${liveInfo.waitingFor}`
+        : baseSummary;
 
-        return {
-            name: generateAgentName(processInfo.cwd, processInfo.pid),
-            type: 'claude',
-            status,
-            summary,
-            pid: processInfo.pid,
-            projectPath: sessionFile.resolvedCwd || processInfo.cwd || '',
-            sessionId: sessionFile.sessionId,
-            lastActive: session.lastActive,
-            sessionFilePath: sessionFile.filePath,
-        };
-    }
+    return {
+      name: generateAgentName(processInfo.cwd, processInfo.pid),
+      type: "claude",
+      status,
+      summary,
+      pid: processInfo.pid,
+      projectPath: sessionFile.resolvedCwd || processInfo.cwd || "",
+      sessionId: sessionFile.sessionId,
+      lastActive: session.lastActive,
+      sessionFilePath: sessionFile.filePath,
+    };
+  }
 
-    mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
-        return {
-            name: generateAgentName(processInfo.cwd || '', processInfo.pid),
-            type: 'claude',
-            status: AgentStatus.IDLE,
-            summary: 'Unknown',
-            pid: processInfo.pid,
-            projectPath: processInfo.cwd || '',
-            sessionId: `pid-${processInfo.pid}`,
-            lastActive: new Date(),
-        };
-    }
+  mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
+    return {
+      name: generateAgentName(processInfo.cwd || "", processInfo.pid),
+      type: "claude",
+      status: AgentStatus.IDLE,
+      summary: "Unknown",
+      pid: processInfo.pid,
+      projectPath: processInfo.cwd || "",
+      sessionId: `pid-${processInfo.pid}`,
+      lastActive: new Date(),
+    };
+  }
 }

package/src/providers/claude/ClaudeCodeAdapter.ts

@@ -1,18 +1,22 @@
-import * as path from 'path';
+import * as path from "path";
 import type {
-    AgentAdapter,
-    AgentInfo,
-    ProcessInfo,
-    ConversationMessage,
-    SessionSummary,
-    ListSessionsOptions,
-    AgentDetectionContext,
-} from '../../adapters/AgentAdapter.js';
-import { captureProcessSnapshot, executableBasename, filterByProcessNames } from '../../utils/process.js';
-import { safeStat } from '../../utils/session.js';
-import { ClaudeSessionParser } from './ClaudeSessionParser.js';
-import { ClaudeAgentMapper } from './ClaudeAgentMapper.js';
-import { ClaudeSessionLocator } from './ClaudeSessionLocator.js';
+  AgentAdapter,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  SessionSummary,
+  ListSessionsOptions,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import {
+  captureProcessSnapshot,
+  executableBasename,
+  filterByProcessNames,
+} from "../../utils/process.js";
+import { safeStat } from "../../utils/session.js";
+import { ClaudeSessionParser } from "./ClaudeSessionParser.js";
+import { ClaudeAgentMapper } from "./ClaudeAgentMapper.js";
+import { ClaudeSessionLocator } from "./ClaudeSessionLocator.js";
 
 /**
  * Claude Code Adapter
@@ -25,136 +29,140 @@ import { ClaudeSessionLocator } from './ClaudeSessionLocator.js';
  * 5. Extracting summary from last user message in session JSONL
  */
 export class ClaudeCodeAdapter implements AgentAdapter {
-    readonly type = 'claude' as const;
-    readonly processNames = ['claude'] as const;
-
-    private parser: ClaudeSessionParser;
-    private mapper: ClaudeAgentMapper;
-    private projectsDir: string;
-    private sessionsDir: string;
-
-    constructor() {
-        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-        this.projectsDir = path.join(homeDir, '.claude', 'projects');
-        this.sessionsDir = path.join(homeDir, '.claude', 'sessions');
-        this.parser = new ClaudeSessionParser();
-        this.mapper = new ClaudeAgentMapper(this.parser);
+  readonly type = "claude" as const;
+  readonly processNames = ["claude"] as const;
+
+  private parser: ClaudeSessionParser;
+  private mapper: ClaudeAgentMapper;
+  private projectsDir: string;
+  private sessionsDir: string;
+
+  constructor() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.projectsDir = path.join(homeDir, ".claude", "projects");
+    this.sessionsDir = path.join(homeDir, ".claude", "sessions");
+    this.parser = new ClaudeSessionParser();
+    this.mapper = new ClaudeAgentMapper(this.parser);
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return this.isClaudeExecutable(processInfo.command);
+  }
+
+  private isClaudeExecutable(command: string): boolean {
+    const base = executableBasename(command);
+    return base === "claude" || base === "claude.exe";
+  }
+
+  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
+    const relevant = filterByProcessNames(snapshot, this.processNames);
+    const processes = relevant.filter((process) => this.canHandle(process));
+    if (processes.length === 0) {
+      return [];
     }
 
-    canHandle(processInfo: ProcessInfo): boolean {
-        return this.isClaudeExecutable(processInfo.command);
+    const { direct, legacyMatches } = this.createLocator().matchRunningProcesses(processes);
+
+    const matchedPids = new Set([
+      ...direct.map((d) => d.process.pid),
+      ...legacyMatches.map((m) => m.process.pid),
+    ]);
+
+    const agents: AgentInfo[] = [];
+
+    // Build agents from direct (resume + PID-file) matches
+    for (const match of direct) {
+      const { process: proc, sessionFile } = match;
+      const sessionData = this.parser.readSession(sessionFile.filePath, sessionFile.resolvedCwd);
+      if (sessionData) {
+        agents.push(
+          this.mapper.mapSessionToAgent({
+            session: sessionData,
+            processInfo: proc,
+            sessionFile,
+            liveInfo: {
+              pidStatus: match.pidStatus,
+              waitingFor: match.waitingFor,
+            },
+          }),
+        );
+      } else {
+        matchedPids.delete(proc.pid);
+      }
     }
 
-    private isClaudeExecutable(command: string): boolean {
-        const base = executableBasename(command);
-        return base === 'claude' || base === 'claude.exe';
+    // Build agents from legacy matches
+    for (const match of legacyMatches) {
+      const sessionData = this.parser.readSession(
+        match.session.filePath,
+        match.session.resolvedCwd,
+      );
+      if (sessionData) {
+        agents.push(
+          this.mapper.mapSessionToAgent({
+            session: sessionData,
+            processInfo: match.process,
+            sessionFile: match.session,
+          }),
+        );
+      } else {
+        matchedPids.delete(match.process.pid);
+      }
     }
 
-    async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
-        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
-        const relevant = filterByProcessNames(snapshot, this.processNames);
-        const processes = relevant.filter((process) => this.canHandle(process));
-        if (processes.length === 0) {
-            return [];
-        }
-
-        const { direct, legacyMatches } = this.createLocator().matchRunningProcesses(processes);
-
-        const matchedPids = new Set([
-            ...direct.map((d) => d.process.pid),
-            ...legacyMatches.map((m) => m.process.pid),
-        ]);
-
-        const agents: AgentInfo[] = [];
-
-        // Build agents from direct (resume + PID-file) matches
-        for (const match of direct) {
-            const { process: proc, sessionFile } = match;
-            const sessionData = this.parser.readSession(sessionFile.filePath, sessionFile.resolvedCwd);
-            if (sessionData) {
-                agents.push(this.mapper.mapSessionToAgent({
-                    session: sessionData,
-                    processInfo: proc,
-                    sessionFile,
-                    liveInfo: {
-                        pidStatus: match.pidStatus,
-                        waitingFor: match.waitingFor,
-                    },
-                }));
-            } else {
-                matchedPids.delete(proc.pid);
-            }
-        }
-
-        // Build agents from legacy matches
-        for (const match of legacyMatches) {
-            const sessionData = this.parser.readSession(
-                match.session.filePath,
-                match.session.resolvedCwd,
-            );
-            if (sessionData) {
-                agents.push(this.mapper.mapSessionToAgent({
-                    session: sessionData,
-                    processInfo: match.process,
-                    sessionFile: match.session,
-                }));
-            } else {
-                matchedPids.delete(match.process.pid);
-            }
-        }
-
-        // Any process with no match (direct or legacy) appears as IDLE
-        for (const proc of processes) {
-            if (!matchedPids.has(proc.pid)) {
-                agents.push(this.mapper.mapProcessOnlyAgent(proc));
-            }
-        }
-
-        return agents;
+    // Any process with no match (direct or legacy) appears as IDLE
+    for (const proc of processes) {
+      if (!matchedPids.has(proc.pid)) {
+        agents.push(this.mapper.mapProcessOnlyAgent(proc));
+      }
     }
 
-    private createLocator(): ClaudeSessionLocator {
-        return new ClaudeSessionLocator({
-            projectsDir: this.projectsDir,
-            sessionsDir: this.sessionsDir,
-        });
+    return agents;
+  }
+
+  private createLocator(): ClaudeSessionLocator {
+    return new ClaudeSessionLocator({
+      projectsDir: this.projectsDir,
+      sessionsDir: this.sessionsDir,
+    });
+  }
+
+  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    return this.parser.getConversation(sessionFilePath, options);
+  }
+
+  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+    const filterCwd = opts?.cwd;
+    const candidates = this.createLocator().discoverHistoricalSessionFiles();
+    const summaries: SessionSummary[] = [];
+
+    for (const { filePath, defaultCwd } of candidates) {
+      const session = this.parser.readSession(filePath, defaultCwd);
+      if (!session) continue;
+
+      // Drop sessions whose JSONL had no parseable conversation entries.
+      // readSession is permissive (returns a shell record even when every
+      // line fails to parse); listSessions needs at least one real entry
+      // so we don't surface garbage files.
+      if (!session.lastEntryType) continue;
+
+      const recordedCwd = session.lastCwd || defaultCwd;
+      if (filterCwd !== undefined && recordedCwd !== filterCwd) continue;
+
+      const stat = safeStat(filePath);
+
+      summaries.push({
+        type: "claude",
+        sessionId: session.sessionId,
+        cwd: recordedCwd,
+        firstUserMessage: session.firstUserMessage || "",
+        lastActive: session.lastActive ?? stat?.mtime ?? new Date(),
+        startedAt: session.sessionStart ?? stat?.birthtime ?? stat?.mtime ?? new Date(),
+        sessionFilePath: filePath,
+      });
     }
 
-    getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
-        return this.parser.getConversation(sessionFilePath, options);
-    }
-
-    async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
-        const filterCwd = opts?.cwd;
-        const candidates = this.createLocator().discoverHistoricalSessionFiles();
-        const summaries: SessionSummary[] = [];
-
-        for (const { filePath, defaultCwd } of candidates) {
-            const session = this.parser.readSession(filePath, defaultCwd);
-            if (!session) continue;
-
-            // Drop sessions whose JSONL had no parseable conversation entries.
-            // readSession is permissive (returns a shell record even when every
-            // line fails to parse); listSessions needs at least one real entry
-            // so we don't surface garbage files.
-            if (!session.lastEntryType) continue;
-
-            const recordedCwd = session.lastCwd || defaultCwd;
-            if (filterCwd !== undefined && recordedCwd !== filterCwd) continue;
-
-            const stat = safeStat(filePath);
-
-            summaries.push({
-                type: 'claude',
-                sessionId: session.sessionId,
-                cwd: recordedCwd,
-                firstUserMessage: session.firstUserMessage || '',
-                lastActive: session.lastActive ?? stat?.mtime ?? new Date(),
-                startedAt: session.sessionStart ?? stat?.birthtime ?? stat?.mtime ?? new Date(),
-                sessionFilePath: filePath,
-            });
-        }
-
-        return summaries;
-    }
+    return summaries;
+  }
 }