context-forge-cli 0.2.0__tar.gz → 0.2.2__tar.gz

{context_forge_cli-0.2.0 → context_forge_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: context-forge-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: Session manager and context bridge for agentic CLI tools
 Project-URL: Homepage, https://github.com/emmver/contextforge
 Project-URL: Repository, https://github.com/emmver/contextforge
@@ -37,7 +37,7 @@ or across different tools.
 
 ## What it does
 
-- **Discovers sessions** from Claude Code (`~/.claude/projects/`), Claude Desktop, Codex (`~/.codex/state_5.sqlite`), Gemini (`~/.gemini/sessions/`), and altimate-code (`~/.local/share/altimate-code/`)
+- **Discovers sessions** from Claude Code (`~/.claude/projects/`), Claude Desktop, Codex (`~/.codex/state_5.sqlite`), Gemini (`~/.gemini/tmp/<project_hash>/chats/`), and altimate-code (`~/.local/share/altimate-code/`)
 - **Generates summaries** of what each session accomplished (with optional Claude API integration)
 - **Compacts context** intelligently, reducing multi-turn conversations to a token-efficient ContextBundle
 - **Transfers context** across tools and sessions (Claude Code → Codex, Codex → altimate-code, etc.)
@@ -167,7 +167,7 @@ The method is chosen automatically based on token count and whether a target ses
 | Claude Code (CLI) | `~/.claude/projects/` JSONL | `--system-prompt` / `--resume` |
 | Claude Desktop | `~/Library/Application Support/Claude/local-agent-mode-sessions/` | `--system-prompt` |
 | Codex | `~/.codex/state_5.sqlite` | `resume` / `fork` |
-| Gemini | `~/.gemini/sessions/` JSONL | `exec` / `resume` / `fork` |
+| Gemini | `~/.gemini/tmp/<project_hash>/chats/` JSON | New session / `/resume` |
 | altimate-code | `~/.local/share/altimate-code/opencode.db` | `run -s` / `import` |
 
 ## Session Summaries

{context_forge_cli-0.2.0 → context_forge_cli-0.2.2}/README.md

@@ -9,7 +9,7 @@ or across different tools.
 
 ## What it does
 
-- **Discovers sessions** from Claude Code (`~/.claude/projects/`), Claude Desktop, Codex (`~/.codex/state_5.sqlite`), Gemini (`~/.gemini/sessions/`), and altimate-code (`~/.local/share/altimate-code/`)
+- **Discovers sessions** from Claude Code (`~/.claude/projects/`), Claude Desktop, Codex (`~/.codex/state_5.sqlite`), Gemini (`~/.gemini/tmp/<project_hash>/chats/`), and altimate-code (`~/.local/share/altimate-code/`)
 - **Generates summaries** of what each session accomplished (with optional Claude API integration)
 - **Compacts context** intelligently, reducing multi-turn conversations to a token-efficient ContextBundle
 - **Transfers context** across tools and sessions (Claude Code → Codex, Codex → altimate-code, etc.)
@@ -139,7 +139,7 @@ The method is chosen automatically based on token count and whether a target ses
 | Claude Code (CLI) | `~/.claude/projects/` JSONL | `--system-prompt` / `--resume` |
 | Claude Desktop | `~/Library/Application Support/Claude/local-agent-mode-sessions/` | `--system-prompt` |
 | Codex | `~/.codex/state_5.sqlite` | `resume` / `fork` |
-| Gemini | `~/.gemini/sessions/` JSONL | `exec` / `resume` / `fork` |
+| Gemini | `~/.gemini/tmp/<project_hash>/chats/` JSON | New session / `/resume` |
 | altimate-code | `~/.local/share/altimate-code/opencode.db` | `run -s` / `import` |
 
 ## Session Summaries

{context_forge_cli-0.2.0 → context_forge_cli-0.2.2}/contextforge/adapters/altimate_code.py

@@ -117,6 +117,7 @@ class AltimateCodeAdapter(ToolAdapter):
                             role=current_role,
                             content=content,
                             timestamp=current_ts,
+                            token_count=_count_tokens(content),
                         )
                     )
             current_role = None
@@ -157,7 +158,7 @@ class AltimateCodeAdapter(ToolAdapter):
         messages = self.load_messages(session_id)
         total = 0
         for msg in messages:
-            total += _count_tokens(msg.content)
+            total += msg.token_count or _count_tokens(msg.content)
         return total
 
     def build_inject_command(

{context_forge_cli-0.2.0 → context_forge_cli-0.2.2}/contextforge/adapters/claude_code.py

@@ -333,6 +333,7 @@ class ClaudeCodeAdapter(ToolAdapter):
                         role="user" if role == "user" else "assistant",
                         content=content,
                         timestamp=ts,
+                        token_count=_count_tokens(content),
                     )
                 )
 
@@ -340,35 +341,11 @@ class ClaudeCodeAdapter(ToolAdapter):
 
     def _count_session_tokens(self, jsonl_path: Path) -> int:
         """Count total tokens in a session JSONL file."""
+        session_id = jsonl_path.stem
+        messages = self.load_messages(session_id)
         total = 0
-        try:
-            with jsonl_path.open() as f:
-                for line in f:
-                    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 ("user", "assistant"):
-                        continue
-
-                    msg_data = entry.get("message", {})
-                    content_raw = msg_data.get("content", "")
-
-                    # Skip tool-result-only arrays (not actual user/assistant content)
-                    if isinstance(content_raw, list):
-                        if not any(block.get("type") == "text" for block in content_raw if isinstance(block, dict)):
-                            continue
-
-                    content = _parse_content(content_raw)
-                    if content:
-                        total += _count_tokens(content)
-        except Exception:
-            pass
+        for msg in messages:
+            total += msg.token_count or _count_tokens(msg.content)
         return total
 
     def build_inject_command(

{context_forge_cli-0.2.0 → context_forge_cli-0.2.2}/contextforge/adapters/claude_desktop.py

@@ -240,8 +240,12 @@ class ClaudeDesktopAdapter(ToolAdapter):
                         pass
 
                 messages.append(
-                    Message(role="user" if role == "user" else "assistant",
-                            content=content, timestamp=ts)
+                    Message(
+                        role="user" if role == "user" else "assistant",
+                        content=content,
+                        timestamp=ts,
+                        token_count=_count_tokens(content),
+                    )
                 )
         return messages
 
@@ -279,7 +283,12 @@ class ClaudeDesktopAdapter(ToolAdapter):
                     except (ValueError, AttributeError):
                         pass
 
-                messages.append(Message(role=role, content=content, timestamp=ts))
+                messages.append(Message(
+                    role=role,
+                    content=content,
+                    timestamp=ts,
+                    token_count=_count_tokens(content),
+                ))
         return messages
 
     def _count_session_tokens(self, session_id: str) -> int:
@@ -287,7 +296,7 @@ class ClaudeDesktopAdapter(ToolAdapter):
         messages = self.load_messages(session_id)
         total = 0
         for msg in messages:
-            total += _count_tokens(msg.content)
+            total += msg.token_count or _count_tokens(msg.content)
         return total
 
     def build_inject_command(

{context_forge_cli-0.2.0 → context_forge_cli-0.2.2}/contextforge/adapters/codex.py

@@ -7,6 +7,8 @@ import sqlite3
 from datetime import datetime, timezone
 from pathlib import Path
 
+import tiktoken
+
 from contextforge.adapters.base import ToolAdapter
 from contextforge.models.session import Message, Session
 
@@ -29,6 +31,16 @@ _CODEX_SESSIONS_DIR = Path.home() / ".codex" / "sessions"
 _SESSION_INDEX = Path.home() / ".codex" / "session_index.jsonl"
 
 
+def _count_tokens(text: str) -> int:
+    """Count tokens in text using tiktoken for Claude models."""
+    try:
+        enc = tiktoken.encoding_for_model("claude-3-5-sonnet-20241022")
+        return len(enc.encode(text))
+    except Exception:
+        # Fallback: rough estimate (~4 chars per token)
+        return len(text) // 4
+
+
 class CodexAdapter(ToolAdapter):
     tool_name = "codex"
     default_paths = [_CODEX_DB, _CODEX_SESSIONS_DIR]
@@ -193,11 +205,21 @@ class CodexAdapter(ToolAdapter):
                     if msg_type == "user_message":
                         text = payload.get("message", "")
                         if text:
-                            messages.append(Message(role="user", content=str(text)))
+                            text_str = str(text)
+                            messages.append(Message(
+                                role="user",
+                                content=text_str,
+                                token_count=_count_tokens(text_str),
+                            ))
                     elif msg_type == "agent_message":
                         text = payload.get("message", "")
                         if text:
-                            messages.append(Message(role="assistant", content=str(text)))
+                            text_str = str(text)
+                            messages.append(Message(
+                                role="assistant",
+                                content=text_str,
+                                token_count=_count_tokens(text_str),
+                            ))
 
         return messages
 

context_forge_cli-0.2.2/contextforge/adapters/gemini.py

@@ -0,0 +1,201 @@
+"""Adapter for Google Gemini CLI sessions."""
+from __future__ import annotations
+
+import json
+import shlex
+from datetime import datetime, timezone
+from pathlib import Path
+
+import tiktoken
+
+from contextforge.adapters.base import ToolAdapter
+from contextforge.models.session import Message, Session
+
+_GEMINI_TMP_BASE = Path.home() / ".gemini" / "tmp"
+
+
+def _count_tokens(text: str) -> int:
+    """Count tokens in text using tiktoken for Claude models."""
+    try:
+        enc = tiktoken.encoding_for_model("claude-3-5-sonnet-20241022")
+        return len(enc.encode(text))
+    except Exception:
+        # Fallback: rough estimate (~4 chars per token)
+        return len(text) // 4
+
+
+class GeminiAdapter(ToolAdapter):
+    tool_name = "gemini"
+    default_paths = [_GEMINI_TMP_BASE]
+
+    def discover_sessions(self) -> list[Session]:
+        """Discover Gemini sessions from ~/.gemini/tmp/<project_hash>/chats/."""
+        sessions: list[Session] = []
+
+        if not _GEMINI_TMP_BASE.exists():
+            return sessions
+
+        # Scan all project hash directories
+        for project_dir in _GEMINI_TMP_BASE.iterdir():
+            if not project_dir.is_dir():
+                continue
+
+            chats_dir = project_dir / "chats"
+            if not chats_dir.exists():
+                continue
+
+            # Scan for session JSON files in format: session-<timestamp>-<hash>.json
+            for session_file in sorted(chats_dir.glob("session-*.json")):
+                try:
+                    with session_file.open() as f:
+                        data = json.load(f)
+                except (json.JSONDecodeError, OSError):
+                    continue
+
+                session_id = data.get("sessionId")
+                if not session_id:
+                    continue
+
+                # Extract timestamps
+                start_time_str = data.get("startTime")
+                last_updated_str = data.get("lastUpdated")
+
+                created_at = None
+                updated_at = None
+
+                if start_time_str:
+                    try:
+                        created_at = datetime.fromisoformat(
+                            start_time_str.replace("Z", "+00:00")
+                        )
+                    except (ValueError, AttributeError):
+                        pass
+
+                if last_updated_str:
+                    try:
+                        updated_at = datetime.fromisoformat(
+                            last_updated_str.replace("Z", "+00:00")
+                        )
+                    except (ValueError, AttributeError):
+                        pass
+
+                if created_at is None:
+                    created_at = datetime.now(timezone.utc)
+                if updated_at is None:
+                    updated_at = created_at
+
+                # Extract title from first user message
+                title = None
+                messages = data.get("messages", [])
+                for msg in messages:
+                    if msg.get("type") == "user":
+                        content = msg.get("content", [])
+                        if isinstance(content, list) and content:
+                            text = content[0].get("text", "")
+                            if text:
+                                title = text[:100]
+                                break
+
+                sessions.append(
+                    Session(
+                        id=session_id,
+                        tool=self.tool_name,
+                        title=title,
+                        cwd=None,
+                        created_at=created_at,
+                        updated_at=updated_at,
+                        raw_path=str(session_file),
+                        status="unknown",
+                    )
+                )
+
+        return sessions
+
+    def load_messages(self, session_id: str) -> list[Message]:
+        """Load messages for a given session ID by scanning all projects."""
+        if not _GEMINI_TMP_BASE.exists():
+            return []
+
+        # Brute-force search across all projects to find the session
+        for project_dir in _GEMINI_TMP_BASE.iterdir():
+            if not project_dir.is_dir():
+                continue
+
+            chats_dir = project_dir / "chats"
+            if not chats_dir.exists():
+                continue
+
+            for session_file in chats_dir.glob("session-*.json"):
+                try:
+                    with session_file.open() as f:
+                        data = json.load(f)
+                except (json.JSONDecodeError, OSError):
+                    continue
+
+                if data.get("sessionId") == session_id:
+                    return self._parse_session_data(data)
+
+        return []
+
+    def _parse_session_data(self, data: dict) -> list[Message]:
+        """Parse Gemini session JSON object into Message list."""
+        messages: list[Message] = []
+
+        for msg in data.get("messages", []):
+            msg_type = msg.get("type", "")
+            if msg_type not in ("user", "gemini"):
+                continue
+
+            # Extract content
+            content_raw = msg.get("content", "")
+            if isinstance(content_raw, list):
+                # User messages: content is list of {text: ...}
+                parts = []
+                for item in content_raw:
+                    if isinstance(item, dict) and "text" in item:
+                        parts.append(item["text"])
+                content = " ".join(parts)
+            else:
+                # Gemini messages: content is a string
+                content = str(content_raw)
+
+            if not content or not content.strip():
+                continue
+
+            ts_str = msg.get("timestamp")
+            ts = None
+            if ts_str:
+                try:
+                    ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+                except (ValueError, AttributeError):
+                    pass
+
+            messages.append(
+                Message(
+                    role="user" if msg_type == "user" else "assistant",
+                    content=content,
+                    timestamp=ts,
+                    token_count=_count_tokens(content),
+                )
+            )
+
+        return messages
+
+    def build_inject_command(
+        self,
+        context: str,
+        target_session_id: str | None = None,
+        cwd: str | None = None,
+        method: str = "system_prompt",
+    ) -> str:
+        """Build a shell command to start/resume a Gemini session with context."""
+        safe_ctx = shlex.quote(context)
+
+        if method == "resume" and target_session_id:
+            return f"gemini /resume {target_session_id}"
+
+        # Default: new session with context injected via system prompt
+        cmd = f"gemini {safe_ctx}"
+        if cwd:
+            cmd = f"cd {shlex.quote(cwd)} && {cmd}"
+        return cmd

{context_forge_cli-0.2.0 → context_forge_cli-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "context-forge-cli"
-version = "0.2.0"
+version = "0.2.2"
 description = "Session manager and context bridge for agentic CLI tools"
 readme = "README.md"
 license = { text = "MIT" }

{context_forge_cli-0.2.0 → context_forge_cli-0.2.2}/uv.lock

@@ -151,8 +151,8 @@ wheels = [
 ]
 
 [[package]]
-name = "context-forge"
-version = "0.1.0"
+name = "context-forge-cli"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "anthropic" },

context_forge_cli-0.2.0/contextforge/adapters/gemini.py

@@ -1,203 +0,0 @@
-"""Adapter for Google Gemini CLI sessions."""
-from __future__ import annotations
-
-import json
-import shlex
-from datetime import datetime, timezone
-from pathlib import Path
-
-from contextforge.adapters.base import ToolAdapter
-from contextforge.models.session import Message, Session
-
-_GEMINI_HISTORY_PATH = Path.home() / ".gemini" / "history.jsonl"
-_GEMINI_SESSIONS_DIR = Path.home() / ".gemini" / "sessions"
-
-
-class GeminiAdapter(ToolAdapter):
-    tool_name = "gemini"
-    default_paths = [_GEMINI_HISTORY_PATH, _GEMINI_SESSIONS_DIR]
-
-    def discover_sessions(self) -> list[Session]:
-        """Discover Gemini sessions from history and sessions directory."""
-        sessions: list[Session] = []
-
-        # Try to load from sessions directory first
-        if _GEMINI_SESSIONS_DIR.exists():
-            sessions = self._scan_sessions_dir()
-
-        # Fall back to history.jsonl if no sessions directory
-        if not sessions and _GEMINI_HISTORY_PATH.exists():
-            sessions = self._from_history()
-
-        return sessions
-
-    def _scan_sessions_dir(self) -> list[Session]:
-        """Scan the Gemini sessions directory for session files."""
-        sessions: list[Session] = []
-
-        if not _GEMINI_SESSIONS_DIR.exists():
-            return sessions
-
-        for session_file in sorted(_GEMINI_SESSIONS_DIR.glob("*.jsonl")):
-            session_id = session_file.stem
-            mtime = session_file.stat().st_mtime
-            dt = datetime.fromtimestamp(mtime, tz=timezone.utc)
-
-            # Try to extract title from first few lines
-            title = None
-            try:
-                with session_file.open() as f:
-                    for line in f:
-                        try:
-                            entry = json.loads(line)
-                            if entry.get("type") == "user" and not title:
-                                content = entry.get("message", {}).get("content", "")
-                                if isinstance(content, str):
-                                    title = content[:100]  # First 100 chars as title
-                                break
-                        except json.JSONDecodeError:
-                            pass
-            except Exception:
-                pass
-
-            sessions.append(
-                Session(
-                    id=session_id,
-                    tool=self.tool_name,
-                    title=title,
-                    cwd=None,
-                    created_at=dt,
-                    updated_at=dt,
-                    raw_path=str(session_file),
-                    status="unknown",
-                )
-            )
-
-        return sessions
-
-    def _from_history(self) -> list[Session]:
-        """Load sessions from history.jsonl file."""
-        sessions: list[Session] = []
-        seen: set[str] = set()
-
-        if not _GEMINI_HISTORY_PATH.exists():
-            return sessions
-
-        with _GEMINI_HISTORY_PATH.open() as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    entry = json.loads(line)
-                except json.JSONDecodeError:
-                    continue
-
-                session_id = entry.get("session_id") or entry.get("sessionId")
-                if not session_id or session_id in seen:
-                    continue
-                seen.add(session_id)
-
-                title = entry.get("title") or entry.get("display")
-                ts = entry.get("timestamp")
-
-                try:
-                    dt = datetime.fromisoformat(str(ts).replace("Z", "+00:00"))
-                except (ValueError, AttributeError, TypeError):
-                    dt = datetime.now(timezone.utc)
-
-                sessions.append(
-                    Session(
-                        id=session_id,
-                        tool=self.tool_name,
-                        title=title,
-                        cwd=None,
-                        created_at=dt,
-                        updated_at=dt,
-                        raw_path=None,
-                        status="unknown",
-                    )
-                )
-
-        return sessions
-
-    def load_messages(self, session_id: str) -> list[Message]:
-        """Load messages for a given session ID."""
-        # Try to find session file
-        if _GEMINI_SESSIONS_DIR.exists():
-            session_file = _GEMINI_SESSIONS_DIR / f"{session_id}.jsonl"
-            if session_file.exists():
-                return self._parse_session_file(session_file)
-
-        return []
-
-    def _parse_session_file(self, path: Path) -> list[Message]:
-        """Parse a Gemini session JSONL file."""
-        messages: list[Message] = []
-
-        try:
-            with path.open() as f:
-                for line in f:
-                    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 ("user", "assistant"):
-                        continue
-
-                    msg_data = entry.get("message", {})
-                    content = msg_data.get("content", "")
-
-                    if not content:
-                        continue
-
-                    # Handle both string and list content formats
-                    if isinstance(content, list):
-                        content = " ".join(str(item) for item in content if item)
-
-                    ts_str = entry.get("timestamp")
-                    ts = None
-                    if ts_str:
-                        try:
-                            ts = datetime.fromisoformat(str(ts_str).replace("Z", "+00:00"))
-                        except (ValueError, AttributeError, TypeError):
-                            pass
-
-                    messages.append(
-                        Message(
-                            role="user" if entry_type == "user" else "assistant",
-                            content=str(content),
-                            timestamp=ts,
-                        )
-                    )
-        except Exception:
-            pass
-
-        return messages
-
-    def build_inject_command(
-        self,
-        context: str,
-        target_session_id: str | None = None,
-        cwd: str | None = None,
-        method: str = "system_prompt",
-    ) -> str:
-        """Build a shell command to start/resume a Gemini session with context."""
-        safe_ctx = shlex.quote(context)
-
-        if method == "resume" and target_session_id:
-            return f"gemini resume {target_session_id} {safe_ctx}"
-
-        if method == "fork" and target_session_id:
-            return f"gemini fork {target_session_id} {safe_ctx}"
-
-        # Default: new session
-        cmd = f"gemini exec {safe_ctx}"
-        if cwd:
-            cmd = f"cd {shlex.quote(cwd)} && {cmd}"
-        return cmd