ccsessions-tui 0.1.0__py3-none-any.whl

ccsessions/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

ccsessions/__main__.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import sys
+
+from .core.resume import ResumeError, ResumeRequest, execute_resume
+from .ui.app import CCSessionsApp
+
+
+def main() -> int:
+    app = CCSessionsApp()
+    result = app.run()
+    if isinstance(result, ResumeRequest):
+        try:
+            execute_resume(result)  # replaces process; does not return on success
+        except ResumeError as e:
+            print(f"Resume failed: {e}", file=sys.stderr)
+            return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ccsessions/core/aliases.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .models import Project
+
+DEFAULT_ALIASES_PATH = Path.home() / ".config" / "ccsessions" / "aliases.json"
+
+
+class ProjectAliases:
+    """Cosmetic display names for projects, keyed by project path.
+
+    Purely a ccsessions-side overlay — nothing under ~/.claude is touched,
+    so the default (path-derived) name is always recoverable by removing
+    the alias.
+    """
+
+    def __init__(self, path: Path = DEFAULT_ALIASES_PATH) -> None:
+        self.path = path
+        self._data: dict[str, str] = {}
+        self._load()
+
+    def _load(self) -> None:
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            return
+        if isinstance(data, dict):
+            self._data = {
+                k: v for k, v in data.items() if isinstance(k, str) and isinstance(v, str)
+            }
+
+    def get(self, project_path: str) -> str:
+        return self._data.get(project_path, "")
+
+    def set(self, project_path: str, alias: str) -> None:
+        self._data[project_path] = alias
+
+    def remove(self, project_path: str) -> None:
+        self._data.pop(project_path, None)
+
+    def save(self) -> None:
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            tmp = self.path.with_suffix(".tmp")
+            tmp.write_text(
+                json.dumps(self._data, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            tmp.replace(self.path)
+        except OSError:
+            pass
+
+    def apply(self, projects: list[Project]) -> None:
+        for p in projects:
+            p.alias = self.get(p.project_path)

ccsessions/core/cache.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from .models import TokenStats
+
+DEFAULT_CACHE_PATH = Path.home() / ".cache" / "ccsessions" / "token-stats.json"
+
+
+class TokenCache:
+    """Per-JSONL-file token stats cache.
+
+    An entry stays valid as long as the file's (st_mtime_ns, st_size) are
+    unchanged — large finished sessions are read from disk only once.
+    """
+
+    def __init__(self, path: Path = DEFAULT_CACHE_PATH) -> None:
+        self.path = path
+        self._entries: dict[str, dict] = {}
+        self._dirty = False
+        self._load()
+
+    def _load(self) -> None:
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            return
+        if isinstance(data, dict):
+            self._entries = {
+                k: v for k, v in data.items() if isinstance(v, dict)
+            }
+
+    def get(self, jsonl: Path, stat: os.stat_result | None = None) -> TokenStats | None:
+        entry = self._entries.get(str(jsonl))
+        if not entry:
+            return None
+        if stat is None:
+            try:
+                stat = jsonl.stat()
+            except OSError:
+                return None
+        if entry.get("mtime_ns") != stat.st_mtime_ns or entry.get("size") != stat.st_size:
+            return None
+        try:
+            return TokenStats(
+                input=int(entry["input"]),
+                output=int(entry["output"]),
+                cache_read=int(entry["cache_read"]),
+                cache_write=int(entry["cache_write"]),
+                messages=int(entry["messages"]),
+            )
+        except (KeyError, TypeError, ValueError):
+            return None
+
+    def put(self, jsonl: Path, stats: TokenStats, stat: os.stat_result) -> None:
+        self._entries[str(jsonl)] = {
+            "mtime_ns": stat.st_mtime_ns,
+            "size": stat.st_size,
+            "input": stats.input,
+            "output": stats.output,
+            "cache_read": stats.cache_read,
+            "cache_write": stats.cache_write,
+            "messages": stats.messages,
+        }
+        self._dirty = True
+
+    def prune(self, existing: set[str]) -> None:
+        """Drop entries for files that no longer exist on disk."""
+        stale = [k for k in self._entries if k not in existing]
+        for k in stale:
+            del self._entries[k]
+            self._dirty = True
+
+    def save(self) -> None:
+        if not self._dirty:
+            return
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            tmp = self.path.with_suffix(".tmp")
+            tmp.write_text(json.dumps(self._entries), encoding="utf-8")
+            tmp.replace(self.path)
+            self._dirty = False
+        except OSError:
+            pass

ccsessions/core/discovery.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+from .cache import TokenCache
+from .live import get_live_session_ids
+from .manage import ARCHIVE_SUBDIR, PROJECTS_ARCHIVE_DIR
+from .models import Project, Session, TokenStats
+from .parser import extract_cwd, get_token_stats
+
+DEFAULT_PROJECTS_DIR = Path.home() / ".claude" / "projects"
+
+
+def _parse_iso(value: object) -> datetime | None:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    # normalize to local-naive so we can sort against fileMtime-derived values
+    if dt.tzinfo is not None:
+        dt = dt.astimezone().replace(tzinfo=None)
+    return dt
+
+
+def _load_index(index_path: Path) -> tuple[str, dict[str, dict]]:
+    if not index_path.is_file():
+        return "", {}
+    try:
+        data = json.loads(index_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return "", {}
+    project_path = data.get("originalPath") or ""
+    indexed: dict[str, dict] = {}
+    for entry in data.get("entries", []) or []:
+        sid = entry.get("sessionId")
+        if isinstance(sid, str):
+            indexed[sid] = entry
+    return project_path, indexed
+
+
+def _build_session(
+    sid: str,
+    jsonl: Path,
+    entry: dict,
+    live_ids: set[str],
+    project_path_fallback: str,
+    cache: TokenCache | None = None,
+    archived: bool = False,
+) -> Session:
+    missing = not jsonl.is_file()
+    tokens = get_token_stats(jsonl, cache) if not missing else TokenStats()
+    mtime: datetime | None = None
+    if not missing:
+        try:
+            mtime = datetime.fromtimestamp(jsonl.stat().st_mtime)
+        except OSError:
+            pass
+    elif entry.get("fileMtime"):
+        try:
+            mtime = datetime.fromtimestamp(int(entry["fileMtime"]) / 1000)
+        except (ValueError, TypeError):
+            pass
+    return Session(
+        session_id=sid,
+        jsonl_path=jsonl,
+        project_path=entry.get("projectPath") or project_path_fallback,
+        first_prompt=entry.get("firstPrompt") or "",
+        summary=entry.get("summary") or "",
+        message_count=int(entry.get("messageCount") or 0) or tokens.messages,
+        created=_parse_iso(entry.get("created")),
+        modified=_parse_iso(entry.get("modified")) or mtime,
+        git_branch=entry.get("gitBranch") or "",
+        is_sidechain=bool(entry.get("isSidechain", False)),
+        is_live=(not missing and not archived) and sid in live_ids,
+        is_archived=archived,
+        is_missing=missing,
+        tokens=tokens,
+    )
+
+
+def _decode_dir_name(name: str) -> str:
+    # best-effort fallback when sessions-index.json is missing
+    return "/" + name.lstrip("-").replace("-", "/")
+
+
+def _load_project(
+    proj_dir: Path, live_ids: set[str], cache: TokenCache | None = None
+) -> Project:
+    project_path, indexed = _load_index(proj_dir / "sessions-index.json")
+
+    sessions: list[Session] = []
+    seen: set[str] = set()
+
+    for jsonl in proj_dir.glob("*.jsonl"):
+        sid = jsonl.stem
+        seen.add(sid)
+        entry = indexed.get(sid, {})
+        sessions.append(_build_session(sid, jsonl, entry, live_ids, project_path, cache))
+
+    for jsonl in (proj_dir / ARCHIVE_SUBDIR).glob("*.jsonl"):
+        sid = jsonl.stem
+        if sid in seen:
+            continue
+        seen.add(sid)
+        entry = indexed.get(sid, {})
+        sessions.append(
+            _build_session(sid, jsonl, entry, live_ids, project_path, cache, archived=True)
+        )
+
+    for sid, entry in indexed.items():
+        if sid in seen:
+            continue
+        full = entry.get("fullPath")
+        path = Path(full) if isinstance(full, str) else proj_dir / f"{sid}.jsonl"
+        # include archived entries (no .jsonl on disk) — still useful as history
+        sessions.append(_build_session(sid, path, entry, live_ids, project_path, cache))
+
+    if not project_path:
+        # try to recover real cwd from a JSONL event
+        for s in sessions:
+            cwd = extract_cwd(s.jsonl_path)
+            if cwd:
+                project_path = cwd
+                break
+        if not project_path:
+            project_path = _decode_dir_name(proj_dir.name)
+        # backfill sessions that fell back to the lossy decoded path
+        for s in sessions:
+            if not s.project_path or s.project_path.startswith("/"):
+                if s.project_path == _decode_dir_name(proj_dir.name) or not s.project_path:
+                    s.project_path = project_path
+
+    sessions.sort(key=lambda s: s.modified or datetime.min, reverse=True)
+    return Project(project_path=project_path, encoded_dir=proj_dir, sessions=sessions)
+
+
+def _latest_modified(p: Project) -> datetime:
+    return max((s.modified or datetime.min) for s in p.sessions)
+
+
+def discover_projects(
+    base: Path = DEFAULT_PROJECTS_DIR,
+    cache: TokenCache | None = None,
+    archive_base: Path | None = None,
+) -> list[Project]:
+    """Scan projects (and archived projects) under ~/.claude.
+
+    When `archive_base` is None it defaults to PROJECTS_ARCHIVE_DIR, but only
+    for the real base directory — callers passing a custom `base` (tests)
+    never get the user's archive mixed in unless they ask for it.
+    """
+    if not base.is_dir():
+        return []
+    live_ids = get_live_session_ids()
+    projects: list[Project] = []
+    for proj_dir in sorted(base.iterdir()):
+        if not proj_dir.is_dir():
+            continue
+        project = _load_project(proj_dir, live_ids, cache)
+        if project.sessions:
+            projects.append(project)
+    # newest project first (by latest session modified)
+    projects.sort(key=_latest_modified, reverse=True)
+
+    if archive_base is None and base == DEFAULT_PROJECTS_DIR:
+        archive_base = PROJECTS_ARCHIVE_DIR
+    archived: list[Project] = []
+    if archive_base is not None and archive_base.is_dir():
+        for proj_dir in sorted(archive_base.iterdir()):
+            if not proj_dir.is_dir():
+                continue
+            project = _load_project(proj_dir, live_ids, cache)
+            if not project.sessions:
+                continue
+            project.is_archived = True
+            for s in project.sessions:
+                s.is_archived = True
+                s.is_live = False
+            archived.append(project)
+        archived.sort(key=_latest_modified, reverse=True)
+    # archived projects always come after active ones
+    return projects + archived

ccsessions/core/live.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+DEFAULT_SESSIONS_DIR = Path.home() / ".claude" / "sessions"
+
+
+def _pid_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
+def get_live_session_ids(base: Path = DEFAULT_SESSIONS_DIR) -> set[str]:
+    alive: set[str] = set()
+    if not base.is_dir():
+        return alive
+    for path in base.glob("*.json"):
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        pid = data.get("pid")
+        sid = data.get("sessionId")
+        if not isinstance(pid, int) or not isinstance(sid, str):
+            continue
+        if _pid_alive(pid):
+            alive.add(sid)
+    return alive

ccsessions/core/manage.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+from .models import Project, Session
+
+ARCHIVE_SUBDIR = "archived"
+PROJECTS_DIR = Path.home() / ".claude" / "projects"
+PROJECTS_ARCHIVE_DIR = Path.home() / ".claude" / "projects-archive"
+
+
+class ManageError(RuntimeError):
+    pass
+
+
+def archive_session(session: Session) -> Path:
+    """Move the .jsonl into the archived/ subdirectory — it disappears from
+    `claude --resume` but stays on disk and can be restored."""
+    if not session.jsonl_path.is_file():
+        raise ManageError("JSONL file not on this machine")
+    dest_dir = session.jsonl_path.parent / ARCHIVE_SUBDIR
+    try:
+        dest_dir.mkdir(exist_ok=True)
+        dest = dest_dir / session.jsonl_path.name
+        session.jsonl_path.rename(dest)
+    except OSError as e:
+        raise ManageError(str(e)) from e
+    return dest
+
+
+def restore_session(session: Session) -> Path:
+    """Move the .jsonl from archived/ back into the project directory."""
+    if not session.jsonl_path.is_file():
+        raise ManageError("file not found in the archive")
+    if session.jsonl_path.parent.name != ARCHIVE_SUBDIR:
+        raise ManageError("session is not archived")
+    dest = session.jsonl_path.parent.parent / session.jsonl_path.name
+    try:
+        session.jsonl_path.rename(dest)
+    except OSError as e:
+        raise ManageError(str(e)) from e
+    return dest
+
+
+def _remove_index_entry(proj_dir: Path, session_id: str) -> None:
+    index_path = proj_dir / "sessions-index.json"
+    if not index_path.is_file():
+        return
+    try:
+        data = json.loads(index_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return
+    entries = data.get("entries")
+    if not isinstance(entries, list):
+        return
+    kept = [e for e in entries if not (isinstance(e, dict) and e.get("sessionId") == session_id)]
+    if len(kept) != len(entries):
+        data["entries"] = kept
+        try:
+            index_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        except OSError:
+            pass
+
+
+def delete_session(session: Session) -> None:
+    """Delete the transcript file (if present) and its sessions-index.json entry."""
+    try:
+        if session.jsonl_path.is_file():
+            session.jsonl_path.unlink()
+    except OSError as e:
+        raise ManageError(str(e)) from e
+    proj_dir = session.jsonl_path.parent
+    if proj_dir.name == ARCHIVE_SUBDIR:
+        proj_dir = proj_dir.parent
+    _remove_index_entry(proj_dir, session.session_id)
+
+
+def archive_project(project: Project) -> Path:
+    """Move the whole project directory into ~/.claude/projects-archive/."""
+    try:
+        PROJECTS_ARCHIVE_DIR.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        raise ManageError(str(e)) from e
+    dest = PROJECTS_ARCHIVE_DIR / project.encoded_dir.name
+    if dest.exists():
+        raise ManageError(f"archive already contains directory {dest.name}")
+    try:
+        shutil.move(str(project.encoded_dir), str(dest))
+    except OSError as e:
+        raise ManageError(str(e)) from e
+    return dest
+
+
+def restore_project(project: Project) -> Path:
+    """Move an archived project directory back into ~/.claude/projects/."""
+    if not project.encoded_dir.is_dir():
+        raise ManageError("project directory not found")
+    dest = PROJECTS_DIR / project.encoded_dir.name
+    if dest.exists():
+        raise ManageError(f"projects directory already contains {dest.name}")
+    try:
+        shutil.move(str(project.encoded_dir), str(dest))
+    except OSError as e:
+        raise ManageError(str(e)) from e
+    return dest
+
+
+def delete_project(project: Project) -> None:
+    """Permanently delete the whole project directory from ~/.claude/projects/."""
+    try:
+        shutil.rmtree(project.encoded_dir)
+    except OSError as e:
+        raise ManageError(str(e)) from e

ccsessions/core/models.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+
+
+@dataclass
+class TokenStats:
+    input: int = 0
+    output: int = 0
+    cache_read: int = 0
+    cache_write: int = 0
+    messages: int = 0  # user/assistant message count computed from the JSONL
+
+    @property
+    def total(self) -> int:
+        return self.input + self.output + self.cache_read + self.cache_write
+
+    def __iadd__(self, other: "TokenStats") -> "TokenStats":
+        self.input += other.input
+        self.output += other.output
+        self.cache_read += other.cache_read
+        self.cache_write += other.cache_write
+        self.messages += other.messages
+        return self
+
+
+@dataclass
+class Session:
+    session_id: str
+    jsonl_path: Path
+    project_path: str
+    first_prompt: str = ""
+    summary: str = ""
+    message_count: int = 0
+    created: datetime | None = None
+    modified: datetime | None = None
+    git_branch: str = ""
+    is_sidechain: bool = False
+    is_live: bool = False
+    is_archived: bool = False  # .jsonl moved into the archived/ subdirectory
+    is_missing: bool = False  # index entry exists but the file does not (e.g. another machine)
+    tokens: TokenStats = field(default_factory=TokenStats)
+
+    @property
+    def display_title(self) -> str:
+        return self.summary or self.first_prompt or self.session_id
+
+
+@dataclass
+class Project:
+    project_path: str
+    encoded_dir: Path
+    sessions: list[Session] = field(default_factory=list)
+    is_archived: bool = False  # directory lives in ~/.claude/projects-archive/
+    alias: str = ""  # user-defined display name (see core.aliases)
+
+    @property
+    def default_name(self) -> str:
+        name = Path(self.project_path).name
+        return name or self.project_path
+
+    @property
+    def display_name(self) -> str:
+        return self.alias or self.default_name
+
+    @property
+    def total_tokens(self) -> TokenStats:
+        agg = TokenStats()
+        for s in self.sessions:
+            agg += s.tokens
+        return agg
+
+    @property
+    def has_live(self) -> bool:
+        return any(s.is_live for s in self.sessions)