tktop 0.1.0__py3-none-any.whl

tktop/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("tktop")
+except PackageNotFoundError:
+    __version__ = "0.1.0"

tktop/adapter/claude.py

@@ -0,0 +1,177 @@
+import json
+from collections.abc import AsyncIterator
+from datetime import UTC, datetime
+from pathlib import Path
+
+from tktop.metrics.types import (
+    SessionInfo,
+    TokenUsage,
+    ToolCall,
+    Turn,
+)
+
+
+class ClaudeCodeAdapter:
+    name = "claude-code"
+
+    def __init__(self, base_dir: str) -> None:
+        self.base_dir = Path(base_dir)
+
+    @classmethod
+    def is_available(cls, base_dir: str) -> bool:
+        return (Path(base_dir) / "sessions").exists()
+
+    async def discover(self) -> list[SessionInfo]:
+        sessions_dir = self.base_dir / "sessions"
+        if not sessions_dir.exists():
+            return []
+
+        sessions: list[SessionInfo] = []
+        for path in sessions_dir.glob("*.json"):
+            try:
+                data = json.loads(path.read_text())
+            except (json.JSONDecodeError, OSError):
+                continue
+
+            sessions.append(
+                SessionInfo(
+                    id=data["sessionId"],
+                    pid=data.get("pid", 0),
+                    agent_type="claude-code",
+                    project_path=data.get("cwd", ""),
+                    model="",
+                    status=data.get("status", "unknown"),
+                    started_at=datetime.fromtimestamp(
+                        data["startedAt"] / 1000, tz=UTC
+                    ),
+                    updated_at=datetime.fromtimestamp(
+                        data.get("updatedAt", data["startedAt"]) / 1000,
+                        tz=UTC,
+                    ),
+                    version=data.get("version", ""),
+                )
+            )
+
+        for session in sessions:
+            session.title = self._read_title(session.id)
+
+        sessions.sort(key=lambda s: s.updated_at, reverse=True)
+        return sessions
+
+    async def parse_transcript(self, session_id: str) -> list[Turn]:
+        transcript_path = self._find_transcript(session_id)
+        if transcript_path is None:
+            return []
+
+        turns: list[Turn] = []
+        turn_number = 0
+
+        for line in transcript_path.read_text().splitlines():
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                entry = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            entry_type = entry.get("type")
+            if entry_type not in ("assistant", "user"):
+                continue
+
+            msg = entry.get("message", {})
+            if not isinstance(msg, dict):
+                continue
+
+            turn_number += 1
+            usage_data = msg.get("usage") or {}
+            content_blocks = msg.get("content", [])
+            if isinstance(content_blocks, str):
+                content_blocks = [{"type": "text", "text": content_blocks}]
+
+            tool_calls: list[ToolCall] = []
+            text_parts: list[str] = []
+
+            for block in content_blocks:
+                if not isinstance(block, dict):
+                    continue
+                if block.get("type") == "tool_use":
+                    tool_calls.append(
+                        ToolCall(name=block.get("name", ""), id=block.get("id", ""))
+                    )
+                elif block.get("type") == "text":
+                    text_parts.append(block.get("text", ""))
+
+            preview = " ".join(text_parts)[:200]
+            timestamp_str = entry.get("timestamp", "")
+            try:
+                timestamp = datetime.fromisoformat(
+                    timestamp_str.replace("Z", "+00:00")
+                )
+            except (ValueError, AttributeError):
+                timestamp = datetime.now(tz=UTC)
+
+            turns.append(
+                Turn(
+                    number=turn_number,
+                    timestamp=timestamp,
+                    role=entry_type,
+                    model=msg.get("model"),
+                    usage=TokenUsage(
+                        input_tokens=usage_data.get("input_tokens", 0),
+                        output_tokens=usage_data.get("output_tokens", 0),
+                        cache_creation_tokens=usage_data.get(
+                            "cache_creation_input_tokens", 0
+                        ),
+                        cache_read_tokens=usage_data.get(
+                            "cache_read_input_tokens", 0
+                        ),
+                    ),
+                    tool_calls=tool_calls,
+                    content_preview=preview,
+                )
+            )
+
+        return turns
+
+    def _find_transcript(self, session_id: str) -> Path | None:
+        projects_dir = self.base_dir / "projects"
+        if not projects_dir.exists():
+            return None
+
+        filename = f"{session_id}.jsonl"
+        for project_dir in projects_dir.iterdir():
+            if not project_dir.is_dir():
+                continue
+            candidate = project_dir / filename
+            if candidate.exists():
+                return candidate
+
+        return None
+
+    def _read_title(self, session_id: str) -> str:
+        transcript_path = self._find_transcript(session_id)
+        if transcript_path is None:
+            return ""
+
+        try:
+            with open(transcript_path) as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if entry.get("type") == "ai-title":
+                        return entry.get("aiTitle", "")
+        except OSError:
+            pass
+
+        return ""
+
+    async def watch(self, session_id: str) -> AsyncIterator[Turn]:
+        raise NotImplementedError
+        yield  # type: ignore[misc]

tktop/adapter/codex.py

@@ -0,0 +1,265 @@
+import json
+import tomllib
+from collections.abc import AsyncIterator
+from datetime import UTC, datetime
+from pathlib import Path
+
+from tktop.metrics.types import SessionInfo, TokenUsage, ToolCall, Turn
+
+
+class CodexAdapter:
+    name = "codex"
+
+    def __init__(self, base_dir: str) -> None:
+        self.base_dir = Path(base_dir)
+        self.default_model = self._read_default_model()
+        self._session_index = self._read_session_index()
+
+    @classmethod
+    def is_available(cls, base_dir: str) -> bool:
+        root = Path(base_dir)
+        return root.exists() and (root / "sessions").exists()
+
+    async def discover(self) -> list[SessionInfo]:
+        sessions_dir = self.base_dir / "sessions"
+        if not sessions_dir.exists():
+            return []
+
+        sessions: list[SessionInfo] = []
+        seen: set[str] = set()
+
+        for path in sessions_dir.rglob("*.jsonl"):
+            meta = self._read_session_meta(path)
+            if meta is None:
+                continue
+
+            session_id = str(meta.get("id", "")).strip()
+            if not session_id or session_id in seen:
+                continue
+            seen.add(session_id)
+
+            index_entry = self._session_index.get(session_id, {})
+            started_at = self._parse_timestamp(meta.get("timestamp"))
+            if started_at is None:
+                started_at = datetime.fromtimestamp(path.stat().st_mtime, tz=UTC)
+
+            updated_at = self._parse_timestamp(index_entry.get("updated_at"))
+            if updated_at is None:
+                updated_at = datetime.fromtimestamp(path.stat().st_mtime, tz=UTC)
+
+            sessions.append(
+                SessionInfo(
+                    id=session_id,
+                    pid=0,
+                    agent_type="codex",
+                    project_path=str(meta.get("cwd", "")),
+                    model=self.default_model,
+                    status="idle",
+                    started_at=started_at,
+                    updated_at=updated_at,
+                    version=str(meta.get("cli_version", "")),
+                    title=str(index_entry.get("thread_name", "")),
+                )
+            )
+
+        sessions.sort(key=lambda s: s.updated_at, reverse=True)
+        return sessions
+
+    async def parse_transcript(self, session_id: str) -> list[Turn]:
+        transcript_path = self._find_transcript(session_id)
+        if transcript_path is None:
+            return []
+
+        turns: list[Turn] = []
+        current_turn: Turn | None = None
+        last_assistant_turn: Turn | None = None
+        turn_number = 0
+
+        for raw_line in transcript_path.read_text().splitlines():
+            line = raw_line.strip()
+            if not line:
+                continue
+
+            try:
+                entry = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            payload = entry.get("payload", {})
+            if not isinstance(payload, dict):
+                continue
+
+            entry_type = entry.get("type")
+            payload_type = payload.get("type")
+
+            if entry_type == "event_msg" and payload_type == "token_count":
+                if last_assistant_turn is not None:
+                    info = payload.get("info", {})
+                    if isinstance(info, dict):
+                        last = info.get("last_token_usage", {})
+                        if isinstance(last, dict):
+                            last_assistant_turn.usage = TokenUsage(
+                                input_tokens=int(last.get("input_tokens", 0) or 0),
+                                output_tokens=int(last.get("output_tokens", 0) or 0),
+                                cache_creation_tokens=0,
+                                cache_read_tokens=int(
+                                    last.get("cached_input_tokens", 0) or 0
+                                ),
+                            )
+                continue
+
+            if entry_type != "response_item":
+                continue
+
+            if payload_type == "message":
+                role = payload.get("role")
+                if role == "developer":
+                    continue
+                if role not in ("user", "assistant"):
+                    continue
+
+                if current_turn is not None:
+                    turns.append(current_turn)
+
+                turn_number += 1
+                timestamp = self._parse_timestamp(
+                    entry.get("timestamp") or payload.get("timestamp")
+                )
+                current_turn = Turn(
+                    number=turn_number,
+                    timestamp=timestamp,
+                    role=role,
+                    model=self.default_model if role == "assistant" else None,
+                    usage=TokenUsage(),
+                    tool_calls=[],
+                    content_preview=self._extract_preview(payload),
+                )
+                if role == "assistant":
+                    last_assistant_turn = current_turn
+                continue
+
+            if current_turn is None or current_turn.role != "assistant":
+                continue
+
+            if payload_type in ("function_call", "custom_tool_call"):
+                call_name = str(payload.get("name", ""))
+                call_id = str(
+                    payload.get("call_id")
+                    or payload.get("id")
+                    or f"{current_turn.number}-{len(current_turn.tool_calls) + 1}"
+                )
+                current_turn.tool_calls.append(ToolCall(name=call_name, id=call_id))
+                continue
+
+            if payload_type == "function_call_output":
+                continue
+
+        if current_turn is not None:
+            turns.append(current_turn)
+
+        for turn in reversed(turns):
+            if turn.role == "assistant" and not turn.model:
+                turn.model = self.default_model or None
+                break
+
+        return turns
+
+    async def watch(self, session_id: str) -> AsyncIterator[Turn]:
+        raise NotImplementedError
+        yield  # type: ignore[misc]
+
+    def _find_transcript(self, session_id: str) -> Path | None:
+        sessions_dir = self.base_dir / "sessions"
+        if not sessions_dir.exists():
+            return None
+
+        for path in sessions_dir.rglob(f"*{session_id}.jsonl"):
+            if path.is_file():
+                return path
+        return None
+
+    def _read_session_index(self) -> dict[str, dict[str, str]]:
+        index_path = self.base_dir / "session_index.jsonl"
+        if not index_path.exists():
+            return {}
+
+        index: dict[str, dict[str, str]] = {}
+        try:
+            for raw_line in index_path.read_text().splitlines():
+                line = raw_line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                session_id = str(entry.get("id", "")).strip()
+                if not session_id:
+                    continue
+                index[session_id] = {
+                    "thread_name": str(entry.get("thread_name", "")),
+                    "updated_at": str(entry.get("updated_at", "")),
+                }
+        except OSError:
+            return {}
+        return index
+
+    def _read_session_meta(self, path: Path) -> dict | None:
+        try:
+            with path.open() as f:
+                for raw_line in f:
+                    line = raw_line.strip()
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if entry.get("type") == "session_meta":
+                        payload = entry.get("payload")
+                        if isinstance(payload, dict):
+                            return payload
+                        return None
+        except OSError:
+            return None
+        return None
+
+    def _read_default_model(self) -> str:
+        config_path = self.base_dir / "config.toml"
+        if not config_path.exists():
+            return ""
+
+        try:
+            with config_path.open("rb") as f:
+                data = tomllib.load(f)
+        except (OSError, tomllib.TOMLDecodeError):
+            return ""
+
+        model = data.get("model")
+        return model if isinstance(model, str) else ""
+
+    @staticmethod
+    def _extract_preview(payload: dict) -> str:
+        parts: list[str] = []
+        for block in payload.get("content", []):
+            if not isinstance(block, dict):
+                continue
+            block_type = block.get("type")
+            if block_type == "input_text":
+                text = block.get("text", "")
+            elif block_type == "output_text":
+                text = block.get("text", "")
+            else:
+                continue
+            if text:
+                parts.append(str(text))
+        return " ".join(parts)[:200]
+
+    @staticmethod
+    def _parse_timestamp(value: object) -> datetime:
+        if isinstance(value, str):
+            try:
+                return datetime.fromisoformat(value.replace("Z", "+00:00"))
+            except ValueError:
+                pass
+        return datetime.now(tz=UTC)

tktop/adapter/factory.py

@@ -0,0 +1,23 @@
+from tktop.config import Config
+
+from .claude import ClaudeCodeAdapter
+from .codex import CodexAdapter
+from .protocol import SessionAdapter
+
+
+def create_adapter(cfg: Config) -> SessionAdapter:
+    choice = (cfg.session_adapter or "auto").strip().lower()
+
+    if choice == "claude":
+        return ClaudeCodeAdapter(cfg.claude_dir)
+    if choice == "codex":
+        return CodexAdapter(cfg.codex_dir)
+    if choice != "auto":
+        raise ValueError(f"unknown session adapter: {cfg.session_adapter}")
+
+    if ClaudeCodeAdapter.is_available(cfg.claude_dir):
+        return ClaudeCodeAdapter(cfg.claude_dir)
+    if CodexAdapter.is_available(cfg.codex_dir):
+        return CodexAdapter(cfg.codex_dir)
+
+    return ClaudeCodeAdapter(cfg.claude_dir)

tktop/adapter/protocol.py

@@ -0,0 +1,15 @@
+from collections.abc import AsyncIterator
+from typing import Protocol, runtime_checkable
+
+from tktop.metrics.types import SessionInfo, Turn
+
+
+@runtime_checkable
+class SessionAdapter(Protocol):
+    name: str
+
+    async def discover(self) -> list[SessionInfo]: ...
+
+    async def parse_transcript(self, session_id: str) -> list[Turn]: ...
+
+    async def watch(self, session_id: str) -> AsyncIterator[Turn]: ...

tktop/cli.py

@@ -0,0 +1,33 @@
+import json
+
+import typer
+
+from tktop.config import SETTINGS_FILE, get_resolved_config_as_dict, load_config
+from tktop.tui.app import TktopApp
+
+app = typer.Typer(help="tktop — token monitor for coding agents", invoke_without_command=True)
+config_app = typer.Typer(help="Manage tktop configuration")
+app.add_typer(config_app, name="config")
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context) -> None:
+    """Launch the interactive token monitor."""
+    if ctx.invoked_subcommand is None:
+        config = load_config()
+        tktop = TktopApp(config=config)
+        tktop.run()
+
+
+@config_app.command("show")
+def config_show() -> None:
+    """Print resolved configuration as JSON."""
+    cfg = load_config()
+    result = get_resolved_config_as_dict(cfg)
+    typer.echo(json.dumps(result, indent=2))
+
+
+@config_app.command("path")
+def config_path() -> None:
+    """Print the settings file path."""
+    typer.echo(str(SETTINGS_FILE))