@ai-devkit/agent-manager 0.36.0 → 0.37.0

package/src/providers/gemini/GeminiSessionLocator.ts

@@ -1,183 +0,0 @@
-import * as crypto from "crypto";
-import * as fs from "fs";
-import * as path from "path";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import type { SessionFile } from "../../utils/session.js";
-import { isDirectory, safeReaddir } from "../../utils/session.js";
-
-export interface GeminiSessionDiscovery {
-  sessions: SessionFile[];
-  contentCache: Map<string, string>;
-}
-
-export interface GeminiSessionLocatorOptions {
-  geminiTmpDir?: string;
-}
-
-interface GeminiSessionMetadata {
-  sessionId?: string;
-  projectHash?: string;
-}
-
-const SESSION_FILE_PREFIX = "session-";
-const CHATS_DIR_NAME = "chats";
-
-export class GeminiSessionLocator {
-  private readonly geminiTmpDir: string;
-
-  constructor(options: GeminiSessionLocatorOptions = {}) {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    this.geminiTmpDir = options.geminiTmpDir ?? path.join(homeDir, ".gemini", "tmp");
-  }
-
-  /**
-   * Discover session files for the given processes.
-   *
-   * Gemini CLI writes sessions to ~/.gemini/tmp/<shortId>/chats/session-*.json
-   * where <shortId> is opaque (managed by a project registry). We scan every
-   * shortId directory and filter by matching session.projectHash against
-   * sha256(process.cwd) to bind each session to a candidate process CWD.
-   */
-  discoverSessions(processes: ProcessInfo[]): GeminiSessionDiscovery {
-    const empty = { sessions: [] as SessionFile[], contentCache: new Map<string, string>() };
-    if (!fs.existsSync(this.geminiTmpDir)) return empty;
-
-    const cwdHashMap = this.buildCwdHashMap(processes);
-    if (cwdHashMap.size === 0) return empty;
-
-    const contentCache = new Map<string, string>();
-    const sessions: SessionFile[] = [];
-
-    let shortIdEntries: string[];
-    try {
-      shortIdEntries = fs.readdirSync(this.geminiTmpDir);
-    } catch {
-      return empty;
-    }
-
-    for (const shortId of shortIdEntries) {
-      const chatsDir = path.join(this.geminiTmpDir, shortId, CHATS_DIR_NAME);
-      if (!isDirectory(chatsDir)) continue;
-
-      for (const fileName of safeReaddir(chatsDir)) {
-        if (!this.isSessionFile(fileName)) continue;
-
-        const session = this.readCandidateSession(chatsDir, fileName, cwdHashMap);
-        if (!session) continue;
-
-        contentCache.set(session.filePath, session.content);
-        sessions.push(session.sessionFile);
-      }
-    }
-
-    return { sessions, contentCache };
-  }
-
-  discoverHistoricalSessionFiles(): string[] {
-    if (!isDirectory(this.geminiTmpDir)) return [];
-
-    const files: string[] = [];
-    for (const shortId of safeReaddir(this.geminiTmpDir)) {
-      const chatsDir = path.join(this.geminiTmpDir, shortId, CHATS_DIR_NAME);
-      if (!isDirectory(chatsDir)) continue;
-
-      for (const fileName of safeReaddir(chatsDir)) {
-        if (this.isSessionFile(fileName)) {
-          files.push(path.join(chatsDir, fileName));
-        }
-      }
-    }
-
-    return files;
-  }
-
-  private readCandidateSession(
-    chatsDir: string,
-    fileName: string,
-    cwdHashMap: Map<string, string>,
-  ): { filePath: string; content: string; sessionFile: SessionFile } | null {
-    const filePath = path.join(chatsDir, fileName);
-
-    let content: string;
-    try {
-      content = fs.readFileSync(filePath, "utf-8");
-    } catch {
-      return null;
-    }
-
-    const parsed = this.parseSessionMetadata(content);
-    if (!parsed?.projectHash) return null;
-
-    const resolvedCwd = cwdHashMap.get(parsed.projectHash);
-    if (!resolvedCwd) return null;
-
-    let birthtimeMs = 0;
-    try {
-      birthtimeMs = fs.statSync(filePath).birthtimeMs;
-    } catch {
-      return null;
-    }
-
-    return {
-      filePath,
-      content,
-      sessionFile: {
-        sessionId: parsed.sessionId || fileName.replace(/\.json$/, ""),
-        filePath,
-        projectDir: chatsDir,
-        birthtimeMs,
-        resolvedCwd,
-      },
-    };
-  }
-
-  private buildCwdHashMap(processes: ProcessInfo[]): Map<string, string> {
-    const map = new Map<string, string>();
-    for (const proc of processes) {
-      if (!proc.cwd) continue;
-
-      // Gemini CLI resolves its project root by walking up from the
-      // startup directory looking for a `.git` boundary marker. A
-      // session's projectHash therefore tracks that ancestor rather
-      // than the process' actual CWD. Enumerate every ancestor as a
-      // candidate so subdirectory invocations still line up with the
-      // session the Gemini process wrote.
-      for (const candidate of this.candidateProjectRoots(proc.cwd)) {
-        const hash = this.hashProjectRoot(candidate);
-        if (!map.has(hash)) {
-          map.set(hash, proc.cwd);
-        }
-      }
-    }
-    return map;
-  }
-
-  private candidateProjectRoots(cwd: string): string[] {
-    const roots: string[] = [];
-    let current = path.resolve(cwd);
-    let parent = path.dirname(current);
-    while (parent !== current) {
-      roots.push(current);
-      current = parent;
-      parent = path.dirname(current);
-    }
-    roots.push(current);
-    return roots;
-  }
-
-  private hashProjectRoot(projectRoot: string): string {
-    return crypto.createHash("sha256").update(projectRoot).digest("hex");
-  }
-
-  private isSessionFile(fileName: string): boolean {
-    return fileName.startsWith(SESSION_FILE_PREFIX) && fileName.endsWith(".json");
-  }
-
-  private parseSessionMetadata(content: string): GeminiSessionMetadata | null {
-    try {
-      return JSON.parse(content) as GeminiSessionMetadata;
-    } catch {
-      return null;
-    }
-  }
-}

package/src/providers/grok/GrokSessionParser.ts

@@ -1,166 +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";
-
-export const CHAT_HISTORY_FILE = "chat_history.jsonl";
-const IDLE_THRESHOLD_MINUTES = 5;
-
-/** One line of chat_history.jsonl. */
-interface ChatRecord {
-  type?: string;
-  content?: unknown;
-}
-
-interface ChatScan {
-  messages: ConversationMessage[];
-  firstUserMessage?: string;
-  lastUserMessage?: string;
-  lastRole?: ConversationMessage["role"];
-}
-
-/** Parsed state for a single ~/.grok/sessions/<cwd>/<id>/ directory. */
-export interface GrokSession {
-  sessionId: string;
-  projectPath: string;
-  sessionFilePath: string;
-  sessionStart: Date;
-  lastActive: Date;
-  firstUserMessage?: string;
-  lastUserMessage?: string;
-  lastRole?: ConversationMessage["role"];
-}
-
-export class GrokSessionParser {
-  /**
-   * Parse a session directory into a {@link GrokSession} from its
-   * chat_history.jsonl transcript. Returns null when the transcript is
-   * missing — i.e. there is no real session to surface.
-   */
-  readSession(sessionDir: string, defaultCwd: string): GrokSession | null {
-    const chatPath = path.join(sessionDir, CHAT_HISTORY_FILE);
-    const chatStat = safeStat(chatPath);
-    if (!chatStat) return null;
-
-    const scan = this.parseChatHistory(chatPath, false);
-    const dirStat = safeStat(sessionDir);
-    const lastActive = chatStat.mtime;
-
-    return {
-      sessionId: path.basename(sessionDir),
-      projectPath: defaultCwd,
-      sessionFilePath: chatPath,
-      sessionStart: dirStat?.birthtime || lastActive,
-      lastActive,
-      firstUserMessage: scan.firstUserMessage,
-      lastUserMessage: scan.lastUserMessage,
-      lastRole: scan.lastRole,
-    };
-  }
-
-  /** Accepts a session dir or an explicit chat_history.jsonl path. */
-  getConversation(sessionPath: string, options?: { verbose?: boolean }): ConversationMessage[] {
-    return this.parseChatHistory(this.resolveChatPath(sessionPath), options?.verbose ?? false)
-      .messages;
-  }
-
-  /**
-   * Determine agent status from parsed session state.
-   *
-   * - past the idle threshold → IDLE
-   * - last transcript turn is an assistant message → WAITING (awaiting user)
-   * - otherwise (last turn was a user message, or unknown) → RUNNING
-   */
-  determineStatus(session: GrokSession): AgentStatus {
-    const diffMinutes = (Date.now() - session.lastActive.getTime()) / 60000;
-    if (diffMinutes > IDLE_THRESHOLD_MINUTES) {
-      return AgentStatus.IDLE;
-    }
-    if (session.lastRole === "assistant") {
-      return AgentStatus.WAITING;
-    }
-    return AgentStatus.RUNNING;
-  }
-
-  /**
-   * Single pass over chat_history.jsonl. Each line is a
-   * { type: 'system' | 'user' | 'assistant', content } record where content is
-   * either a string or an array of { type: 'text', text } blocks.
-   *
-   * Grok wraps the real user prompt in <user_query>...</user_query>; the other
-   * user records are context injections (<user_info>, <system-reminder>, ...)
-   * and are skipped so the summary is the actual prompt, not boilerplate.
-   */
-  private parseChatHistory(chatPath: string, verbose: boolean): ChatScan {
-    const content = safeReadFile(chatPath);
-    if (content === undefined) return { messages: [] };
-
-    const messages: ConversationMessage[] = [];
-    let lastRole: ConversationMessage["role"] | undefined;
-
-    for (const line of content.trim().split("\n")) {
-      if (!line.trim()) continue;
-
-      let record: ChatRecord;
-      try {
-        record = JSON.parse(line);
-      } catch {
-        continue;
-      }
-
-      const text = this.extractText(record.content);
-      if (record.type === "user") {
-        const query = this.extractUserQuery(text);
-        if (query === null) continue; // context injection, not a real prompt
-        messages.push({ role: "user", content: query });
-        lastRole = "user";
-      } else if (record.type === "assistant") {
-        if (!text) continue;
-        messages.push({ role: "assistant", content: text });
-        lastRole = "assistant";
-      } else if (verbose && record.type === "system") {
-        if (!text) continue;
-        messages.push({ role: "system", content: text });
-      }
-    }
-
-    const userTurns = messages.filter((m) => m.role === "user");
-    return {
-      messages,
-      firstUserMessage: userTurns[0]?.content,
-      lastUserMessage: userTurns[userTurns.length - 1]?.content,
-      lastRole,
-    };
-  }
-
-  /** Flatten a chat record's content (string or text-block array) to text. */
-  private extractText(content: unknown): string {
-    if (typeof content === "string") return content;
-    if (Array.isArray(content)) {
-      return content
-        .map((block) =>
-          block &&
-          typeof block === "object" &&
-          typeof (block as { text?: unknown }).text === "string"
-            ? (block as { text: string }).text
-            : "",
-        )
-        .join("");
-    }
-    return "";
-  }
-
-  /**
-   * Extract the prompt inside <user_query>...</user_query>. Returns null when
-   * the record has no such tag (a context injection rather than a prompt).
-   */
-  private extractUserQuery(text: string): string | null {
-    const match = text.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/);
-    return match ? match[1].trim() : null;
-  }
-
-  /** Resolve a session dir or an explicit chat_history.jsonl path to the file. */
-  private resolveChatPath(sessionPath: string): string {
-    return sessionPath.endsWith(".jsonl") ? sessionPath : path.join(sessionPath, CHAT_HISTORY_FILE);
-  }
-}

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, "-")}--`;
-  }
-}