@ai-devkit/agent-manager 0.33.0 → 0.34.0

package/src/providers/gemini/GeminiSessionParser.ts

@@ -0,0 +1,271 @@
+import * as fs from "fs";
+import type { ConversationMessage, SessionSummary } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { safeReadFile, safeStat } from "../../utils/session.js";
+
+/**
+ * A single Gemini CLI message content part. Mirrors the `{text?: string}`
+ * shape that Gemini writes for user message parts (derived from the
+ * Gemini API `Content.parts[]` schema). Non-text part variants (data,
+ * file, etc.) are preserved via the index signature but ignored by
+ * `resolveContent` since the adapter only surfaces human-readable text.
+ */
+interface GeminiContentPart {
+  text?: string;
+  [key: string]: unknown;
+}
+
+type GeminiMessageContent = string | GeminiContentPart[];
+
+export interface GeminiMessageEntry {
+  id?: string;
+  timestamp?: string;
+  type?: string;
+  /**
+   * Gemini CLI stores two different content shapes depending on the
+   * message origin:
+   * - `type: "user"` messages carry the raw Part[] from userContent.parts
+   *   (e.g. `[{ text: "hello" }]`).
+   * - `type: "gemini"` (assistant) messages carry a pre-joined string
+   *   built from `consolidatedParts.filter(p => p.text).join('').trim()`.
+   * Both forms must be normalized via resolveContent before any string
+   * operation is applied.
+   */
+  content?: GeminiMessageContent;
+  displayContent?: GeminiMessageContent;
+}
+
+export interface GeminiSessionFile {
+  sessionId?: string;
+  projectHash?: string;
+  startTime?: string;
+  lastUpdated?: string;
+  messages?: GeminiMessageEntry[];
+  directories?: string[];
+  kind?: string;
+}
+
+export interface GeminiSession {
+  sessionId: string;
+  projectPath: string;
+  summary: string;
+  sessionStart: Date;
+  lastActive: Date;
+  lastMessageType?: string;
+}
+
+const IDLE_THRESHOLD_MINUTES = 5;
+
+export class GeminiSessionParser {
+  /**
+   * Parse session file content into GeminiSession.
+   * Uses cached content if available, otherwise reads from disk.
+   */
+  parseSession(cachedContent: string | undefined, filePath: string): GeminiSession | null {
+    const content = cachedContent ?? this.readSessionFile(filePath);
+    if (content === null) return null;
+
+    const parsed = this.parseSessionJson(content);
+    if (!parsed?.sessionId) return null;
+
+    const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+    const lastEntry = messages.length > 0 ? messages[messages.length - 1] : undefined;
+    const fileStat = safeStat(filePath);
+
+    const lastActive =
+      this.parseTimestamp(parsed.lastUpdated) ||
+      this.parseTimestamp(lastEntry?.timestamp) ||
+      fileStat?.mtime ||
+      new Date();
+
+    const sessionStart = this.parseTimestamp(parsed.startTime) || lastActive;
+    const projectPath =
+      Array.isArray(parsed.directories) && parsed.directories.length > 0
+        ? parsed.directories[0]
+        : "";
+
+    return {
+      sessionId: parsed.sessionId,
+      projectPath,
+      summary: this.extractSummary(messages),
+      sessionStart,
+      lastActive,
+      lastMessageType: lastEntry?.type,
+    };
+  }
+
+  determineStatus(session: GeminiSession): AgentStatus {
+    const diffMs = Date.now() - session.lastActive.getTime();
+    const diffMinutes = diffMs / 60000;
+
+    if (diffMinutes > IDLE_THRESHOLD_MINUTES) {
+      return AgentStatus.IDLE;
+    }
+
+    if (session.lastMessageType === "gemini" || session.lastMessageType === "assistant") {
+      return AgentStatus.WAITING;
+    }
+
+    return AgentStatus.RUNNING;
+  }
+
+  /**
+   * Read the full conversation from a Gemini CLI session JSON file.
+   *
+   * Gemini sessions store messages in an array with `type` field — typically
+   * 'user' or 'gemini' for visible turns, with tool and system entries mixed in.
+   */
+  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    const verbose = options?.verbose ?? false;
+    const content = safeReadFile(sessionFilePath);
+    if (content === undefined) return [];
+
+    const parsed = this.parseSessionJson(content);
+    if (!Array.isArray(parsed?.messages)) return [];
+
+    const messages: ConversationMessage[] = [];
+    for (const entry of parsed.messages) {
+      const role = this.roleForEntry(entry?.type, verbose);
+      if (!role) continue;
+
+      const text = this.messageText(entry).trim();
+      if (!text) continue;
+
+      messages.push({
+        role,
+        content: text,
+        timestamp: entry.timestamp,
+      });
+    }
+
+    return messages;
+  }
+
+  /**
+   * Read a Gemini session JSON file and produce a {@link SessionSummary}.
+   * Returns null when the file is unreadable, the JSON doesn't parse,
+   * or the body lacks a sessionId.
+   */
+  fileToSessionSummary(filePath: string): SessionSummary | null {
+    const content = safeReadFile(filePath);
+    if (content === undefined) return null;
+
+    const parsed = this.parseSessionJson(content);
+    if (!parsed?.sessionId) return null;
+
+    const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+    const firstUserMessage = this.extractFirstUserMessage(messages);
+    const cwd =
+      Array.isArray(parsed.directories) && parsed.directories.length > 0
+        ? parsed.directories[0]
+        : "";
+
+    const stat = safeStat(filePath);
+    const lastEntryTimestamp = this.parseTimestamp(
+      messages.length > 0 ? messages[messages.length - 1]?.timestamp : undefined,
+    );
+    const lastActive =
+      this.parseTimestamp(parsed.lastUpdated) || lastEntryTimestamp || stat?.mtime || new Date();
+    const startedAt =
+      this.parseTimestamp(parsed.startTime) || stat?.birthtime || stat?.mtime || lastActive;
+
+    return {
+      type: "gemini_cli",
+      sessionId: parsed.sessionId,
+      cwd,
+      firstUserMessage,
+      lastActive,
+      startedAt,
+      sessionFilePath: filePath,
+    };
+  }
+
+  private parseSessionJson(content: string): GeminiSessionFile | null {
+    try {
+      return JSON.parse(content) as GeminiSessionFile;
+    } catch {
+      return null;
+    }
+  }
+
+  private readSessionFile(filePath: string): string | null {
+    try {
+      return fs.readFileSync(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+
+  private roleForEntry(
+    entryType: string | undefined,
+    verbose: boolean,
+  ): ConversationMessage["role"] | null {
+    if (entryType === "user") return "user";
+    if (entryType === "gemini" || entryType === "assistant") return "assistant";
+    if (verbose && entryType) return "system";
+    return null;
+  }
+
+  private extractSummary(messages: GeminiMessageEntry[]): string {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const entry = messages[i];
+      if (entry?.type !== "user") continue;
+      const text = this.messageText(entry).trim();
+      if (text) return this.truncate(text, 120);
+    }
+
+    return "Gemini CLI session active";
+  }
+
+  /**
+   * Normalize an entry's content/displayContent into a plain string.
+   * Prefers displayContent when both are present (matches Gemini CLI's
+   * own rendering priority for the /chat UI).
+   */
+  private messageText(entry: GeminiMessageEntry): string {
+    const displayText = this.resolveContent(entry.displayContent);
+    if (displayText) return displayText;
+    return this.resolveContent(entry.content);
+  }
+
+  /**
+   * Collapse a Gemini message content field into plain text.
+   * Accepts either a pre-joined string (assistant turns) or a Part[]
+   * list (user turns carrying `[{text: "..."}]`). Non-text part
+   * variants (data, file) are dropped since this helper is only used
+   * for summary/conversation rendering.
+   */
+  private resolveContent(content: GeminiMessageContent | undefined): string {
+    if (!content) return "";
+    if (typeof content === "string") return content;
+    if (!Array.isArray(content)) return "";
+
+    const parts: string[] = [];
+    for (const part of content) {
+      if (part && typeof part.text === "string" && part.text) {
+        parts.push(part.text);
+      }
+    }
+    return parts.join("");
+  }
+
+  private extractFirstUserMessage(messages: GeminiMessageEntry[]): string {
+    for (const entry of messages) {
+      if (entry?.type !== "user") continue;
+      const text = this.messageText(entry).trim();
+      if (text) return text;
+    }
+    return "";
+  }
+
+  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/opencode/OpenCodeAdapter.ts

@@ -0,0 +1,112 @@
+/**
+ * OpenCode Adapter
+ *
+ * Detects running OpenCode agents by:
+ * 1. Filtering OpenCode processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
+ * 3. Querying OpenCode's SQLite DB (~/.local/share/opencode/opencode.db) to
+ *    find the session matching each process's CWD and read status from message.time.completed
+ *
+ * sessionFilePath encodes "<dbPath>::<sessionId>" so getConversation() can open the right
+ * DB row without extending the AgentAdapter interface.
+ */
+
+import type {
+  AgentAdapter,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  SessionSummary,
+  ListSessionsOptions,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import {
+  captureProcessSnapshot,
+  executableBasename,
+  filterByProcessNames,
+} from "../../utils/process.js";
+import { OpenCodeAgentMapper } from "./OpenCodeAgentMapper.js";
+import { OpenCodeSessionLocator } from "./OpenCodeSessionLocator.js";
+import { OpenCodeSessionParser } from "./OpenCodeSessionParser.js";
+
+const SESSION_REF_SEP = "::";
+
+function decodeSessionRef(ref: string): { sessionId: string } | null {
+  const idx = ref.lastIndexOf(SESSION_REF_SEP);
+  if (idx === -1) return null;
+  return { sessionId: ref.slice(idx + SESSION_REF_SEP.length) };
+}
+
+export class OpenCodeAdapter implements AgentAdapter {
+  readonly type = "opencode" as const;
+  readonly processNames = ["opencode"] as const;
+
+  private readonly parser: OpenCodeSessionParser;
+  private readonly locator: OpenCodeSessionLocator;
+  private readonly mapper: OpenCodeAgentMapper;
+  private readonly cleanup = (): void => this.close();
+
+  constructor(dbPath?: string) {
+    this.parser = new OpenCodeSessionParser();
+    this.locator = new OpenCodeSessionLocator(dbPath, this.parser);
+    this.mapper = new OpenCodeAgentMapper(this.locator.dbFilePath);
+    process.once("exit", this.cleanup);
+    process.once("SIGINT", this.cleanup);
+    process.once("SIGTERM", this.cleanup);
+  }
+
+  close(): void {
+    process.off("exit", this.cleanup);
+    process.off("SIGINT", this.cleanup);
+    process.off("SIGTERM", this.cleanup);
+    this.locator.close();
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    const base = executableBasename(processInfo.command);
+    return base === "opencode" || base === "opencode.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 [];
+
+    const db = this.locator.openDb();
+    if (!db) return processes.map((process) => this.mapper.mapProcessOnlyAgent(process));
+
+    const agents: AgentInfo[] = [];
+    for (const proc of processes) {
+      if (!proc.cwd) {
+        agents.push(this.mapper.mapProcessOnlyAgent(proc));
+        continue;
+      }
+
+      const session = this.locator.findSessionForDirectory(db, proc.cwd);
+      if (!session) {
+        agents.push(this.mapper.mapProcessOnlyAgent(proc));
+        continue;
+      }
+
+      const stats = this.parser.getSessionStats(db, session.sessionId);
+      agents.push(this.mapper.mapSessionToAgent(session, stats, proc));
+    }
+
+    return agents;
+  }
+
+  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    const ref = decodeSessionRef(sessionFilePath);
+    if (!ref) return [];
+
+    const db = this.locator.openDb();
+    if (!db) return [];
+
+    return this.parser.getConversation(db, ref.sessionId, options);
+  }
+
+  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+    return this.locator.listSessions(opts);
+  }
+}

package/src/providers/opencode/OpenCodeAgentMapper.ts

@@ -0,0 +1,61 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import type { OpenCodeSession } from "./OpenCodeSessionLocator.js";
+import type { OpenCodeSessionStats } from "./OpenCodeSessionParser.js";
+
+const SESSION_REF_SEP = "::";
+const IDLE_THRESHOLD_MINUTES = 5;
+
+function encodeSessionRef(dbPath: string, sessionId: string): string {
+  return `${dbPath}${SESSION_REF_SEP}${sessionId}`;
+}
+
+export class OpenCodeAgentMapper {
+  constructor(private readonly dbPath: string) {}
+
+  mapSessionToAgent(
+    session: OpenCodeSession,
+    stats: OpenCodeSessionStats,
+    proc: ProcessInfo,
+  ): AgentInfo {
+    const lastActive =
+      stats.lastTimeUpdated > 0 ? new Date(stats.lastTimeUpdated) : new Date(session.timeCreated);
+
+    return {
+      name: generateAgentName(session.directory || proc.cwd || "", proc.pid),
+      type: "opencode",
+      status: this.determineStatus(stats, lastActive),
+      summary: stats.summary || "OpenCode session active",
+      pid: proc.pid,
+      projectPath: session.directory || proc.cwd || "",
+      sessionId: session.sessionId,
+      lastActive,
+      sessionFilePath: encodeSessionRef(this.dbPath, session.sessionId),
+    };
+  }
+
+  mapProcessOnlyAgent(proc: ProcessInfo): AgentInfo {
+    return {
+      name: generateAgentName(proc.cwd || "", proc.pid),
+      type: "opencode",
+      status: AgentStatus.RUNNING,
+      summary: "OpenCode process running",
+      pid: proc.pid,
+      projectPath: proc.cwd || "",
+      sessionId: `pid-${proc.pid}`,
+      lastActive: new Date(),
+    };
+  }
+
+  private determineStatus(stats: OpenCodeSessionStats, lastActive: Date): AgentStatus {
+    const ageMin = (Date.now() - lastActive.getTime()) / 60000;
+    if (ageMin > IDLE_THRESHOLD_MINUTES) return AgentStatus.IDLE;
+
+    if (stats.lastRole === "assistant" && !stats.lastAssistantCompleted) {
+      return AgentStatus.RUNNING;
+    }
+    if (stats.lastRole === "assistant") return AgentStatus.WAITING;
+    return AgentStatus.RUNNING;
+  }
+}

package/src/providers/opencode/OpenCodeSessionLocator.ts

@@ -0,0 +1,123 @@
+import * as fs from "fs";
+import * as path from "path";
+import Database from "better-sqlite3";
+import type { ListSessionsOptions, SessionSummary } from "../../adapters/AgentAdapter.js";
+import { OpenCodeSessionParser } from "./OpenCodeSessionParser.js";
+
+const SESSION_REF_SEP = "::";
+
+function encodeOpenCodeSessionRef(dbPath: string, sessionId: string): string {
+  return `${dbPath}${SESSION_REF_SEP}${sessionId}`;
+}
+
+export interface OpenCodeSession {
+  sessionId: string;
+  directory: string;
+  timeCreated: number;
+}
+
+export class OpenCodeSessionLocator {
+  private readonly dbPath: string;
+  private db: Database.Database | null = null;
+
+  constructor(
+    dbPath = OpenCodeSessionLocator.resolveDbPath(),
+    private readonly parser: OpenCodeSessionParser = new OpenCodeSessionParser(),
+  ) {
+    this.dbPath = dbPath;
+  }
+
+  static resolveDbPath(): string {
+    const xdg = process.env.XDG_DATA_HOME;
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    const base = xdg || path.join(home, ".local", "share");
+    return path.join(base, "opencode", "opencode.db");
+  }
+
+  openDb(): Database.Database | null {
+    if (this.db) return this.db;
+    if (!fs.existsSync(this.dbPath)) return null;
+
+    try {
+      this.db = new Database(this.dbPath, { readonly: true });
+      return this.db;
+    } catch {
+      return null;
+    }
+  }
+
+  close(): void {
+    if (this.db) {
+      try {
+        this.db.close();
+      } catch {
+        /* ignore */
+      }
+      this.db = null;
+    }
+  }
+
+  findSessionForDirectory(db: Database.Database, directory: string): OpenCodeSession | null {
+    try {
+      const row = db
+        .prepare<[string], { id: string; directory: string; time_created: number }>(`
+                SELECT id, directory, time_created
+                FROM session
+                WHERE directory = ?
+                ORDER BY time_created DESC
+                LIMIT 1
+            `)
+        .get(directory);
+
+      if (!row) return null;
+      return { sessionId: row.id, directory: row.directory, timeCreated: row.time_created };
+    } catch {
+      return null;
+    }
+  }
+
+  listSessions(opts?: ListSessionsOptions): SessionSummary[] {
+    const db = this.openDb();
+    if (!db) return [];
+
+    try {
+      const rows = db
+        .prepare<[], { id: string; directory: string; timeCreated: number }>(`
+                SELECT id, directory, time_created AS timeCreated
+                FROM session
+                ORDER BY time_created DESC
+            `)
+        .all();
+
+      const summaries: SessionSummary[] = [];
+
+      for (const row of rows) {
+        if (opts?.cwd !== undefined && row.directory !== opts.cwd) continue;
+
+        const stats = this.parser.getSessionStats(db, row.id);
+        const lastActive =
+          stats.lastTimeUpdated > 0 ? new Date(stats.lastTimeUpdated) : new Date(row.timeCreated);
+        const startedAt = new Date(row.timeCreated);
+
+        summaries.push({
+          type: "opencode",
+          sessionId: row.id,
+          cwd: row.directory,
+          firstUserMessage: stats.summary,
+          lastActive,
+          startedAt,
+          sessionFilePath: encodeOpenCodeSessionRef(this.dbPath, row.id),
+        });
+      }
+
+      return summaries;
+    } catch {
+      this.close();
+      return [];
+    }
+  }
+
+  get dbFilePath(): string {
+    return this.dbPath;
+  }
+}