@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/providers/opencode/OpenCodeSessionParser.ts

@@ -1,145 +0,0 @@
-import type { ConversationMessage } from "../../adapters/AgentAdapter.js";
-import type Database from "better-sqlite3";
-
-export interface OpenCodeSessionStats {
-  lastRole: string | null;
-  lastTimeUpdated: number;
-  /** OpenCode writes `time.completed` on the assistant message only when the turn finishes. */
-  lastAssistantCompleted: boolean;
-  lastAssistantErrored: boolean;
-  summary: string;
-}
-
-interface OpenCodePartData {
-  type?: string;
-  text?: string;
-  reasoning?: string;
-  tool?: string;
-}
-
-const EMPTY_STATS: OpenCodeSessionStats = {
-  lastRole: null,
-  lastTimeUpdated: 0,
-  lastAssistantCompleted: false,
-  lastAssistantErrored: false,
-  summary: "",
-};
-
-export class OpenCodeSessionParser {
-  getConversation(
-    db: Database.Database,
-    sessionId: string,
-    options?: { verbose?: boolean },
-  ): ConversationMessage[] {
-    const verbose = options?.verbose ?? false;
-
-    try {
-      const rows = db
-        .prepare<[string], { role: string; partData: string; timeCreated: number }>(`
-                SELECT json_extract(m.data, '$.role') AS role,
-                       p.data AS partData,
-                       p.time_created AS timeCreated
-                FROM part p
-                JOIN message m ON p.message_id = m.id
-                WHERE p.session_id = ?
-                ORDER BY p.time_created ASC
-            `)
-        .all(sessionId);
-
-      const messages: ConversationMessage[] = [];
-
-      for (const row of rows) {
-        const partData = this.parsePartData(row.partData);
-        if (!partData) continue;
-
-        const role = row.role === "user" ? "user" : "assistant";
-
-        if (partData.type === "text" && partData.text) {
-          messages.push({ role, content: partData.text });
-        } else if (partData.type === "reasoning" && verbose) {
-          const text = partData.reasoning || partData.text || "";
-          if (text) messages.push({ role: "assistant", content: `[thinking] ${text}` });
-        } else if (partData.type === "tool" && verbose) {
-          const toolName = partData.tool || "tool";
-          messages.push({ role: "assistant", content: `[tool: ${toolName}]` });
-        }
-      }
-
-      return messages;
-    } catch {
-      return [];
-    }
-  }
-
-  getSessionStats(db: Database.Database, sessionId: string): OpenCodeSessionStats {
-    try {
-      // Order by time_created — time_updated can lag when OpenCode appends
-      // metadata (e.g. summary diffs) to user messages after a turn finishes.
-      const last = db
-        .prepare<[string], { role: string; timeUpdated: number }>(`
-                SELECT json_extract(data, '$.role') AS role,
-                       time_updated AS timeUpdated
-                FROM message
-                WHERE session_id = ?
-                ORDER BY time_created DESC
-                LIMIT 1
-            `)
-        .get(sessionId);
-
-      const heartbeat = db
-        .prepare<[string], { maxUpdated: number }>(`
-                SELECT MAX(time_updated) AS maxUpdated FROM message WHERE session_id = ?
-            `)
-        .get(sessionId);
-
-      const lastAssistant = db
-        .prepare<
-          [string],
-          {
-            completed: number | null;
-            errored: number | null;
-          }
-        >(`
-                SELECT json_extract(data, '$.time.completed') AS completed,
-                       json_extract(data, '$.time.error') AS errored
-                FROM message
-                WHERE session_id = ? AND json_extract(data, '$.role') = 'assistant'
-                ORDER BY time_created DESC
-                LIMIT 1
-            `)
-        .get(sessionId);
-
-      const first = db
-        .prepare<[string], { text: string }>(`
-                SELECT json_extract(p.data, '$.text') AS text
-                FROM part p
-                JOIN message m ON p.message_id = m.id
-                WHERE p.session_id = ?
-                  AND json_extract(m.data, '$.role') = 'user'
-                  AND json_extract(p.data, '$.type') = 'text'
-                  AND json_extract(p.data, '$.text') IS NOT NULL
-                ORDER BY p.time_created ASC
-                LIMIT 1
-            `)
-        .get(sessionId);
-
-      return {
-        lastRole: last?.role ?? null,
-        lastTimeUpdated: heartbeat?.maxUpdated ?? last?.timeUpdated ?? 0,
-        lastAssistantCompleted: lastAssistant?.completed != null,
-        lastAssistantErrored: lastAssistant?.errored != null,
-        summary: first?.text?.trim() ?? "",
-      };
-    } catch {
-      return EMPTY_STATS;
-    }
-  }
-
-  private parsePartData(partData: string): OpenCodePartData | null {
-    try {
-      return JSON.parse(partData) as OpenCodePartData;
-    } catch {
-      return null;
-    }
-  }
-}

package/src/providers/pi/PiAdapter.ts

@@ -1,195 +0,0 @@
-import * as fs from "fs";
-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 { AgentRegistry } from "../../utils/AgentRegistry.js";
-import { PiAgentMapper } from "./PiAgentMapper.js";
-import { PiSessionLocator } from "./PiSessionLocator.js";
-import { PiSessionParser } from "./PiSessionParser.js";
-import { PiSessionTracker } from "./PiSessionTracker.js";
-
-interface MappedAgentResult {
-  agents: AgentInfo[];
-  fallback: ProcessInfo[];
-}
-
-interface SessionFileMatch {
-  process: ProcessInfo;
-  filePath: string;
-}
-
-export class PiAdapter implements AgentAdapter {
-  readonly type = "pi" as const;
-  readonly processNames = ["pi", "node"] as const;
-
-  private readonly piSessionsDir: string;
-  private readonly trackerPath: string;
-  private readonly registry: AgentRegistry;
-  private readonly parser: PiSessionParser;
-  private readonly mapper: PiAgentMapper;
-
-  constructor(registry: AgentRegistry = AgentRegistry.default()) {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    const piAgentDir = path.join(homeDir, ".pi", "agent");
-    this.piSessionsDir = path.join(piAgentDir, "sessions");
-    this.trackerPath = path.join(piAgentDir, "sessions.json");
-    this.registry = registry;
-    this.parser = new PiSessionParser();
-    this.mapper = new PiAgentMapper(this.parser);
-  }
-
-  canHandle(processInfo: ProcessInfo): boolean {
-    return this.isPiExecutable(processInfo.command);
-  }
-
-  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
-    const processes = await this.getPiProcesses(context);
-    if (processes.length === 0) return [];
-
-    const cacheResult = this.mapRegistryCache(processes);
-    const trackerResult = this.mapTrackerMatches(cacheResult.fallback);
-    const locatorResult = this.createLocator().matchRunningProcesses(trackerResult.fallback);
-    const legacyResult = this.mapLegacyMatches(locatorResult.legacyMatches);
-    const unmatchedProcesses = this.findUnmatchedProcesses(
-      locatorResult.fallback,
-      legacyResult.agents,
-    );
-
-    return [
-      ...cacheResult.agents,
-      ...trackerResult.agents,
-      ...legacyResult.agents,
-      ...unmatchedProcesses.map((processInfo) => this.mapper.mapProcessOnlyAgent(processInfo)),
-    ];
-  }
-
-  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.createLocator().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[]> {
-    const summaries: SessionSummary[] = [];
-    const filePaths = this.createLocator().findHistoricalSessionFilesById(sessionId);
-    for (const filePath of filePaths) {
-      const summary = this.parser.fileToSessionSummary(filePath);
-      if (summary?.sessionId === sessionId) summaries.push(summary);
-    }
-
-    if (summaries.length > 0) return summaries;
-    return (await this.listSessions()).filter((summary) => summary.sessionId === sessionId);
-  }
-
-  private async getPiProcesses(context?: AgentDetectionContext): Promise<ProcessInfo[]> {
-    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
-    const relevant = filterByProcessNames(snapshot, this.processNames);
-
-    const byPid = new Map<number, ProcessInfo>();
-    for (const processInfo of relevant) {
-      if (this.canHandle(processInfo)) byPid.set(processInfo.pid, processInfo);
-    }
-    return Array.from(byPid.values());
-  }
-
-  private createLocator(): PiSessionLocator {
-    return new PiSessionLocator({ sessionsDir: this.piSessionsDir }, this.parser);
-  }
-
-  private createTracker(): PiSessionTracker {
-    return new PiSessionTracker({
-      sessionsDir: this.piSessionsDir,
-      trackerPath: this.trackerPath,
-    });
-  }
-
-  private mapRegistryCache(processes: ProcessInfo[]): MappedAgentResult {
-    const matches: SessionFileMatch[] = [];
-    const fallback: ProcessInfo[] = [];
-    const byPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
-
-    for (const processInfo of processes) {
-      const entry = byPid.get(processInfo.pid);
-      if (
-        !entry ||
-        entry.type !== this.type ||
-        !entry.sessionFilePath ||
-        !fs.existsSync(entry.sessionFilePath)
-      ) {
-        fallback.push(processInfo);
-        continue;
-      }
-
-      matches.push({ process: processInfo, filePath: entry.sessionFilePath });
-    }
-
-    const mapped = this.mapSessionFileMatches(matches);
-    return { agents: mapped.agents, fallback: [...fallback, ...mapped.fallback] };
-  }
-
-  private mapTrackerMatches(processes: ProcessInfo[]): MappedAgentResult {
-    const { matches, fallback } = this.createTracker().match(processes);
-    const mapped = this.mapSessionFileMatches(matches);
-    return { agents: mapped.agents, fallback: [...fallback, ...mapped.fallback] };
-  }
-
-  private mapLegacyMatches(
-    matches: Array<{ process: ProcessInfo; session: { filePath: string } }>,
-  ): MappedAgentResult {
-    return this.mapSessionFileMatches(
-      matches.map((match) => ({ process: match.process, filePath: match.session.filePath })),
-    );
-  }
-
-  private mapSessionFileMatches(matches: SessionFileMatch[]): MappedAgentResult {
-    const agents: AgentInfo[] = [];
-    const fallback: ProcessInfo[] = [];
-
-    for (const match of matches) {
-      const session = this.parser.readSession(match.filePath, match.process.cwd);
-      if (session) {
-        agents.push(this.mapper.mapSessionToAgent(session, match.process, match.filePath));
-      } else {
-        fallback.push(match.process);
-      }
-    }
-
-    return { agents, fallback };
-  }
-
-  private findUnmatchedProcesses(processes: ProcessInfo[], agents: AgentInfo[]): ProcessInfo[] {
-    const matchedPids = new Set(agents.map((agent) => agent.pid));
-    return processes.filter((processInfo) => !matchedPids.has(processInfo.pid));
-  }
-
-  private isPiExecutable(command: string): boolean {
-    for (const token of command.trim().split(/\s+/)) {
-      const base = executableBasename(token);
-      if (base === "pi" || base === "pi.exe" || base === "pi.js") return true;
-    }
-    return false;
-  }
-}

package/src/providers/pi/PiAgentMapper.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 { type PiSession, PiSessionParser } from "./PiSessionParser.js";
-
-export class PiAgentMapper {
-  constructor(private readonly parser: PiSessionParser = new PiSessionParser()) {}
-
-  mapSessionToAgent(session: PiSession, processInfo: ProcessInfo, filePath: string): AgentInfo {
-    const projectPath = session.projectPath || processInfo.cwd || "";
-    return {
-      name: generateAgentName(projectPath, processInfo.pid),
-      type: "pi",
-      status: this.parser.determineStatus(session),
-      summary: session.summary || "Pi 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: "pi",
-      status: AgentStatus.RUNNING,
-      summary: "Pi process running",
-      pid: processInfo.pid,
-      projectPath: processInfo.cwd || "",
-      sessionId: `pid-${processInfo.pid}`,
-      lastActive: new Date(),
-    };
-  }
-}

package/src/providers/pi/PiSessionLocator.ts

@@ -1,110 +0,0 @@
-import * as path from "path";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { matchProcessesToSessions, type MatchResult } from "../../utils/matching.js";
-import {
-  isDirectory,
-  isSafePathSegment,
-  safeReaddir,
-  safeStat,
-  type SessionFile,
-} from "../../utils/session.js";
-import { PiSessionParser } from "./PiSessionParser.js";
-
-export interface PiSessionLocatorOptions {
-  sessionsDir?: string;
-}
-
-export interface PiProcessSessionMatches {
-  legacyMatches: MatchResult[];
-  fallback: ProcessInfo[];
-}
-
-export class PiSessionLocator {
-  private readonly sessionsDir: string;
-
-  constructor(
-    options: PiSessionLocatorOptions = {},
-    private readonly parser: PiSessionParser = new PiSessionParser(),
-  ) {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    this.sessionsDir = options.sessionsDir ?? path.join(homeDir, ".pi", "agent", "sessions");
-  }
-
-  matchRunningProcesses(processes: ProcessInfo[]): PiProcessSessionMatches {
-    if (processes.length === 0) return { legacyMatches: [], fallback: [] };
-
-    const sessions = this.discoverLiveSessions(processes);
-    if (sessions.length === 0) return { legacyMatches: [], fallback: processes };
-
-    return {
-      legacyMatches: matchProcessesToSessions(processes, sessions),
-      fallback: processes,
-    };
-  }
-
-  discoverLiveSessions(processes: ProcessInfo[] = []): SessionFile[] {
-    if (!isDirectory(this.sessionsDir)) return [];
-
-    const cwdByProjectDir = this.buildProjectDirCwdMap(processes);
-    const sessions: SessionFile[] = [];
-    for (const filePath of this.discoverHistoricalSessionFiles()) {
-      const stat = safeStat(filePath);
-      if (!stat) continue;
-
-      const session = this.parser.readSession(filePath);
-      const sessionId = session?.sessionId || this.parser.sessionIdFromFile(filePath);
-      const projectDir = path.dirname(filePath);
-      sessions.push({
-        sessionId,
-        filePath,
-        projectDir,
-        birthtimeMs: stat.birthtimeMs || stat.mtimeMs,
-        resolvedCwd: session?.projectPath || cwdByProjectDir.get(path.basename(projectDir)) || "",
-      });
-    }
-
-    return sessions;
-  }
-
-  discoverHistoricalSessionFiles(): string[] {
-    return this.collectJsonlFiles(this.sessionsDir);
-  }
-
-  findHistoricalSessionFilesById(sessionId: string): string[] {
-    if (!isSafePathSegment(sessionId)) return [];
-
-    return this.collectJsonlFiles(this.sessionsDir).filter((filePath) => {
-      const basename = path.basename(filePath, ".jsonl");
-      return basename === sessionId || basename.endsWith(`_${sessionId}`);
-    });
-  }
-
-  private buildProjectDirCwdMap(processes: ProcessInfo[]): Map<string, string> {
-    const map = new Map<string, string>();
-    for (const proc of processes) {
-      if (!proc.cwd) continue;
-      map.set(this.encodeProjectDir(proc.cwd), proc.cwd);
-    }
-    return map;
-  }
-
-  private collectJsonlFiles(dir: string): string[] {
-    const files: string[] = [];
-    for (const entry of safeReaddir(dir)) {
-      const fullPath = path.join(dir, entry);
-      const stat = safeStat(fullPath);
-      if (!stat) continue;
-      if (stat.isDirectory()) {
-        files.push(...this.collectJsonlFiles(fullPath));
-      } else if (stat.isFile() && entry.endsWith(".jsonl")) {
-        files.push(fullPath);
-      }
-    }
-    return files;
-  }
-
-  private encodeProjectDir(cwd: string): string {
-    const normalized = path.resolve(cwd);
-    return `--${normalized.replace(/^\//, "").replace(/\//g, "-")}--`;
-  }
-}