context-forge-cli 0.1.0__py3-none-any.whl

contextforge/tui/widgets/stats_panel.py

@@ -0,0 +1,340 @@
+"""StatsPanel — analytics modal with time-window charts."""
+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.reactive import reactive
+from textual.screen import ModalScreen
+from textual.widgets import Static
+
+# ── Unicode rendering helpers ─────────────────────────────────────────────────
+
+_BLOCKS = " ▏▎▍▌▋▊▉█"   # 9 levels: 0/8 → 8/8 of a cell
+_SPARK = "▁▂▃▄▅▆▇█"      # 8 vertical height levels
+
+TOOL_COLORS = {
+    "claude_code": "cyan",
+    "codex": "green",
+    "altimate_code": "magenta",
+    "claude_desktop": "yellow",
+}
+TOOL_LABELS = {
+    "claude_code": "Claude Code",
+    "codex": "Codex",
+    "altimate_code": "altimate",
+    "claude_desktop": "Desktop",
+}
+
+WINDOW_LABELS = {
+    "7d": "7 days",
+    "30d": "30 days",
+    "6m": "6 months",
+    "1y": "1 year",
+}
+
+
+def _unicode_bar(fraction: float, width: int = 32) -> str:
+    if fraction <= 0:
+        return " " * width
+    total_eighths = round(fraction * width * 8)
+    full_cells = min(total_eighths // 8, width)
+    remainder = total_eighths % 8
+    bar = "█" * full_cells
+    if full_cells < width and remainder > 0:
+        bar += _BLOCKS[remainder]
+    return bar.ljust(width)
+
+
+def _render_bar_line(
+    label: str,
+    value: int,
+    max_value: int,
+    color: str = "cyan",
+    label_width: int = 14,
+    bar_width: int = 32,
+) -> str:
+    fraction = value / max_value if max_value else 0
+    bar = _unicode_bar(fraction, bar_width)
+    val_str = _fmt_tokens(value) if value >= 1000 else str(value)
+    return f"[dim]{label:<{label_width}}[/dim][{color}]{bar}[/{color}] [bold]{val_str}[/bold]"
+
+
+def _fmt_tokens(n: int) -> str:
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f}M"
+    if n >= 1_000:
+        return f"{n // 1_000}k"
+    return str(n)
+
+
+def _spark_char(value: int, max_value: int) -> str:
+    if not max_value or not value:
+        return " "
+    idx = max(0, min(7, int(value / max_value * 8) - 1))
+    return _SPARK[idx]
+
+
+def _render_sparkline(buckets: list, width: int = 52) -> str:
+    """Return a two-line Rich markup string: bar row + sparse date labels."""
+    if not buckets:
+        return "[dim](no data)[/dim]"
+
+    max_count = max(b.count for b in buckets) if buckets else 0
+
+    # Downsample if too many buckets
+    if len(buckets) > width:
+        step = len(buckets) / width
+        sampled = []
+        for i in range(width):
+            idx = min(int(i * step), len(buckets) - 1)
+            sampled.append(buckets[idx])
+        buckets = sampled
+
+    # Compute quartiles for coloring
+    counts = sorted(b.count for b in buckets if b.count > 0)
+    q1 = counts[len(counts) // 4] if counts else 1
+    q3 = counts[3 * len(counts) // 4] if counts else 1
+
+    bar_chars: list[str] = []
+    for b in buckets:
+        ch = _spark_char(b.count, max_count)
+        if b.count == 0:
+            bar_chars.append(f"[dim]{ch}[/dim]")
+        elif b.count >= q3:
+            bar_chars.append(f"[yellow]{ch}[/yellow]")
+        elif b.count >= q1:
+            bar_chars.append(f"[green]{ch}[/green]")
+        else:
+            bar_chars.append(f"[dim]{ch}[/dim]")
+
+    spark_line = "".join(bar_chars)
+
+    # Build sparse date label row (first, middle, last)
+    n = len(buckets)
+    label_line = [" "] * n
+    if n > 0:
+        first_lbl = buckets[0].label[-5:]   # last 5 chars e.g. "04-12" or "W15"
+        last_lbl = buckets[-1].label[-5:]
+        mid_lbl = buckets[n // 2].label[-5:]
+
+        # Place labels without overlap
+        label_line[0] = first_lbl[0]
+        for i, ch in enumerate(first_lbl):
+            if i < n:
+                label_line[i] = ch
+
+        mid_start = n // 2
+        for i, ch in enumerate(mid_lbl):
+            pos = mid_start + i
+            if pos < n:
+                label_line[pos] = ch
+
+        last_start = max(n - len(last_lbl), 0)
+        for i, ch in enumerate(last_lbl):
+            pos = last_start + i
+            if pos < n:
+                label_line[pos] = ch
+
+    date_line = f"[dim]{''.join(label_line)}[/dim]"
+    return spark_line + "\n" + date_line
+
+
+# ── Modal screen ──────────────────────────────────────────────────────────────
+
+
+class StatsPanel(ModalScreen):
+    """Analytics overview modal. Open with 'a', close with ESC/q."""
+
+    BINDINGS = [
+        Binding("escape,q", "dismiss(None)", "Close"),
+        Binding("w", "set_window_7d", "7d"),
+        Binding("m", "set_window_30d", "30d"),
+        Binding("h", "set_window_6m", "6m"),
+        Binding("y", "set_window_1y", "1y"),
+    ]
+
+    DEFAULT_CSS = """
+    StatsPanel {
+        align: center middle;
+    }
+    StatsPanel > Vertical {
+        width: 82%;
+        max-width: 110;
+        height: 88%;
+        border: thick $primary;
+        background: $surface;
+        padding: 1 2;
+        overflow-y: auto;
+    }
+    StatsPanel #stats-title {
+        text-style: bold;
+        color: $accent;
+        margin-bottom: 1;
+    }
+    StatsPanel #stats-overview {
+        color: $text-muted;
+        margin-bottom: 1;
+        border-bottom: solid $primary-background-lighten-1;
+        padding-bottom: 1;
+    }
+    StatsPanel .chart-title {
+        text-style: bold;
+        color: $text;
+        margin-top: 1;
+    }
+    StatsPanel #bar-sessions {
+        margin-bottom: 1;
+    }
+    StatsPanel #bar-tokens {
+        margin-bottom: 1;
+    }
+    StatsPanel #sparkline {
+        margin-bottom: 1;
+    }
+    StatsPanel #projects {
+        margin-bottom: 1;
+    }
+    StatsPanel #stats-footer {
+        color: $text-disabled;
+        text-align: center;
+        margin-top: 1;
+        border-top: solid $primary-background-lighten-1;
+        padding-top: 1;
+    }
+    """
+
+    window: reactive[str] = reactive("30d")
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static("", id="stats-title")
+            yield Static("", id="stats-overview")
+            yield Static("Sessions by tool", classes="chart-title")
+            yield Static("", id="bar-sessions")
+            yield Static("Token usage by tool", classes="chart-title")
+            yield Static("", id="bar-tokens")
+            yield Static("Activity over time", classes="chart-title")
+            yield Static("", id="sparkline")
+            yield Static("Top projects", classes="chart-title")
+            yield Static("", id="projects")
+            yield Static(
+                "ESC/q — close  │  W=7d  M=30d  H=6m  Y=1y",
+                id="stats-footer",
+            )
+
+    def on_mount(self) -> None:
+        self._refresh_data()
+
+    def watch_window(self, new_window: str) -> None:
+        self._refresh_data()
+
+    # ── Window actions ────────────────────────────────────────────────────────
+
+    def action_set_window_7d(self) -> None:
+        self.window = "7d"
+
+    def action_set_window_30d(self) -> None:
+        self.window = "30d"
+
+    def action_set_window_6m(self) -> None:
+        self.window = "6m"
+
+    def action_set_window_1y(self) -> None:
+        self.window = "1y"
+
+    # ── Data loading ──────────────────────────────────────────────────────────
+
+    def _refresh_data(self) -> None:
+        db_path: Path | None = getattr(self.app, "db_path", None)
+        if db_path is None:
+            self.query_one("#stats-overview", Static).update("[red]No database path.[/red]")
+            return
+
+        from contextforge.core import analytics
+        from contextforge.core.db import get_db
+
+        db = get_db(db_path)
+        overview = analytics.get_overview(db, self.window)
+        activity = analytics.get_activity_over_time(db, self.window)
+        projects = analytics.get_top_projects(db, self.window)
+
+        self._render_all(overview, activity, projects)
+
+    def _render_all(self, overview, activity: list, projects: list) -> None:
+        w = self.window
+        label = WINDOW_LABELS.get(w, w)
+
+        # ── Title ──────────────────────────────────────────────────────────
+        window_indicators = "  ".join(
+            f"[bold cyan]▶ {k}[/bold cyan]" if k == w else f"[dim]{k.upper()[0]}[/dim]"
+            for k in ("7d", "30d", "6m", "1y")
+        )
+        self.query_one("#stats-title", Static).update(
+            f"[bold]Analytics[/bold]  {window_indicators}  [dim]— last {label}[/dim]"
+        )
+
+        # ── Overview ───────────────────────────────────────────────────────
+        total_tok_str = _fmt_tokens(overview.total_tokens)
+        date_str = ""
+        if overview.date_range:
+            earliest, latest = overview.date_range
+            date_str = (
+                f"  │  {earliest.strftime('%b %d')} → {latest.strftime('%b %d, %Y')}"
+            )
+        tools_str = ", ".join(
+            TOOL_LABELS.get(t, t) for t in sorted(overview.active_tools)
+        ) or "—"
+        self.query_one("#stats-overview", Static).update(
+            f"[bold]{overview.total_sessions:,}[/bold] sessions  │  "
+            f"[bold]{total_tok_str}[/bold] tokens  │  "
+            f"Tools: [dim]{tools_str}[/dim]"
+            f"{date_str}"
+        )
+
+        # ── Sessions bar chart ─────────────────────────────────────────────
+        tool_order = ["claude_code", "codex", "altimate_code", "claude_desktop"]
+        max_sess = max(overview.session_count_by_tool.values(), default=1)
+        sess_lines: list[str] = []
+        for tool in tool_order:
+            cnt = overview.session_count_by_tool.get(tool, 0)
+            if cnt == 0:
+                continue
+            color = TOOL_COLORS.get(tool, "white")
+            label_str = TOOL_LABELS.get(tool, tool)
+            sess_lines.append(_render_bar_line(label_str, cnt, max_sess, color))
+        self.query_one("#bar-sessions", Static).update(
+            "\n".join(sess_lines) if sess_lines else "[dim](no data)[/dim]"
+        )
+
+        # ── Token bar chart ────────────────────────────────────────────────
+        max_tok = max(overview.token_sum_by_tool.values(), default=1)
+        tok_lines: list[str] = []
+        for tool in tool_order:
+            tok = overview.token_sum_by_tool.get(tool, 0)
+            if tok == 0:
+                continue
+            color = TOOL_COLORS.get(tool, "white")
+            label_str = TOOL_LABELS.get(tool, tool)
+            tok_lines.append(_render_bar_line(label_str, tok, max_tok, color))
+        self.query_one("#bar-tokens", Static).update(
+            "\n".join(tok_lines) if tok_lines else "[dim](no data)[/dim]"
+        )
+
+        # ── Sparkline ──────────────────────────────────────────────────────
+        self.query_one("#sparkline", Static).update(_render_sparkline(activity))
+
+        # ── Top projects ───────────────────────────────────────────────────
+        if projects:
+            proj_lines = [
+                f"[dim]{i + 1}.[/dim] [bold]{p.project}[/bold] [dim]({p.count})[/dim]"
+                for i, p in enumerate(projects)
+            ]
+            self.query_one("#projects", Static).update("\n".join(proj_lines))
+        else:
+            self.query_one("#projects", Static).update("[dim](no data)[/dim]")

contextforge/tui/widgets/status_bar.py

@@ -0,0 +1,102 @@
+"""StatusBar widget — bottom bar showing scan time and session counts by tool."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+from textual.widget import Widget
+from textual.widgets import Static
+
+
+def _fmt_tokens(n: int) -> str:
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f}M tok"
+    if n >= 1_000:
+        return f"{n // 1_000}k tok"
+    return f"{n} tok"
+
+
+class StatusBar(Widget):
+    """Shows last scan time, per-tool session counts, and filter state."""
+
+    DEFAULT_CSS = """
+    StatusBar {
+        height: 1;
+        dock: bottom;
+        background: $primary-background-darken-2;
+        color: $text-muted;
+        padding: 0 1;
+        layout: horizontal;
+    }
+    StatusBar #status-counts {
+        width: auto;
+        margin-right: 2;
+    }
+    StatusBar #status-filter {
+        width: 1fr;
+    }
+    StatusBar #status-scan-time {
+        width: auto;
+    }
+    """
+
+    def compose(self):
+        yield Static("", id="status-counts")
+        yield Static("", id="status-filter")
+        yield Static("", id="status-scan-time")
+
+    def refresh_stats(self) -> None:
+        """Re-read DB and update the status bar."""
+        db_path: Path | None = getattr(self.app, "db_path", None)
+        if db_path is None:
+            return
+
+        from contextforge.core.db import get_db, get_sessions
+        db = get_db(db_path)
+        rows = get_sessions(db, limit=10_000)
+
+        counts: dict[str, int] = {}
+        total_tokens = 0
+        for row in rows:
+            tool = row.get("tool", "unknown")
+            counts[tool] = counts.get(tool, 0) + 1
+            total_tokens += row.get("token_count") or 0
+
+        tool_parts = []
+        labels = {
+            "claude_code": "CC",
+            "codex": "Codex",
+            "altimate_code": "Alt",
+            "claude_desktop": "Desktop",
+        }
+        for tool, label in labels.items():
+            n = counts.get(tool, 0)
+            if n:
+                tool_parts.append(f"{label}:{n}")
+
+        tok_str = _fmt_tokens(total_tokens)
+        self.query_one("#status-counts").update(
+            f"Sessions — {' │ '.join(tool_parts)} │ Total:{len(rows)} │ {tok_str}"
+        )
+
+        now = datetime.now(timezone.utc).strftime("%H:%M:%S")
+        self.query_one("#status-scan-time").update(f"Updated {now}")
+
+    def set_filter_indicator(
+        self, text: str, tool: str | None, match_count: int
+    ) -> None:
+        """Show or clear the active filter indicator."""
+        if not text and tool is None:
+            self.query_one("#status-filter", Static).update("")
+            return
+
+        parts: list[str] = []
+        if text:
+            parts.append(f'"{text}"')
+        if tool:
+            short = {"claude_code": "CC", "codex": "Codex", "altimate_code": "Alt", "claude_desktop": "Desktop"}.get(tool, tool)
+            parts.append(short)
+
+        self.query_one("#status-filter", Static).update(
+            f"[yellow]Filter: {' + '.join(parts)} ({match_count} matches)[/yellow]"
+        )

contextforge/tui/widgets/tokens_panel.py

@@ -0,0 +1,134 @@
+"""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)

contextforge/tui/widgets/transfer_panel.py

@@ -0,0 +1,119 @@
+"""TransferPanel — modal screen for configuring and launching a context transfer."""
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.message import Message
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, RadioButton, RadioSet, Static
+
+
+TOOLS = [
+    ("claude_code", "Claude Code"),
+    ("codex", "Codex"),
+    ("altimate_code", "altimate-code"),
+]
+
+STRATEGIES = [
+    ("summary_only", "summary_only  — max token efficiency"),
+    ("key_messages", "key_messages  — scored important messages"),
+    ("full_recent",  "full_recent   — last N messages verbatim"),
+]
+
+
+class TransferPanel(ModalScreen):
+    """Modal overlay for selecting target tool, strategy, and launching transfer."""
+
+    DEFAULT_CSS = """
+    TransferPanel {
+        align: center middle;
+    }
+    TransferPanel > Vertical {
+        width: 60;
+        height: auto;
+        max-height: 40;
+        border: thick $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    TransferPanel #panel-title {
+        text-style: bold;
+        color: $accent;
+        margin-bottom: 1;
+    }
+    TransferPanel .section-label {
+        text-style: bold;
+        margin-top: 1;
+        color: $text-muted;
+    }
+    TransferPanel #btn-row {
+        margin-top: 2;
+        height: auto;
+        layout: horizontal;
+        align: right middle;
+    }
+    TransferPanel Button {
+        margin-left: 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "dismiss(None)", "Cancel"),
+    ]
+
+    class Confirmed(Message):
+        """Emitted when the user clicks Execute."""
+        def __init__(self, session_id: str, target_tool: str, strategy: str) -> None:
+            super().__init__()
+            self.session_id = session_id
+            self.target_tool = target_tool
+            self.strategy = strategy
+
+    def __init__(self, session_id: str, session_title: str = "") -> None:
+        super().__init__()
+        self._session_id = session_id
+        self._session_title = session_title or session_id[:16]
+
+    def compose(self) -> ComposeResult:
+        from textual.containers import Vertical, Horizontal
+
+        with Vertical():
+            yield Static(f"Transfer: {self._session_title}", id="panel-title")
+
+            yield Static("Target tool:", classes="section-label")
+            with RadioSet(id="tool-select"):
+                for tool_id, tool_name in TOOLS:
+                    yield RadioButton(tool_name, value=(tool_id == "codex"), id=f"tool-{tool_id}")
+
+            yield Static("Compaction strategy:", classes="section-label")
+            with RadioSet(id="strategy-select"):
+                for strat_id, strat_label in STRATEGIES:
+                    yield RadioButton(strat_label, value=(strat_id == "summary_only"), id=f"strat-{strat_id}")
+
+            with Horizontal(id="btn-row"):
+                yield Button("Cancel", variant="default", id="btn-cancel")
+                yield Button("Preview command", variant="primary", id="btn-preview")
+                yield Button("Execute", variant="error", id="btn-execute")
+
+    def _selected_tool(self) -> str:
+        radio_set = self.query_one("#tool-select", RadioSet)
+        pressed = radio_set.pressed_button
+        if pressed is None:
+            return TOOLS[0][0]
+        return pressed.id.removeprefix("tool-") if pressed.id else TOOLS[0][0]
+
+    def _selected_strategy(self) -> str:
+        radio_set = self.query_one("#strategy-select", RadioSet)
+        pressed = radio_set.pressed_button
+        if pressed is None:
+            return "summary_only"
+        return pressed.id.removeprefix("strat-") if pressed.id else "summary_only"
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn-cancel":
+            self.dismiss(None)
+        elif event.button.id in ("btn-preview", "btn-execute"):
+            tool = self._selected_tool()
+            strategy = self._selected_strategy()
+            execute = event.button.id == "btn-execute"
+            self.dismiss({"tool": tool, "strategy": strategy, "execute": execute})