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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: context-forge-cli
-Version: 0.2.2
+Version: 0.2.5
 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

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

@@ -25,6 +25,16 @@ def _count_tokens(text: str) -> int:
         return len(text) // 4
 
 
+def _compute_message_tokens(msg) -> int:
+    """Count tokens across all content: text + tool_call inputs + tool_result outputs."""
+    total = _count_tokens(msg.content)
+    for tc in msg.tool_calls:
+        total += _count_tokens(tc.get("input", ""))
+    for tr in msg.tool_results:
+        total += _count_tokens(tr.get("output", ""))
+    return total
+
+
 class AltimateCodeAdapter(ToolAdapter):
     tool_name = "altimate_code"
     default_paths = [_OPENCODE_DB]
@@ -86,14 +96,22 @@ class AltimateCodeAdapter(ToolAdapter):
             conn = sqlite3.connect(str(_OPENCODE_DB))
             conn.row_factory = sqlite3.Row
             cur = conn.cursor()
-            # Join message + part to get full content
             cur.execute(
                 """
-                SELECT m.role, p.type as part_type, p.content, m.time as ts
+                SELECT
+                    m.id,
+                    json_extract(m.data, '$.role') as role,
+                    m.time_created as ts,
+                    json_extract(p.data, '$.type') as part_type,
+                    json_extract(p.data, '$.text') as text_content,
+                    json_extract(p.data, '$.tool') as tool_name,
+                    json_extract(p.data, '$.callID') as call_id,
+                    json_extract(p.data, '$.state.input') as tool_input,
+                    json_extract(p.data, '$.state.output') as tool_output
                 FROM message m
                 LEFT JOIN part p ON p.message_id = m.id
                 WHERE m.session_id = ?
-                ORDER BY m.time ASC, p.id ASC
+                ORDER BY m.time_created ASC, p.id ASC
                 """,
                 (session_id,),
             )
@@ -103,34 +121,43 @@ class AltimateCodeAdapter(ToolAdapter):
             return []
 
         messages: list[Message] = []
+        current_msg_id: str | None = None
         current_role: str | None = None
         current_parts: list[str] = []
+        current_tool_calls: list[dict] = []
+        current_tool_results: list[dict] = []
         current_ts: datetime | None = None
 
         def flush():
-            nonlocal current_role, current_parts, current_ts
-            if current_role and current_parts:
+            nonlocal current_msg_id, current_role, current_parts, current_ts
+            nonlocal current_tool_calls, current_tool_results
+            if current_role and (current_parts or current_tool_calls):
                 content = "\n".join(p for p in current_parts if p)
-                if content:
-                    messages.append(
-                        Message(
-                            role=current_role,
-                            content=content,
-                            timestamp=current_ts,
-                            token_count=_count_tokens(content),
-                        )
-                    )
+                msg = Message(
+                    role=current_role,
+                    content=content,
+                    timestamp=current_ts,
+                    tool_calls=list(current_tool_calls),
+                    tool_results=list(current_tool_results),
+                )
+                msg.token_count = _compute_message_tokens(msg)
+                messages.append(msg)
+            current_msg_id = None
             current_role = None
             current_parts = []
+            current_tool_calls = []
+            current_tool_results = []
             current_ts = None
 
         for row in rows:
+            msg_id = row["id"]
             role = row["role"]
             if role not in ("user", "assistant"):
                 continue
 
-            if role != current_role:
+            if msg_id != current_msg_id:
                 flush()
+                current_msg_id = msg_id
                 current_role = role
                 try:
                     current_ts = datetime.fromtimestamp(row["ts"] / 1000, tz=timezone.utc)
@@ -138,28 +165,36 @@ class AltimateCodeAdapter(ToolAdapter):
                     current_ts = None
 
             part_type = row["part_type"] or ""
-            content = row["content"] or ""
 
-            if part_type in ("text", "reasoning") and content:
-                if isinstance(content, str):
+            if part_type in ("text", "reasoning"):
+                content = row["text_content"] or ""
+                if isinstance(content, str) and content:
                     try:
                         parsed = json.loads(content)
                         if isinstance(parsed, dict):
                             content = parsed.get("text", str(parsed))
                     except (json.JSONDecodeError, TypeError):
                         pass
-                current_parts.append(str(content).strip())
+                    content = str(content).strip()
+                    if content:
+                        current_parts.append(content)
+
+            elif part_type == "tool":
+                tool_name = row["tool_name"] or "?"
+                tool_input = row["tool_input"] or ""
+                tool_output = row["tool_output"] or ""
+                # input from json_extract is already a JSON string; keep as-is for token counting
+                current_tool_calls.append({"name": tool_name, "input": tool_input})
+                if tool_output:
+                    current_tool_results.append({"output": tool_output})
 
         flush()
         return messages
 
     def _count_session_tokens(self, session_id: str) -> int:
-        """Count total tokens in a session."""
+        """Count total tokens in a session (text + tool inputs + tool outputs)."""
         messages = self.load_messages(session_id)
-        total = 0
-        for msg in messages:
-            total += msg.token_count or _count_tokens(msg.content)
-        return total
+        return sum(msg.token_count or _compute_message_tokens(msg) for msg in messages)
 
     def build_inject_command(
         self,

{context_forge_cli-0.2.2 → context_forge_cli-0.2.5}/contextforge/adapters/base.py

@@ -5,6 +5,7 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 
 from contextforge.models.session import Message, Session
+from contextforge.utils.tokens import count_tokens
 
 
 class ToolAdapter(ABC):
@@ -42,3 +43,17 @@ class ToolAdapter(ABC):
     def is_available(self) -> bool:
         """Return True if this tool is installed and its data paths exist."""
         return any(p.exists() for p in self.default_paths)
+
+    def _count_session_tokens(self, session_id: str | Path) -> int:
+        """Count total tokens in a session by loading and summing message tokens.
+
+        This is the default implementation that all adapters can use.
+        Adapters may override this with more efficient implementations.
+        """
+        if isinstance(session_id, Path):
+            session_id = session_id.stem
+        messages = self.load_messages(str(session_id))
+        total = 0
+        for msg in messages:
+            total += msg.token_count or count_tokens(msg.content)
+        return total

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

@@ -64,6 +64,16 @@ def _count_tokens(text: str) -> int:
         return len(text) // 4
 
 
+def _compute_message_tokens(msg: Message) -> int:
+    """Count tokens across all content in a message: text + tool_call inputs + tool_result outputs."""
+    total = _count_tokens(msg.content)
+    for tc in msg.tool_calls:
+        total += _count_tokens(tc.get("input", ""))
+    for tr in msg.tool_results:
+        total += _count_tokens(tr.get("output", ""))
+    return total
+
+
 class ClaudeCodeAdapter(ToolAdapter):
     tool_name = "claude_code"
     default_paths = [_HISTORY_PATH, _PROJECTS_DIR]
@@ -309,17 +319,6 @@ class ClaudeCodeAdapter(ToolAdapter):
                 role = msg_data.get("role", entry_type)
                 content_raw = msg_data.get("content", "")
 
-                # Skip entries where content is an array of tool results/tool use
-                # (these are Claude's internal messages, not user input or assistant responses)
-                if isinstance(content_raw, list):
-                    # Only include arrays that contain text blocks (actual assistant content)
-                    if not any(block.get("type") == "text" for block in content_raw if isinstance(block, dict)):
-                        continue
-
-                content = _parse_content(content_raw)
-                if not content:
-                    continue
-
                 ts_str = entry.get("timestamp")
                 ts = None
                 if ts_str:
@@ -328,20 +327,76 @@ class ClaudeCodeAdapter(ToolAdapter):
                     except (ValueError, AttributeError):
                         pass
 
-                messages.append(
-                    Message(
-                        role="user" if role == "user" else "assistant",
-                        content=content,
-                        timestamp=ts,
-                        token_count=_count_tokens(content),
+                if isinstance(content_raw, list):
+                    has_text = any(
+                        isinstance(b, dict) and b.get("type") == "text"
+                        for b in content_raw
+                    )
+                    has_tool_result = any(
+                        isinstance(b, dict) and b.get("type") == "tool_result"
+                        for b in content_raw
                     )
+
+                    # tool_result-only user entries: attribute their outputs to the
+                    # last assistant turn (the one that issued the tool calls)
+                    if has_tool_result and not has_text:
+                        if messages and messages[-1].role == "assistant":
+                            last = messages[-1]
+                            for block in content_raw:
+                                if not isinstance(block, dict) or block.get("type") != "tool_result":
+                                    continue
+                                inner = block.get("content", "")
+                                if isinstance(inner, list):
+                                    for item in inner:
+                                        if isinstance(item, dict) and item.get("type") == "text":
+                                            output = item.get("text", "")
+                                            if output:
+                                                last.tool_results.append({"output": output})
+                                elif isinstance(inner, str) and inner:
+                                    last.tool_results.append({"output": inner})
+                            # Recompute token_count now that tool_results have been added
+                            last.token_count = _compute_message_tokens(last)
+                        continue
+
+                    # Extract tool_call entries from assistant content arrays
+                    tool_calls: list[dict] = []
+                    if role != "user":
+                        for block in content_raw:
+                            if not isinstance(block, dict) or block.get("type") != "tool_use":
+                                continue
+                            try:
+                                input_str = json.dumps(block.get("input", {}))
+                            except (TypeError, ValueError):
+                                input_str = ""
+                            tool_calls.append({"name": block.get("name", "?"), "input": input_str})
+                else:
+                    tool_calls = []
+
+                content = _parse_content(content_raw)
+                if not content and not tool_calls:
+                    continue
+
+                msg = Message(
+                    role="user" if role == "user" else "assistant",
+                    content=content,
+                    timestamp=ts,
+                    tool_calls=tool_calls,
                 )
+                msg.token_count = _compute_message_tokens(msg)
+                messages.append(msg)
 
         return messages
 
-    def _count_session_tokens(self, jsonl_path: Path) -> int:
-        """Count total tokens in a session JSONL file."""
-        session_id = jsonl_path.stem
+    def _count_session_tokens(self, jsonl_path: Path | str) -> int:
+        """Count total tokens in a session JSONL file or session ID.
+
+        Args:
+            jsonl_path: Either a Path to the JSONL file or a session ID string.
+        """
+        if isinstance(jsonl_path, str):
+            session_id = jsonl_path
+        else:
+            session_id = jsonl_path.stem
         messages = self.load_messages(session_id)
         total = 0
         for msg in messages:

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

@@ -41,6 +41,30 @@ def _count_tokens(text: str) -> int:
         return len(text) // 4
 
 
+def _compute_message_tokens(msg: Message) -> int:
+    total = _count_tokens(msg.content)
+    for tc in msg.tool_calls:
+        total += _count_tokens(tc.get("input", ""))
+    for tr in msg.tool_results:
+        total += _count_tokens(tr.get("output", ""))
+    return total
+
+
+def _extract_function_output(raw_output: str) -> str:
+    """Extract the human-readable output from a Codex function_call_output payload.
+
+    The `output` field is a JSON string: {"output": "...", "metadata": {...}}.
+    Returns the inner "output" string, or the raw string on parse failure.
+    """
+    try:
+        parsed = json.loads(raw_output)
+        if isinstance(parsed, dict):
+            return str(parsed.get("output", raw_output))
+    except (json.JSONDecodeError, TypeError):
+        pass
+    return raw_output
+
+
 class CodexAdapter(ToolAdapter):
     tool_name = "codex"
     default_paths = [_CODEX_DB, _CODEX_SESSIONS_DIR]
@@ -87,7 +111,10 @@ class CodexAdapter(ToolAdapter):
                     cwd=row["cwd"] or None,
                     created_at=created,
                     updated_at=updated,
-                    token_count=row["tokens_used"],
+                    # tokens_used in state_5.sqlite is cumulative API billing spend
+                    # (re-sends full context each call), NOT conversation footprint.
+                    # Leave token_count=None so cf refresh computes it from rollout content.
+                    token_count=None,
                     raw_path=row["rollout_path"] or None,
                     status="unknown",
                 )
@@ -184,6 +211,31 @@ class CodexAdapter(ToolAdapter):
 
     def _parse_rollout(self, path: Path) -> list[Message]:
         messages: list[Message] = []
+
+        # Pending tool data for the current assistant turn (buffered until
+        # we see the agent_message that closes the turn).
+        pending_tool_calls: list[dict] = []
+        pending_tool_results: list[dict] = []
+
+        def flush_pending_assistant(text: str = "", ts=None):
+            """Emit an assistant message with any buffered tool data."""
+            nonlocal pending_tool_calls, pending_tool_results
+            if not text and not pending_tool_calls:
+                pending_tool_calls = []
+                pending_tool_results = []
+                return
+            msg = Message(
+                role="assistant",
+                content=text,
+                timestamp=ts,
+                tool_calls=list(pending_tool_calls),
+                tool_results=list(pending_tool_results),
+            )
+            msg.token_count = _compute_message_tokens(msg)
+            messages.append(msg)
+            pending_tool_calls = []
+            pending_tool_results = []
+
         with path.open() as f:
             for line in f:
                 line = line.strip()
@@ -196,30 +248,42 @@ class CodexAdapter(ToolAdapter):
 
                 entry_type = entry.get("type", "")
                 payload = entry.get("payload", {})
+                ts_str = entry.get("timestamp")
+                ts = None
+                if ts_str:
+                    try:
+                        ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+                    except (ValueError, AttributeError):
+                        pass
 
                 if entry_type == "event_msg":
                     msg_type = payload.get("type", "")
-                    # user_message / agent_message are the clean human-facing turns.
-                    # response_item entries are skipped — they contain system context
-                    # injections (AGENTS.md, environment_context) and duplicate content.
                     if msg_type == "user_message":
-                        text = payload.get("message", "")
+                        # New user turn — flush any orphaned tool data first
+                        flush_pending_assistant()
+                        text = str(payload.get("message", ""))
                         if text:
-                            text_str = str(text)
-                            messages.append(Message(
-                                role="user",
-                                content=text_str,
-                                token_count=_count_tokens(text_str),
-                            ))
+                            msg = Message(role="user", content=text, timestamp=ts)
+                            msg.token_count = _count_tokens(text)
+                            messages.append(msg)
                     elif msg_type == "agent_message":
-                        text = payload.get("message", "")
-                        if text:
-                            text_str = str(text)
-                            messages.append(Message(
-                                role="assistant",
-                                content=text_str,
-                                token_count=_count_tokens(text_str),
-                            ))
+                        text = str(payload.get("message", ""))
+                        flush_pending_assistant(text=text, ts=ts)
+
+                elif entry_type == "response_item":
+                    item_type = payload.get("type", "")
+                    if item_type == "function_call":
+                        name = payload.get("name", "?")
+                        arguments = payload.get("arguments", "")
+                        pending_tool_calls.append({"name": name, "input": arguments})
+                    elif item_type == "function_call_output":
+                        raw_output = payload.get("output", "")
+                        output = _extract_function_output(raw_output)
+                        if output:
+                            pending_tool_results.append({"output": output})
+
+        # Flush any trailing tool data (e.g. incomplete / aborted turn)
+        flush_pending_assistant()
 
         return messages
 

{context_forge_cli-0.2.2 → context_forge_cli-0.2.5}/contextforge/cli.py

@@ -505,6 +505,79 @@ def config_set(key: str, value: str):
     console.print(f"Would set [bold]{key}[/bold] = [bold]{value}[/bold]")
 
 
+# ---------------------------------------------------------------------------
+# cf refresh
+# ---------------------------------------------------------------------------
+
+@app.command()
+def refresh(
+    quiet: Annotated[bool, typer.Option("--quiet", "-q")] = False,
+):
+    """Refresh token counts and metadata for all sessions.
+
+    Recalculates token_count for every session from source data.
+    Useful after adapter updates or schema changes.
+    """
+    cfg = _get_config()
+    database = _get_db(cfg)
+
+    from contextforge.adapters.registry import get_adapter
+
+    # Get all sessions grouped by tool
+    sessions_by_tool = {}
+    for row in database.execute("SELECT DISTINCT tool FROM sessions ORDER BY tool").fetchall():
+        tool = row[0]
+        sessions_by_tool[tool] = []
+        for s in database.execute("SELECT id, title FROM sessions WHERE tool = ? ORDER BY id", [tool]).fetchall():
+            sessions_by_tool[tool].append((s[0], s[1]))
+
+    from rich.progress import Progress, SpinnerColumn, TextColumn
+
+    total_sessions = sum(len(sessions) for sessions in sessions_by_tool.values())
+    updated_count = 0
+    error_count = 0
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        disable=quiet,
+    ) as progress:
+        task = progress.add_task("Refreshing...", total=total_sessions)
+
+        for tool, sessions in sessions_by_tool.items():
+            if not sessions:
+                continue
+
+            try:
+                adapter = get_adapter(tool)
+            except Exception as e:
+                if not quiet:
+                    err_console.print(f"[yellow]Warning:[/yellow] Skipping {tool}: {e}")
+                error_count += len(sessions)
+                progress.advance(task, len(sessions))
+                continue
+
+            for session_id, title in sessions:
+                try:
+                    token_count = adapter._count_session_tokens(session_id)
+                    database["sessions"].update(session_id, {"token_count": token_count})
+                    updated_count += 1
+                    if not quiet:
+                        progress.update(task, description=f"Refreshed {session_id[:12]} ({token_count:,} tokens)")
+                except Exception as e:
+                    error_count += 1
+                    if not quiet:
+                        err_console.print(f"[yellow]Warning:[/yellow] {session_id}: {e}")
+                finally:
+                    progress.advance(task)
+
+    if not quiet:
+        console.print(
+            f"[green]Refresh complete:[/green] "
+            f"{updated_count} updated" + (f", {error_count} errors" if error_count else "")
+        )
+
+
 # ---------------------------------------------------------------------------
 # cf dashboard
 # ---------------------------------------------------------------------------

{context_forge_cli-0.2.2 → context_forge_cli-0.2.5}/contextforge/core/token_analyzer.py

@@ -18,6 +18,9 @@ class TurnStats:
     tokens: int
     content_preview: str  # first 80 chars, single line
     cumulative: int = 0
+    text_tokens: int = 0
+    tool_call_tokens: int = 0
+    tool_result_tokens: int = 0
 
 
 @dataclass
@@ -26,11 +29,20 @@ class SessionTokenReport:
     tool: str
     title: str
     turns: list[TurnStats] = field(default_factory=list)
+    has_tool_data: bool = False
 
     @property
     def total(self) -> int:
         return sum(t.tokens for t in self.turns)
 
+    @property
+    def tool_call_total(self) -> int:
+        return sum(t.tool_call_tokens for t in self.turns)
+
+    @property
+    def tool_result_total(self) -> int:
+        return sum(t.tool_result_tokens for t in self.turns)
+
     @property
     def user_total(self) -> int:
         return sum(t.tokens for t in self.turns if t.role == "user")
@@ -71,8 +83,14 @@ def analyze_tokens(
 
     turns: list[TurnStats] = []
     cumulative = 0
+    has_tool_data = False
     for i, msg in enumerate(messages, 1):
-        tokens = count_tokens(msg.content)
+        text_tokens = count_tokens(msg.content)
+        tool_call_tokens = sum(count_tokens(tc.get("input", "")) for tc in msg.tool_calls)
+        tool_result_tokens = sum(count_tokens(tr.get("output", "")) for tr in msg.tool_results)
+        tokens = text_tokens + tool_call_tokens + tool_result_tokens
+        if tool_call_tokens or tool_result_tokens:
+            has_tool_data = True
         cumulative += tokens
         preview = msg.content.replace("\n", " ").strip()[:80]
         turns.append(TurnStats(
@@ -81,6 +99,9 @@ def analyze_tokens(
             tokens=tokens,
             content_preview=preview,
             cumulative=cumulative,
+            text_tokens=text_tokens,
+            tool_call_tokens=tool_call_tokens,
+            tool_result_tokens=tool_result_tokens,
         ))
 
     return SessionTokenReport(
@@ -88,4 +109,5 @@ def analyze_tokens(
         tool=row["tool"],
         title=row.get("title") or session_id[:16],
         turns=turns,
+        has_tool_data=has_tool_data,
     )

{context_forge_cli-0.2.2 → context_forge_cli-0.2.5}/contextforge/models/session.py

@@ -11,6 +11,8 @@ class Message(BaseModel):
     content: str
     timestamp: datetime | None = None
     token_count: int | None = None
+    tool_calls: list[dict] = Field(default_factory=list)  # [{name, input}] on assistant turns
+    tool_results: list[dict] = Field(default_factory=list)  # [{output}] attributed to the assistant turn that invoked them
 
 
 class Session(BaseModel):

context_forge_cli-0.2.5/contextforge/tui/widgets/tokens_panel.py

@@ -0,0 +1,290 @@
+"""TokensPanel — modal screen showing per-turn token analysis for a session."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import ScrollableContainer, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import DataTable, Static
+
+from contextforge.models.session import Message
+
+
+class TurnDetailPanel(ModalScreen):
+    """Modal showing the full content of a single turn."""
+
+    BINDINGS = [
+        Binding("escape,q", "dismiss(None)", "Close"),
+    ]
+
+    DEFAULT_CSS = """
+    TurnDetailPanel {
+        align: center middle;
+    }
+    TurnDetailPanel > Vertical {
+        width: 92%;
+        height: 88%;
+        border: thick $accent;
+        background: $surface;
+        padding: 0 1;
+    }
+    TurnDetailPanel #turn-header {
+        height: auto;
+        padding: 1 1 0 1;
+        border-bottom: solid $primary-background-lighten-1;
+        margin-bottom: 1;
+    }
+    TurnDetailPanel ScrollableContainer {
+        height: 1fr;
+        padding: 0 1;
+    }
+    TurnDetailPanel .section-label {
+        color: $text-muted;
+        text-style: bold;
+        margin-top: 1;
+    }
+    TurnDetailPanel .content-block {
+        color: $text;
+        margin-bottom: 1;
+    }
+    TurnDetailPanel .tool-name {
+        color: $warning;
+        text-style: bold;
+    }
+    TurnDetailPanel .tool-input {
+        color: $text-muted;
+        margin-left: 2;
+    }
+    TurnDetailPanel .tool-output {
+        color: $success;
+        margin-left: 2;
+    }
+    TurnDetailPanel #turn-footer {
+        height: 1;
+        color: $text-disabled;
+        text-align: center;
+    }
+    """
+
+    def __init__(self, turn_num: int, msg: Message) -> None:
+        super().__init__()
+        self._turn_num = turn_num
+        self._msg = msg
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static("", id="turn-header")
+            with ScrollableContainer():
+                yield Static("", id="turn-body")
+            yield Static("ESC / q — close", id="turn-footer")
+
+    def on_mount(self) -> None:
+        msg = self._msg
+        role_color = "cyan" if msg.role == "user" else "green"
+
+        self.query_one("#turn-header", Static).update(
+            f"[bold]Turn #{self._turn_num}[/bold]  "
+            f"[{role_color}]{msg.role}[/{role_color}]  "
+            f"[dim]{(msg.token_count or 0):,} tokens[/dim]"
+            + (f"  [yellow]{len(msg.tool_calls)} call(s)[/yellow]" if msg.tool_calls else "")
+            + (f"  [magenta]{len(msg.tool_results)} result(s)[/magenta]" if msg.tool_results else "")
+        )
+
+        parts: list[str] = []
+
+        # ── Text content ────────────────────────────────────────────────────
+        if msg.content:
+            parts.append("[bold dim]── Content ──[/bold dim]")
+            parts.append(msg.content)
+
+        # ── Tool calls ──────────────────────────────────────────────────────
+        if msg.tool_calls:
+            parts.append("\n[bold dim]── Tool Calls ──[/bold dim]")
+            for i, tc in enumerate(msg.tool_calls, 1):
+                name = tc.get("name", "?")
+                raw_input = tc.get("input", "")
+                try:
+                    formatted = json.dumps(json.loads(raw_input), indent=2)
+                except (json.JSONDecodeError, TypeError):
+                    formatted = raw_input
+                parts.append(f"[bold yellow]{i}. {name}[/bold yellow]")
+                parts.append(f"[dim]{formatted}[/dim]")
+
+        # ── Tool results ────────────────────────────────────────────────────
+        if msg.tool_results:
+            parts.append("\n[bold dim]── Tool Results ──[/bold dim]")
+            for i, tr in enumerate(msg.tool_results, 1):
+                output = tr.get("output", "")
+                parts.append(f"[bold green]Result {i}[/bold green]")
+                parts.append(f"[dim]{output}[/dim]")
+
+        self.query_one("#turn-body", Static).update("\n".join(parts))
+
+
+class TokensPanel(ModalScreen):
+    """Full-screen modal showing token breakdown for a session."""
+
+    BINDINGS = [
+        Binding("escape,q", "dismiss(None)", "Close"),
+    ]
+
+    DEFAULT_CSS = """
+    TokensPanel {
+        align: center middle;
+    }
+    TokensPanel > Vertical {
+        width: 90%;
+        height: 85%;
+        border: thick $primary;
+        background: $surface;
+        padding: 0 1;
+    }
+    TokensPanel #tokens-header {
+        height: auto;
+        padding: 1 1 0 1;
+        color: $text;
+    }
+    TokensPanel #tokens-stats {
+        height: auto;
+        padding: 0 1 1 1;
+        color: $text-muted;
+        border-bottom: solid $primary-background-lighten-1;
+        margin-bottom: 1;
+    }
+    TokensPanel DataTable {
+        height: 1fr;
+    }
+    TokensPanel #tokens-footer {
+        height: 1;
+        color: $text-disabled;
+        text-align: center;
+        padding: 0 1;
+    }
+    """
+
+    _BAR_MAX = 24
+
+    def __init__(self, session_id: str, db_path: Path) -> None:
+        super().__init__()
+        self._session_id = session_id
+        self._db_path = db_path
+        self._messages: list[Message] = []
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static("", id="tokens-header")
+            yield Static("", id="tokens-stats")
+            yield DataTable(id="tokens-table", show_cursor=True, zebra_stripes=True, cursor_type="row")
+            yield Static("ESC / q — close  │  Enter — view turn", id="tokens-footer")
+
+    def on_mount(self) -> None:
+        self._load()
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        row_idx = event.cursor_row
+        if 0 <= row_idx < len(self._messages):
+            self.app.push_screen(TurnDetailPanel(row_idx + 1, self._messages[row_idx]))
+
+    def _load(self) -> None:
+        from contextforge.adapters.registry import get_adapter
+        from contextforge.core.db import get_db, get_session
+        from contextforge.core.token_analyzer import analyze_tokens
+
+        db = get_db(self._db_path)
+        report = analyze_tokens(db, self._session_id)
+
+        # Load messages so TurnDetailPanel can show full content
+        row = get_session(db, self._session_id)
+        if row is not None:
+            try:
+                adapter = get_adapter(row["tool"])
+                self._messages = adapter.load_messages(self._session_id)
+            except Exception:
+                self._messages = []
+
+        header = self.query_one("#tokens-header", Static)
+        stats = self.query_one("#tokens-stats", Static)
+        table = self.query_one("#tokens-table", DataTable)
+
+        if report is None or not report.turns:
+            header.update("[bold red]No token data available.[/bold red]")
+            return
+
+        # ── Header ──────────────────────────────────────────────────────────
+        header.update(
+            f"[bold accent]Token Analysis[/bold accent]  "
+            f"[dim]{report.title[:60]}[/dim]  "
+            f"[dim]{report.tool}[/dim]"
+        )
+
+        # ── Stats bar ───────────────────────────────────────────────────────
+        max_t = report.max_turn
+        tool_summary = ""
+        if report.has_tool_data:
+            tool_summary = (
+                f"  │  [yellow]Calls {report.tool_call_total:,}[/yellow]"
+                f"  [magenta]Results {report.tool_result_total:,}[/magenta]"
+            )
+        stats.update(
+            f"Total [bold]{report.total:,}[/bold] tokens  │  "
+            f"[cyan]User {report.user_total:,}[/cyan] (avg {report.avg_user:,.0f})  │  "
+            f"[green]Asst {report.assistant_total:,}[/green] (avg {report.avg_assistant:,.0f})  │  "
+            f"{report.turn_count} turns"
+            + tool_summary
+            + (f"  │  Heaviest: turn #{max_t.turn} "
+               f"[bold]{max_t.tokens:,}[/bold] tok [{max_t.role}]"
+               if max_t else "")
+        )
+
+        # ── Table ────────────────────────────────────────────────────────────
+        if report.has_tool_data:
+            table.add_columns("#", "Role", "Tokens", "Text", "Calls", "Results", "Cumul.", "Bar", "Preview")
+        else:
+            table.add_columns("#", "Role", "Tokens", "Cumul.", "Bar", "Preview")
+
+        max_tokens = max(t.tokens for t in report.turns)
+
+        for t in report.turns:
+            bar_len = max(1, int(t.tokens / max_tokens * self._BAR_MAX))
+
+            if t.role == "user":
+                role_str = "[cyan]user[/cyan]"
+                bar_str = f"[cyan]{'█' * bar_len}[/cyan]"
+            elif t.role == "assistant":
+                role_str = "[green]asst[/green]"
+                bar_str = f"[green]{'█' * bar_len}[/green]"
+            else:
+                role_str = f"[dim]{t.role}[/dim]"
+                bar_str = f"[dim]{'█' * bar_len}[/dim]"
+
+            if report.has_tool_data:
+                calls_str = f"[yellow]{t.tool_call_tokens:,}[/yellow]" if t.tool_call_tokens else "[dim]—[/dim]"
+                results_str = f"[magenta]{t.tool_result_tokens:,}[/magenta]" if t.tool_result_tokens else "[dim]—[/dim]"
+                table.add_row(
+                    str(t.turn),
+                    role_str,
+                    f"{t.tokens:,}",
+                    f"{t.text_tokens:,}",
+                    calls_str,
+                    results_str,
+                    f"{t.cumulative:,}",
+                    bar_str,
+                    t.content_preview,
+                )
+            else:
+                table.add_row(
+                    str(t.turn),
+                    role_str,
+                    f"{t.tokens:,}",
+                    f"{t.cumulative:,}",
+                    bar_str,
+                    t.content_preview,
+                )
+
+        # Highlight the heaviest row and ensure the table has focus
+        if max_t:
+            table.move_cursor(row=max_t.turn - 1)
+        table.focus()

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

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

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

@@ -152,7 +152,7 @@ wheels = [
 
 [[package]]
 name = "context-forge-cli"
-version = "0.2.1"
+version = "0.2.4"
 source = { editable = "." }
 dependencies = [
     { name = "anthropic" },

context_forge_cli-0.2.2/contextforge/tui/widgets/tokens_panel.py

@@ -1,134 +0,0 @@
-"""TokensPanel — modal screen showing per-turn token analysis for a session."""
-from __future__ import annotations
-
-from pathlib import Path
-
-from textual.app import ComposeResult
-from textual.binding import Binding
-from textual.containers import Vertical
-from textual.screen import ModalScreen
-from textual.widgets import DataTable, Footer, Static
-
-
-class TokensPanel(ModalScreen):
-    """Full-screen modal showing token breakdown for a session."""
-
-    BINDINGS = [
-        Binding("escape,q", "dismiss(None)", "Close"),
-    ]
-
-    DEFAULT_CSS = """
-    TokensPanel {
-        align: center middle;
-    }
-    TokensPanel > Vertical {
-        width: 90%;
-        height: 85%;
-        border: thick $primary;
-        background: $surface;
-        padding: 0 1;
-    }
-    TokensPanel #tokens-header {
-        height: auto;
-        padding: 1 1 0 1;
-        color: $text;
-    }
-    TokensPanel #tokens-stats {
-        height: auto;
-        padding: 0 1 1 1;
-        color: $text-muted;
-        border-bottom: solid $primary-background-lighten-1;
-        margin-bottom: 1;
-    }
-    TokensPanel DataTable {
-        height: 1fr;
-    }
-    TokensPanel #tokens-footer {
-        height: 1;
-        color: $text-disabled;
-        text-align: center;
-        padding: 0 1;
-    }
-    """
-
-    _BAR_MAX = 24
-
-    def __init__(self, session_id: str, db_path: Path) -> None:
-        super().__init__()
-        self._session_id = session_id
-        self._db_path = db_path
-
-    def compose(self) -> ComposeResult:
-        with Vertical():
-            yield Static("", id="tokens-header")
-            yield Static("", id="tokens-stats")
-            yield DataTable(id="tokens-table", show_cursor=True, zebra_stripes=True)
-            yield Static("ESC / q — close", id="tokens-footer")
-
-    def on_mount(self) -> None:
-        self._load()
-
-    def _load(self) -> None:
-        from contextforge.core.db import get_db
-        from contextforge.core.token_analyzer import analyze_tokens
-
-        db = get_db(self._db_path)
-        report = analyze_tokens(db, self._session_id)
-
-        header = self.query_one("#tokens-header", Static)
-        stats = self.query_one("#tokens-stats", Static)
-        table = self.query_one("#tokens-table", DataTable)
-
-        if report is None or not report.turns:
-            header.update("[bold red]No token data available.[/bold red]")
-            return
-
-        # ── Header ──────────────────────────────────────────────────────────
-        header.update(
-            f"[bold accent]Token Analysis[/bold accent]  "
-            f"[dim]{report.title[:60]}[/dim]  "
-            f"[dim]{report.tool}[/dim]"
-        )
-
-        # ── Stats bar ───────────────────────────────────────────────────────
-        max_t = report.max_turn
-        stats.update(
-            f"Total [bold]{report.total:,}[/bold] tokens  │  "
-            f"[cyan]User {report.user_total:,}[/cyan] (avg {report.avg_user:,.0f})  │  "
-            f"[green]Asst {report.assistant_total:,}[/green] (avg {report.avg_assistant:,.0f})  │  "
-            f"{report.turn_count} turns"
-            + (f"  │  Heaviest: turn #{max_t.turn} "
-               f"[bold]{max_t.tokens:,}[/bold] tok [{max_t.role}]"
-               if max_t else "")
-        )
-
-        # ── Table ────────────────────────────────────────────────────────────
-        table.add_columns("#", "Role", "Tokens", "Cumul.", "Bar", "Preview")
-
-        max_tokens = max(t.tokens for t in report.turns)
-
-        for t in report.turns:
-            bar_len = max(1, int(t.tokens / max_tokens * self._BAR_MAX))
-
-            if t.role == "user":
-                role_str = "[cyan]user[/cyan]"
-                bar_str = f"[cyan]{'█' * bar_len}[/cyan]"
-            elif t.role == "assistant":
-                role_str = "[green]asst[/green]"
-                bar_str = f"[green]{'█' * bar_len}[/green]"
-            else:
-                role_str = f"[dim]{t.role}[/dim]"
-                bar_str = f"[dim]{'█' * bar_len}[/dim]"
-
-            table.add_row(
-                str(t.turn),
-                role_str,
-                f"{t.tokens:,}",
-                f"{t.cumulative:,}",
-                bar_str,
-                t.content_preview,
-            )
-
-        # Highlight the heaviest row
-        if max_t:
-            table.move_cursor(row=max_t.turn - 1)