context-forge-cli 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

{context_forge_cli-0.2.0.dist-info → context_forge_cli-0.2.2.dist-info}/METADATA

@@ -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.dist-info → context_forge_cli-0.2.2.dist-info}/RECORD

@@ -1,12 +1,12 @@
 contextforge/__init__.py,sha256=L5NnW7jpnDQrAhnqTWSzW-bk2Bp8TXpFK1-SmQXI2QE,104
 contextforge/cli.py,sha256=OIHjV_pL4fKCvnn-2bQwza8NOUplptSfASPg4yzQmjA,18685
 contextforge/adapters/__init__.py,sha256=HGIFdC_tNpX_QOPrePwU5cEVBhp3Hsh6Sihwb23HdTk,171
-contextforge/adapters/altimate_code.py,sha256=aFo3FvO6XdN8eORnU_F8PbEB7rTTB2quIyU381AHE1E,5967
+contextforge/adapters/altimate_code.py,sha256=_buMKoFP8YSqtElPHwmsJicse85OydwoX1t94JC8BDI,6050
 contextforge/adapters/base.py,sha256=q3_pn0XoDV_r2GkuSzuRof0SSqynHqiaCAe4piq3tGs,1355
-contextforge/adapters/claude_code.py,sha256=RcFucjQGuDztU_BFVdm-O7mQ12FHFSD6y9AUrYJg4X4,15315
-contextforge/adapters/claude_desktop.py,sha256=uXJgMt2BdbhkwU9DMXhik--kb-RNKqxTdMc4Z9O-9lc,11957
-contextforge/adapters/codex.py,sha256=WhLHOyZZM4KI-G2hEvsqq9PYOjuCyI2Zo8S9ircZtf8,8005
-contextforge/adapters/gemini.py,sha256=maTuHg9XhHimBCvcaRQ2X7InqrEI3PIi2LVCFY3hcXQ,7007
+contextforge/adapters/claude_code.py,sha256=Oes23vjRRv7Js0BaZvScZNDpyaItlwPEWKwsyL6Zj60,14453
+contextforge/adapters/claude_desktop.py,sha256=P0fI3Tg00bX8MifV09I1iRPqk-6m5w1kpllCW7Bc2hg,12238
+contextforge/adapters/codex.py,sha256=yj0Sdzo8yrkQHSqfCxq-NxXuaiaUOSlnZOTIAOQw-gU,8776
+contextforge/adapters/gemini.py,sha256=757prqt5_AILxFm53CEfhlqjFKlxVs-YmLBImt8Aj1M,6844
 contextforge/adapters/registry.py,sha256=kbasRJE4WBJ8qw7VGENgjp8NDS3jyIHo8wpGxjk9srs,1177
 contextforge/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 contextforge/core/analytics.py,sha256=qffm7oqfmosU6XPUftbf68AOvDrylrxBR4rJyLhvoXU,7056
@@ -32,7 +32,7 @@ contextforge/tui/widgets/transfer_panel.py,sha256=Qrgkt1-MpzRHWuwNyu2ErM26IRl0ya
 contextforge/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 contextforge/utils/display.py,sha256=bagZgpZ6WGki2THNHA8lfg9ITqM8W0q_M6Os-pgwFHk,3111
 contextforge/utils/tokens.py,sha256=UVGz-vvmCIxMgnRPn1T53v2ZdKMmxKhoJcc1qbmjpDQ,414
-context_forge_cli-0.2.0.dist-info/METADATA,sha256=XzPmavHPsItycsFQJ75Wu8UaxVsleh338N1_ukaJZMU,12803
-context_forge_cli-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-context_forge_cli-0.2.0.dist-info/entry_points.txt,sha256=nPN0PWb85KCPXqFp4opmBsNejdCHyl7rK_cREsu4r7A,44
-context_forge_cli-0.2.0.dist-info/RECORD,,
+context_forge_cli-0.2.2.dist-info/METADATA,sha256=PixJa-FTRNZSUIxXHuah7o_1Z2QlzaSNkUqGyoe-5-g,12831
+context_forge_cli-0.2.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+context_forge_cli-0.2.2.dist-info/entry_points.txt,sha256=nPN0PWb85KCPXqFp4opmBsNejdCHyl7rK_cREsu4r7A,44
+context_forge_cli-0.2.2.dist-info/RECORD,,

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(

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(

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(

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
 

contextforge/adapters/gemini.py

@@ -6,105 +6,95 @@ 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_HISTORY_PATH = Path.home() / ".gemini" / "history.jsonl"
-_GEMINI_SESSIONS_DIR = Path.home() / ".gemini" / "sessions"
+_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_HISTORY_PATH, _GEMINI_SESSIONS_DIR]
+    default_paths = [_GEMINI_TMP_BASE]
 
     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."""
+        """Discover Gemini sessions from ~/.gemini/tmp/<project_hash>/chats/."""
         sessions: list[Session] = []
 
-        if not _GEMINI_SESSIONS_DIR.exists():
+        if not _GEMINI_TMP_BASE.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()
+        # Scan all project hash directories
+        for project_dir in _GEMINI_TMP_BASE.iterdir():
+            if not project_dir.is_dir():
+                continue
 
-        if not _GEMINI_HISTORY_PATH.exists():
-            return sessions
+            chats_dir = project_dir / "chats"
+            if not chats_dir.exists():
+                continue
 
-        with _GEMINI_HISTORY_PATH.open() as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
+            # Scan for session JSON files in format: session-<timestamp>-<hash>.json
+            for session_file in sorted(chats_dir.glob("session-*.json")):
                 try:
-                    entry = json.loads(line)
-                except json.JSONDecodeError:
+                    with session_file.open() as f:
+                        data = json.load(f)
+                except (json.JSONDecodeError, OSError):
                     continue
 
-                session_id = entry.get("session_id") or entry.get("sessionId")
-                if not session_id or session_id in seen:
+                session_id = data.get("sessionId")
+                if not session_id:
                     continue
-                seen.add(session_id)
 
-                title = entry.get("title") or entry.get("display")
-                ts = entry.get("timestamp")
+                # Extract timestamps
+                start_time_str = data.get("startTime")
+                last_updated_str = data.get("lastUpdated")
 
-                try:
-                    dt = datetime.fromisoformat(str(ts).replace("Z", "+00:00"))
-                except (ValueError, AttributeError, TypeError):
-                    dt = datetime.now(timezone.utc)
+                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(
@@ -112,9 +102,9 @@ class GeminiAdapter(ToolAdapter):
                         tool=self.tool_name,
                         title=title,
                         cwd=None,
-                        created_at=dt,
-                        updated_at=dt,
-                        raw_path=None,
+                        created_at=created_at,
+                        updated_at=updated_at,
+                        raw_path=str(session_file),
                         status="unknown",
                     )
                 )
@@ -122,61 +112,72 @@ class GeminiAdapter(ToolAdapter):
         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)
+        """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_file(self, path: Path) -> list[Message]:
-        """Parse a Gemini session JSONL file."""
+    def _parse_session_data(self, data: dict) -> list[Message]:
+        """Parse Gemini session JSON object into Message list."""
         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
+        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
 
@@ -191,13 +192,10 @@ class GeminiAdapter(ToolAdapter):
         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}"
+            return f"gemini /resume {target_session_id}"
 
-        # Default: new session
-        cmd = f"gemini exec {safe_ctx}"
+        # 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