@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/providers/copilot/CopilotSessionParser.ts

@@ -1,289 +0,0 @@
-import * as path from "path";
-import type { ConversationMessage } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
-import { safeReadFile, safeStat } from "../../utils/session.js";
-
-interface CopilotEventEntry {
-  type?: string;
-  data?: {
-    sessionId?: string;
-    startTime?: string;
-    context?: {
-      cwd?: string;
-      gitRoot?: string;
-      branch?: string;
-    };
-    content?: string;
-    transformedContent?: string;
-    message?: string;
-    text?: string;
-    result?: {
-      content?: string;
-      detailedContent?: string;
-    };
-    output?: string;
-  };
-  timestamp?: string;
-}
-
-interface CopilotWorkspace {
-  id?: string;
-  cwd?: string;
-  name?: string;
-  createdAt?: Date;
-  updatedAt?: Date;
-}
-
-export interface CopilotSession {
-  sessionId: string;
-  projectPath: string;
-  summary: string;
-  sessionStart: Date;
-  lastActive: Date;
-  lastEventType?: string;
-  firstUserMessage: string;
-  eventsFilePath: string;
-}
-
-interface CopilotEventSummary {
-  sessionId: string;
-  projectPath: string;
-  sessionStart: Date;
-  lastActive: Date;
-  firstUserMessage: string;
-  lastText: string;
-  lastEventType?: string;
-}
-
-const IDLE_THRESHOLD_MINUTES = 5;
-const VERBOSE_SYSTEM_EVENTS = new Set([
-  "system.message",
-  "session.info",
-  "session.warning",
-  "tool.execution_start",
-  "tool.execution_complete",
-  "function",
-  "abort",
-]);
-const WAITING_EVENTS = new Set([
-  "assistant.message",
-  "assistant.turn_end",
-  "session.shutdown",
-  "abort",
-]);
-
-export class CopilotSessionParser {
-  readSessionDir(sessionDir: string, fallbackSessionId: string): CopilotSession | null {
-    const eventsFilePath = path.join(sessionDir, "events.jsonl");
-    const workspace = this.readWorkspaceMetadata(path.join(sessionDir, "workspace.yaml"));
-    const entries = this.readEventEntries(eventsFilePath);
-    if (entries.length === 0 && !this.hasWorkspaceMetadata(workspace)) {
-      return null;
-    }
-
-    const fileStat = safeStat(eventsFilePath);
-    const sessionStart = workspace.createdAt || fileStat?.birthtime || new Date();
-    const eventSummary = this.buildSessionFromEntries(entries, {
-      sessionId: workspace.id || fallbackSessionId,
-      projectPath: workspace.cwd || "",
-      sessionStart,
-      lastActive: workspace.updatedAt || fileStat?.mtime || sessionStart,
-      firstUserMessage: "",
-      lastText: "",
-    });
-
-    const summary =
-      eventSummary.firstUserMessage ||
-      eventSummary.lastText ||
-      workspace.name ||
-      "Copilot session active";
-
-    return {
-      sessionId: eventSummary.sessionId,
-      projectPath: eventSummary.projectPath,
-      summary: this.truncate(summary, 120),
-      sessionStart: eventSummary.sessionStart,
-      lastActive: eventSummary.lastActive,
-      lastEventType: eventSummary.lastEventType,
-      firstUserMessage: eventSummary.firstUserMessage,
-      eventsFilePath,
-    };
-  }
-
-  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
-    const verbose = options?.verbose ?? false;
-    const content = safeReadFile(sessionFilePath);
-    if (content === undefined) return [];
-
-    const messages: ConversationMessage[] = [];
-
-    for (const entry of this.parseEventLines(content)) {
-      const role = this.roleForEvent(entry.type, verbose);
-      if (!role) continue;
-
-      const text = this.extractEventText(entry, verbose);
-      if (!text) continue;
-
-      messages.push({
-        role,
-        content: text,
-        timestamp: entry.timestamp,
-      });
-    }
-
-    return messages;
-  }
-
-  determineStatus(session: CopilotSession): AgentStatus {
-    const diffMs = Date.now() - session.lastActive.getTime();
-    const diffMinutes = diffMs / 60000;
-    if (diffMinutes > IDLE_THRESHOLD_MINUTES) {
-      return AgentStatus.IDLE;
-    }
-
-    if (session.lastEventType !== undefined && WAITING_EVENTS.has(session.lastEventType)) {
-      return AgentStatus.WAITING;
-    }
-
-    return AgentStatus.RUNNING;
-  }
-
-  private readEventEntries(eventsFilePath: string): CopilotEventEntry[] {
-    const content = safeReadFile(eventsFilePath);
-    return content === undefined ? [] : this.parseEventLines(content);
-  }
-
-  private buildSessionFromEntries(
-    entries: CopilotEventEntry[],
-    initial: CopilotEventSummary,
-  ): CopilotEventSummary {
-    const summary = { ...initial };
-    for (const entry of entries) {
-      const timestamp = this.parseTimestamp(entry.timestamp);
-      if (timestamp) {
-        summary.lastActive = timestamp;
-      }
-      if (entry.type) {
-        summary.lastEventType = entry.type;
-      }
-
-      if (entry.type === "session.start") {
-        summary.sessionId = entry.data?.sessionId || summary.sessionId;
-        summary.projectPath = entry.data?.context?.cwd || summary.projectPath;
-        summary.sessionStart =
-          this.parseTimestamp(entry.data?.startTime) || timestamp || summary.sessionStart;
-        continue;
-      }
-
-      const text = this.extractEventText(entry, false);
-      if (!text) continue;
-
-      if (!summary.firstUserMessage && entry.type === "user.message") {
-        summary.firstUserMessage = text;
-      }
-
-      if (entry.type === "user.message" || entry.type === "assistant.message") {
-        summary.lastText = text;
-      }
-    }
-
-    return summary;
-  }
-
-  private hasWorkspaceMetadata(workspace: CopilotWorkspace): boolean {
-    return Boolean(
-      workspace.id || workspace.cwd || workspace.name || workspace.createdAt || workspace.updatedAt,
-    );
-  }
-
-  private readWorkspaceMetadata(filePath: string): CopilotWorkspace {
-    const content = safeReadFile(filePath);
-    if (content === undefined) return {};
-
-    const values = new Map<string, string>();
-    for (const rawLine of content.split("\n")) {
-      const line = rawLine.trim();
-      if (!line || line.startsWith("#")) continue;
-
-      const idx = line.indexOf(":");
-      if (idx === -1) continue;
-
-      const key = line.slice(0, idx).trim();
-      const value = this.stripYamlScalar(line.slice(idx + 1).trim());
-      values.set(key, value);
-    }
-
-    return {
-      id: values.get("id"),
-      cwd: values.get("cwd"),
-      name: values.get("name"),
-      createdAt: this.parseTimestamp(values.get("created_at")) || undefined,
-      updatedAt: this.parseTimestamp(values.get("updated_at")) || undefined,
-    };
-  }
-
-  private stripYamlScalar(value: string): string {
-    if (
-      (value.startsWith('"') && value.endsWith('"')) ||
-      (value.startsWith("'") && value.endsWith("'"))
-    ) {
-      return value.slice(1, -1);
-    }
-    return value;
-  }
-
-  private parseEventLines(content: string): CopilotEventEntry[] {
-    const entries: CopilotEventEntry[] = [];
-    for (const line of content.trim().split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-
-      try {
-        entries.push(JSON.parse(trimmed) as CopilotEventEntry);
-      } catch {
-        continue;
-      }
-    }
-    return entries;
-  }
-
-  private roleForEvent(
-    type: string | undefined,
-    verbose: boolean,
-  ): ConversationMessage["role"] | null {
-    if (type === "user.message") return "user";
-    if (type === "assistant.message") return "assistant";
-    if (verbose && type !== undefined && VERBOSE_SYSTEM_EVENTS.has(type)) {
-      return "system";
-    }
-    return null;
-  }
-
-  private extractEventText(entry: CopilotEventEntry, verbose: boolean): string {
-    const data = entry.data;
-    if (!data) return "";
-
-    const raw =
-      data.content ||
-      data.message ||
-      data.text ||
-      data.result?.content ||
-      data.result?.detailedContent ||
-      (verbose ? data.output : "") ||
-      "";
-
-    if (typeof raw !== "string") return "";
-    return raw.trim();
-  }
-
-  private parseTimestamp(value?: string): Date | null {
-    if (!value) return null;
-    const timestamp = new Date(value);
-    return Number.isNaN(timestamp.getTime()) ? null : timestamp;
-  }
-
-  private truncate(value: string, maxLength: number): string {
-    if (value.length <= maxLength) return value;
-    return `${value.slice(0, maxLength - 3)}...`;
-  }
-}

package/src/providers/gemini/GeminiAgentMapper.ts

@@ -1,36 +0,0 @@
-import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
-import { generateAgentName } from "../../utils/matching.js";
-import { GeminiSessionParser, type GeminiSession } from "./GeminiSessionParser.js";
-
-export class GeminiAgentMapper {
-  constructor(private readonly parser: GeminiSessionParser = new GeminiSessionParser()) {}
-
-  mapSessionToAgent(session: GeminiSession, processInfo: ProcessInfo, filePath: string): AgentInfo {
-    const projectPath = session.projectPath || processInfo.cwd || "";
-    return {
-      name: generateAgentName(projectPath, processInfo.pid),
-      type: "gemini_cli",
-      status: this.parser.determineStatus(session),
-      summary: session.summary || "Gemini CLI session active",
-      pid: processInfo.pid,
-      projectPath,
-      sessionId: session.sessionId,
-      lastActive: session.lastActive,
-      sessionFilePath: filePath,
-    };
-  }
-
-  mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
-    return {
-      name: generateAgentName(processInfo.cwd || "", processInfo.pid),
-      type: "gemini_cli",
-      status: AgentStatus.RUNNING,
-      summary: "Gemini CLI process running",
-      pid: processInfo.pid,
-      projectPath: processInfo.cwd || "",
-      sessionId: `pid-${processInfo.pid}`,
-      lastActive: new Date(),
-    };
-  }
-}

package/src/providers/gemini/GeminiCliAdapter.ts

@@ -1,274 +0,0 @@
-/**
- * Gemini CLI Adapter
- *
- * Detects running Gemini CLI agents by:
- * 1. Filtering Gemini Node processes from a shared asynchronous process snapshot
- * 2. Using snapshot CWD and start-time enrichment
- * 3. Discovering session files from ~/.gemini/tmp/<shortId>/chats/session-*.json
- * 4. Matching sessions to processes via shared matchProcessesToSessions()
- *    using sha256(cwd) === session.projectHash as the resolvedCwd source
- * 5. Extracting summary from the most recent user message in the session JSON
- */
-
-import type {
-  AgentAdapter,
-  AgentInfo,
-  ProcessInfo,
-  ConversationMessage,
-  SessionSummary,
-  ListSessionsOptions,
-  AgentDetectionContext,
-} from "../../adapters/AgentAdapter.js";
-import {
-  captureProcessSnapshot,
-  executableBasename,
-  filterByProcessNames,
-  findWrapperProcess,
-  findWrapperProcessPids,
-} from "../../utils/process.js";
-import { matchProcessesToSessions } from "../../utils/matching.js";
-import { AgentRegistry, type RegistryEntry } from "../../utils/AgentRegistry.js";
-import { GeminiAgentMapper } from "./GeminiAgentMapper.js";
-import { GeminiSessionLocator, type GeminiSessionDiscovery } from "./GeminiSessionLocator.js";
-import { GeminiSessionParser } from "./GeminiSessionParser.js";
-
-export interface GeminiCliAdapterOptions {
-  geminiTmpDir?: string;
-}
-
-export class GeminiCliAdapter implements AgentAdapter {
-  readonly type = "gemini_cli" as const;
-  readonly processNames = ["node"] as const;
-
-  private readonly registry: AgentRegistry;
-  private readonly parser: GeminiSessionParser;
-  private readonly mapper: GeminiAgentMapper;
-  private readonly locator: GeminiSessionLocator;
-
-  constructor(
-    registry: AgentRegistry = AgentRegistry.default(),
-    options: GeminiCliAdapterOptions = {},
-  ) {
-    this.registry = registry;
-    this.parser = new GeminiSessionParser();
-    this.mapper = new GeminiAgentMapper(this.parser);
-    this.locator = new GeminiSessionLocator(options);
-  }
-
-  canHandle(processInfo: ProcessInfo): boolean {
-    return this.isGeminiExecutable(processInfo.command);
-  }
-
-  /**
-   * Detect running Gemini CLI agents.
-   *
-   * Gemini CLI ships as a Node script (`bundle/gemini.js` with shebang
-   * `#!/usr/bin/env node`) — unlike Claude Code (native binary per
-   * platform) or Codex CLI (Node wrapper that execs a native Rust
-   * binary). The primary running process is therefore the Node runtime
-   * itself, and `ps aux` lists it as `node /path/to/gemini ...` with
-   * argv[0] = `node`. We scan the Node process pool via the shared
-   * snapshot and keep only those whose command line references the gemini
-   * executable or script via isGeminiExecutable().
-   */
-  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
-    const processes = await this.getGeminiProcesses(context);
-    if (processes.length === 0) return [];
-
-    const wrapperPids = findWrapperProcessPids(processes);
-    const { cachedAgents, remaining } = this.tryRegistryCache(processes, wrapperPids);
-    if (remaining.length === 0) return this.deduplicateSessionAgents(cachedAgents);
-
-    const candidateProcesses = remaining.filter((proc) => !wrapperPids.has(proc.pid));
-    const registryEntriesByPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
-    const discovery = this.locator.discoverSessions(candidateProcesses);
-
-    const agents =
-      discovery.sessions.length === 0
-        ? this.mapProcessOnlyAgents(candidateProcesses, processes, registryEntriesByPid)
-        : this.mapSessionDiscovery(discovery, candidateProcesses, processes, registryEntriesByPid);
-
-    return this.deduplicateSessionAgents([...cachedAgents, ...agents]);
-  }
-
-  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
-    return this.parser.getConversation(sessionFilePath, options);
-  }
-
-  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
-    const summaries: SessionSummary[] = [];
-
-    for (const filePath of this.locator.discoverHistoricalSessionFiles()) {
-      const summary = this.parser.fileToSessionSummary(filePath);
-      if (!summary) continue;
-      if (opts?.cwd !== undefined && summary.cwd !== opts.cwd) continue;
-      summaries.push(summary);
-    }
-
-    return summaries;
-  }
-
-  async findSessionsById(sessionId: string): Promise<SessionSummary[]> {
-    for (const filePath of this.locator.discoverHistoricalSessionFiles()) {
-      const summary = this.parser.fileToSessionSummary(filePath);
-      if (summary?.sessionId === sessionId) return [summary];
-    }
-    return [];
-  }
-
-  private async getGeminiProcesses(context?: AgentDetectionContext): Promise<ProcessInfo[]> {
-    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
-    const relevant = filterByProcessNames(snapshot, this.processNames);
-    return relevant.filter((process) => this.canHandle(process));
-  }
-
-  private mapSessionDiscovery(
-    discovery: GeminiSessionDiscovery,
-    candidateProcesses: ProcessInfo[],
-    allProcesses: ProcessInfo[],
-    registryEntriesByPid: Map<number, RegistryEntry>,
-  ): AgentInfo[] {
-    const matches = matchProcessesToSessions(candidateProcesses, discovery.sessions);
-    const matchedPids = new Set(matches.map((m) => m.process.pid));
-    const matchedProcesses: ProcessInfo[] = [];
-    const agents: AgentInfo[] = [];
-
-    for (const match of matches) {
-      const cachedContent = discovery.contentCache.get(match.session.filePath);
-      const sessionData = this.parser.parseSession(cachedContent, match.session.filePath);
-      if (!sessionData) {
-        matchedPids.delete(match.process.pid);
-        continue;
-      }
-
-      const agent = this.mapper.mapSessionToAgent(
-        sessionData,
-        match.process,
-        match.session.filePath,
-      );
-      this.applyWrapperRegistryName(agent, match.process, allProcesses, registryEntriesByPid);
-      agents.push(agent);
-      matchedProcesses.push(match.process);
-    }
-
-    const matchedWrapperPids = findWrapperProcessPids(candidateProcesses, matchedProcesses);
-    const unmatchedProcesses = candidateProcesses.filter(
-      (process) => !matchedPids.has(process.pid) && !matchedWrapperPids.has(process.pid),
-    );
-
-    agents.push(
-      ...this.mapProcessOnlyAgents(unmatchedProcesses, allProcesses, registryEntriesByPid),
-    );
-    return agents;
-  }
-
-  private mapProcessOnlyAgents(
-    processes: ProcessInfo[],
-    allProcesses: ProcessInfo[],
-    registryEntriesByPid: Map<number, RegistryEntry>,
-  ): AgentInfo[] {
-    return processes.map((processInfo) => {
-      const agent = this.mapper.mapProcessOnlyAgent(processInfo);
-      this.applyWrapperRegistryName(agent, processInfo, allProcesses, registryEntriesByPid);
-      return agent;
-    });
-  }
-
-  private applyWrapperRegistryName(
-    agent: AgentInfo,
-    processInfo: ProcessInfo,
-    processes: ProcessInfo[],
-    registryEntriesByPid: Map<number, RegistryEntry>,
-  ): void {
-    const wrapper = findWrapperProcess(processes, processInfo);
-    const wrapperEntry = wrapper ? registryEntriesByPid.get(wrapper.pid) : undefined;
-    if (wrapperEntry?.type === this.type) {
-      agent.name = wrapperEntry.name;
-    }
-  }
-
-  private deduplicateSessionAgents(agents: AgentInfo[]): AgentInfo[] {
-    const bySession = new Map<string, AgentInfo>();
-    const result: AgentInfo[] = [];
-
-    for (const agent of agents) {
-      const sessionKey = this.sessionDeduplicationKey(agent);
-      if (!sessionKey) {
-        result.push(agent);
-        continue;
-      }
-
-      const existing = bySession.get(sessionKey);
-      if (!existing) {
-        bySession.set(sessionKey, agent);
-        result.push(agent);
-        continue;
-      }
-
-      if (agent.pid > existing.pid) {
-        bySession.set(sessionKey, agent);
-        const index = result.indexOf(existing);
-        if (index >= 0) result[index] = agent;
-      }
-    }
-
-    return result;
-  }
-
-  private sessionDeduplicationKey(agent: AgentInfo): string | null {
-    if (agent.sessionFilePath) return `file:${agent.sessionFilePath}`;
-    if (agent.sessionId && !agent.sessionId.startsWith("pid-")) {
-      return `session:${agent.sessionId}`;
-    }
-    return null;
-  }
-
-  private tryRegistryCache(
-    processes: ProcessInfo[],
-    wrapperPids: Set<number>,
-  ): {
-    cachedAgents: AgentInfo[];
-    remaining: ProcessInfo[];
-  } {
-    const cachedAgents: AgentInfo[] = [];
-    const remaining: ProcessInfo[] = [];
-    const byPid = new Map(this.registry.list().map((e) => [e.pid, e]));
-
-    for (const proc of processes) {
-      const entry = byPid.get(proc.pid);
-      if (
-        wrapperPids.has(proc.pid) ||
-        !entry ||
-        entry.type !== this.type ||
-        !entry.sessionFilePath
-      ) {
-        remaining.push(proc);
-        continue;
-      }
-
-      const sessionData = this.parser.parseSession(undefined, entry.sessionFilePath);
-      if (!sessionData) {
-        remaining.push(proc);
-        continue;
-      }
-
-      cachedAgents.push(this.mapper.mapSessionToAgent(sessionData, proc, entry.sessionFilePath));
-    }
-
-    return { cachedAgents, remaining };
-  }
-
-  private isGeminiExecutable(command: string): boolean {
-    // Accept any token in the command line whose basename matches a
-    // known gemini entrypoint. This is intentionally broader than the
-    // other adapters' argv[0]-only check because the Node-script
-    // distribution puts the real gemini path in argv[1..], not argv[0].
-    for (const token of command.trim().split(/\s+/)) {
-      const base = executableBasename(token);
-      if (base === "gemini" || base === "gemini.exe" || base === "gemini.js") {
-        return true;
-      }
-    }
-    return false;
-  }
-}