agent-manager-cli 0.1.0__py3-none-any.whl

am/scanners/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from am.scanners.claude import scan_claude_sessions
+from am.scanners.codex import scan_codex_sessions
+from am.scanners.gemini import scan_gemini_sessions
+from am.schemas.session import LocalSession
+
+
+def scan_all_sessions() -> list[LocalSession]:
+    """Scan all supported CLI tools and return merged session list."""
+    sessions: list[LocalSession] = []
+    sessions.extend(scan_claude_sessions())
+    sessions.extend(scan_codex_sessions())
+    sessions.extend(scan_gemini_sessions())
+    sessions.sort(
+        key=lambda s: s.updated_at or datetime.min.replace(tzinfo=UTC),
+        reverse=True,
+    )
+    return sessions

am/scanners/_util.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+# Max bytes to read from end of a file to avoid OOM
+TAIL_BYTES = 64 * 1024  # 64 KB
+
+
+def read_tail(path, max_bytes: int = TAIL_BYTES) -> str:
+    """Read the tail of a file, skipping partial first line."""
+    try:
+        file_size = path.stat().st_size
+        with open(path, "rb") as f:
+            if file_size > max_bytes:
+                f.seek(file_size - max_bytes)
+                f.readline()  # skip partial line
+            return f.read().decode("utf-8", errors="replace")
+    except Exception:
+        return ""

am/scanners/claude.py

@@ -0,0 +1,105 @@
+"""Scanner for Claude Code CLI sessions (~/.claude/projects/)."""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import UTC, datetime
+from pathlib import Path
+
+from am.scanners._util import read_tail
+from am.schemas.session import LocalSession
+
+CLAUDE_DIR = Path.home() / ".claude" / "projects"
+
+_UUID_RE = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
+
+
+def _project_name(dirname: str) -> str:
+    parts = dirname.strip("-").split("-")
+    return parts[-1] if parts else dirname
+
+
+def _resolve_cwd(project_dir: Path) -> str | None:
+    """Extract real project path from `cwd` field in JSONL metadata."""
+    for jsonl_file in project_dir.glob("*.jsonl"):
+        try:
+            with open(jsonl_file, encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    cwd = entry.get("cwd")
+                    if cwd and isinstance(cwd, str):
+                        return cwd
+        except Exception:
+            continue
+    return None
+
+
+def _last_user_message(jsonl_path: Path) -> str | None:
+    tail = read_tail(jsonl_path)
+    if not tail:
+        return None
+
+    for line in reversed(tail.strip().splitlines()):
+        try:
+            entry = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if entry.get("type") != "user":
+            continue
+        msg = entry.get("message", {})
+        if msg.get("role") != "user":
+            continue
+        content = msg.get("content")
+        if isinstance(content, str):
+            text = content
+        elif isinstance(content, list):
+            text = " ".join(
+                b.get("text", "")
+                for b in content
+                if isinstance(b, dict) and b.get("type") == "text"
+            )
+        else:
+            continue
+        text = text.strip()
+        if text and not text.startswith("[Request interrupted"):
+            return text[:200]
+    return None
+
+
+def scan_claude_sessions() -> list[LocalSession]:
+    if not CLAUDE_DIR.is_dir():
+        return []
+
+    sessions: list[LocalSession] = []
+
+    for project_dir in CLAUDE_DIR.iterdir():
+        if not project_dir.is_dir():
+            continue
+
+        name = _project_name(project_dir.name)
+        cwd = _resolve_cwd(project_dir)
+
+        for f in project_dir.glob("*.jsonl"):
+            sid = f.stem
+            if not _UUID_RE.match(sid):
+                continue
+
+            sessions.append(
+                LocalSession(
+                    session_id=sid,
+                    project=name,
+                    project_path=cwd or "",
+                    cli="claude",
+                    last_message=_last_user_message(f),
+                    updated_at=datetime.fromtimestamp(f.stat().st_mtime, tz=UTC),
+                )
+            )
+
+    return sessions

am/scanners/codex.py

@@ -0,0 +1,88 @@
+"""Scanner for OpenAI Codex CLI sessions (~/.codex/sessions/)."""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import UTC, datetime
+from pathlib import Path
+
+from am.scanners._util import read_tail
+from am.schemas.session import LocalSession
+
+CODEX_DIR = Path(os.environ.get("CODEX_HOME", Path.home() / ".codex"))
+SESSIONS_DIR = CODEX_DIR / "sessions"
+
+
+def _parse_codex_session(jsonl_path: Path) -> LocalSession | None:
+    """Parse a Codex rollout-*.jsonl file."""
+    tail = read_tail(jsonl_path)
+    if not tail:
+        return None
+
+    # Extract session_id from filename: rollout-<timestamp>-<id>.jsonl
+    sid = jsonl_path.stem  # e.g. "rollout-1234567890-abcdef"
+
+    project_path = ""
+    last_message = None
+
+    for line in reversed(tail.strip().splitlines()):
+        try:
+            entry = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        # Try to find project path from turn_context or session_meta
+        if not project_path:
+            if entry.get("type") == "session_meta":
+                project_path = entry.get("cwd", "")
+            elif entry.get("cwd"):
+                project_path = entry["cwd"]
+
+        # Find last user message
+        if not last_message:
+            payload = entry.get("payload", {})
+            if payload.get("type") == "user_message":
+                text = payload.get("message", "").strip()
+                if text:
+                    last_message = text[:200]
+
+            # Also check event_msg wrapper
+            if entry.get("type") == "event_msg":
+                inner = entry.get("payload", {})
+                if inner.get("type") == "user_message":
+                    text = inner.get("message", "").strip()
+                    if text:
+                        last_message = text[:200]
+
+        if project_path and last_message:
+            break
+
+    project_name = Path(project_path).name if project_path else sid
+
+    return LocalSession(
+        session_id=sid,
+        project=project_name,
+        project_path=project_path,
+        cli="codex",
+        last_message=last_message,
+        updated_at=datetime.fromtimestamp(jsonl_path.stat().st_mtime, tz=UTC),
+    )
+
+
+def scan_codex_sessions() -> list[LocalSession]:
+    if not SESSIONS_DIR.is_dir():
+        return []
+
+    sessions: list[LocalSession] = []
+
+    # Sessions are in YYYY/MM/DD/ subdirectories
+    for jsonl_file in SESSIONS_DIR.rglob("rollout-*.jsonl"):
+        try:
+            session = _parse_codex_session(jsonl_file)
+            if session:
+                sessions.append(session)
+        except Exception:
+            continue
+
+    return sessions

am/scanners/gemini.py

@@ -0,0 +1,99 @@
+"""Scanner for Google Gemini CLI sessions (~/.gemini/tmp/)."""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+from am.schemas.session import LocalSession
+
+GEMINI_DIR = Path.home() / ".gemini" / "tmp"
+
+
+def _parse_gemini_project(project_dir: Path) -> list[LocalSession]:
+    """Parse sessions from a Gemini project hash directory."""
+    chats_dir = project_dir / "chats"
+    if not chats_dir.is_dir():
+        return []
+
+    sessions: list[LocalSession] = []
+
+    # Try to find project path from logs.json
+    project_path = ""
+    logs_file = chats_dir / "logs.json"
+    if logs_file.is_file():
+        try:
+            data = json.loads(logs_file.read_text(encoding="utf-8"))
+            # logs.json may contain cwd or project root info
+            if isinstance(data, dict):
+                project_path = data.get("cwd", "")
+        except Exception:
+            pass
+
+    project_name = Path(project_path).name if project_path else project_dir.name[:12]
+
+    # Scan JSON files in chats/ directory
+    for chat_file in chats_dir.glob("*.json"):
+        if chat_file.name == "logs.json":
+            continue
+        try:
+            stat = chat_file.stat()
+            last_message = None
+
+            # Try to extract last user message from chat JSON
+            try:
+                data = json.loads(chat_file.read_text(encoding="utf-8"))
+                messages = []
+                if isinstance(data, list):
+                    messages = data
+                elif isinstance(data, dict):
+                    messages = data.get("messages", [])
+                    if not project_path:
+                        project_path = data.get("cwd", "")
+
+                for msg in reversed(messages):
+                    if msg.get("role") == "user":
+                        content = msg.get("content", "")
+                        if isinstance(content, list):
+                            content = " ".join(
+                                p.get("text", "") for p in content if isinstance(p, dict)
+                            )
+                        text = str(content).strip()
+                        if text:
+                            last_message = text[:200]
+                            break
+            except Exception:
+                pass
+
+            sessions.append(
+                LocalSession(
+                    session_id=chat_file.stem,
+                    project=project_name,
+                    project_path=project_path,
+                    cli="gemini",
+                    last_message=last_message,
+                    updated_at=datetime.fromtimestamp(stat.st_mtime, tz=UTC),
+                )
+            )
+        except Exception:
+            continue
+
+    return sessions
+
+
+def scan_gemini_sessions() -> list[LocalSession]:
+    if not GEMINI_DIR.is_dir():
+        return []
+
+    sessions: list[LocalSession] = []
+
+    for project_dir in GEMINI_DIR.iterdir():
+        if not project_dir.is_dir():
+            continue
+        try:
+            sessions.extend(_parse_gemini_project(project_dir))
+        except Exception:
+            continue
+
+    return sessions

am/schemas/session.py

@@ -0,0 +1,12 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class LocalSession(BaseModel):
+    session_id: str
+    project: str
+    project_path: str
+    cli: str  # "claude", "codex", "gemini"
+    last_message: str | None = None
+    updated_at: datetime | None = None