token-tracker 0.2.2__tar.gz → 0.2.4__tar.gz

{token_tracker-0.2.2 → token_tracker-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: token-tracker
-Version: 0.2.2
+Version: 0.2.4
 Summary: Track token usage across local AI agents (Claude Code, Codex)
 Requires-Python: >=3.11
 Requires-Dist: rich>=13.7

{token_tracker-0.2.2 → token_tracker-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "token-tracker"
-version = "0.2.2"
+version = "0.2.4"
 description = "Track token usage across local AI agents (Claude Code, Codex)"
 requires-python = ">=3.11"
 dependencies = [

token_tracker-0.2.4/src/analyzer/aggregator.py

@@ -0,0 +1,133 @@
+from collections import defaultdict
+from datetime import datetime
+
+from ..adapters.types import DailyStats, MonthlyStats, SessionStats, UsageEntry, WeeklyStats
+from .cost import calculate_cost
+
+
+def aggregate_daily(entries: list[UsageEntry]) -> list[DailyStats]:
+    by_date: dict[str, DailyStats] = {}
+    sessions_by_date: dict[str, set[str]] = defaultdict(set)
+
+    for e in entries:
+        date_str = e.timestamp.strftime("%Y-%m-%d")
+        if date_str not in by_date:
+            by_date[date_str] = DailyStats(date=date_str)
+        s = by_date[date_str]
+        cost = calculate_cost(e)
+        s.input_tokens += e.input_tokens
+        s.output_tokens += e.output_tokens
+        s.cache_creation_tokens += e.cache_creation_tokens
+        s.cache_read_tokens += e.cache_read_tokens
+        s.total_tokens += e.total_tokens
+        s.cost_usd += cost
+        s.message_count += e.message_count
+        s.models[e.model] = s.models.get(e.model, 0) + e.total_tokens
+        sessions_by_date[date_str].add(e.session_id)
+
+    for date_str, sessions in sessions_by_date.items():
+        by_date[date_str].session_count = len(sessions)
+
+    return sorted(by_date.values(), key=lambda s: s.date)
+
+
+def aggregate_monthly(entries: list[UsageEntry]) -> list[MonthlyStats]:
+    by_month: dict[str, MonthlyStats] = {}
+    sessions_by_month: dict[str, set[str]] = defaultdict(set)
+
+    for e in entries:
+        month_str = e.timestamp.strftime("%Y-%m")
+        if month_str not in by_month:
+            by_month[month_str] = MonthlyStats(month=month_str)
+        s = by_month[month_str]
+        cost = calculate_cost(e)
+        s.input_tokens += e.input_tokens
+        s.output_tokens += e.output_tokens
+        s.cache_creation_tokens += e.cache_creation_tokens
+        s.cache_read_tokens += e.cache_read_tokens
+        s.total_tokens += e.total_tokens
+        s.cost_usd += cost
+        s.message_count += e.message_count
+        s.models[e.model] = s.models.get(e.model, 0) + e.total_tokens
+        sessions_by_month[month_str].add(e.session_id)
+
+    for month_str, sessions in sessions_by_month.items():
+        by_month[month_str].session_count = len(sessions)
+
+    return sorted(by_month.values(), key=lambda s: s.month)
+
+
+def aggregate_weekly(entries: list[UsageEntry]) -> list[WeeklyStats]:
+    from datetime import timedelta
+
+    by_week: dict[str, WeeklyStats] = {}
+    sessions_by_week: dict[str, set[str]] = defaultdict(set)
+
+    for e in entries:
+        monday = e.timestamp.date() - timedelta(days=e.timestamp.weekday())
+        sunday = monday + timedelta(days=6)
+        week_key = monday.isoformat()
+        if week_key not in by_week:
+            by_week[week_key] = WeeklyStats(
+                week=week_key,
+                week_start=monday.strftime("%m-%d"),
+                week_end=sunday.strftime("%m-%d"),
+            )
+        s = by_week[week_key]
+        cost = calculate_cost(e)
+        s.input_tokens += e.input_tokens
+        s.output_tokens += e.output_tokens
+        s.cache_creation_tokens += e.cache_creation_tokens
+        s.cache_read_tokens += e.cache_read_tokens
+        s.total_tokens += e.total_tokens
+        s.cost_usd += cost
+        s.message_count += e.message_count
+        s.models[e.model] = s.models.get(e.model, 0) + e.total_tokens
+        sessions_by_week[week_key].add(e.session_id)
+
+    for week_key, sessions in sessions_by_week.items():
+        by_week[week_key].session_count = len(sessions)
+
+    return sorted(by_week.values(), key=lambda s: s.week)
+
+
+def aggregate_sessions(entries: list[UsageEntry]) -> list[SessionStats]:
+    by_session: dict[str, list[UsageEntry]] = defaultdict(list)
+
+    for e in entries:
+        by_session[e.session_id].append(e)
+
+    sessions: list[SessionStats] = []
+    for session_id, session_entries in by_session.items():
+        session_entries.sort(key=lambda e: e.timestamp)
+        first = session_entries[0]
+        last = session_entries[-1]
+        duration = (last.timestamp - first.timestamp).total_seconds() / 60
+
+        models: dict[str, int] = defaultdict(int)
+        for e in session_entries:
+            models[e.model] += e.total_tokens
+        primary_model = max(models, key=models.get) if models else "unknown"
+
+        s = SessionStats(
+            session_id=session_id,
+            project=first.project,
+            model=primary_model,
+            start_time=first.timestamp,
+            end_time=last.timestamp,
+            duration_minutes=round(duration, 1),
+        )
+        for e in session_entries:
+            cost = calculate_cost(e)
+            s.input_tokens += e.input_tokens
+            s.output_tokens += e.output_tokens
+            s.cache_creation_tokens += e.cache_creation_tokens
+            s.cache_read_tokens += e.cache_read_tokens
+            s.total_tokens += e.total_tokens
+            s.cost_usd += cost
+            s.message_count += e.message_count
+
+        sessions.append(s)
+
+    sessions.sort(key=lambda s: s.start_time, reverse=True)
+    return sessions

{token_tracker-0.2.2 → token_tracker-0.2.4}/src/cli.py

@@ -1,5 +1,4 @@
 import sys
-from datetime import datetime, timedelta, timezone
 
 from .adapters import claude, codex
 from .adapters.rate_limits import load_rate_limits as load_claude_rate_limits
@@ -49,6 +48,7 @@ def _build_agent_data(agent_id: str, agent_name: str) -> dict | None:
     weekly = aggregate_weekly(entries)
     monthly = aggregate_monthly(entries)
     sessions = aggregate_sessions(entries)
+    from datetime import datetime, timezone, timedelta
     cutoff = datetime.now(timezone.utc) - timedelta(hours=48)
     recent = [e for e in entries if e.timestamp >= cutoff]
     blocks = analyze_blocks(recent)
@@ -64,48 +64,96 @@ def _build_agent_data(agent_id: str, agent_name: str) -> dict | None:
     )
 
 
+def _initial_agent_index(agents) -> int:
+    import os
+
+    preferred = None
+    if os.environ.get("CODEX_THREAD_ID") or os.environ.get("CODEX_SANDBOX"):
+        preferred = "codex"
+    elif os.environ.get("CLAUDE_CONFIG_DIR") or os.environ.get("CLAUDECODE"):
+        preferred = "claude-code"
+
+    if preferred:
+        for i, agent in enumerate(agents):
+            if agent.id == preferred:
+                return i
+    return 0
+
+
+def _fit_screen(text: str, height: int, scroll_offset: int) -> tuple[str, int]:
+    lines = text.splitlines()
+    if not lines:
+        return "", 0
+    max_body = max(1, height - 1)
+    max_scroll = max(0, len(lines) - max_body)
+    scroll_offset = max(0, min(scroll_offset, max_scroll))
+    visible = lines[:1] + lines[1 + scroll_offset:1 + scroll_offset + max_body - 1]
+    return "\n".join(visible), max_scroll
+
+
 def _show_interactive_dashboard(agents):
     import tty
     import termios
+    import shutil
     from io import StringIO
     from rich.console import Console as RichConsole
     import src.ui.tables as _tables
 
     agent_names = [a.name for a in agents]
-    console.print(f"[dim]加载数据...[/dim]")
-    cache = {a.id: _build_agent_data(a.id, a.name) for a in agents}
-
-    current = 0
+    current = _initial_agent_index(agents)
+    scroll_offset = 0
     orig = _tables.console
 
-    sys.stdout.write("\033[?1049h\033[?25l")
-    sys.stdout.flush()
+    sys.stdout.write("\033[?1049h\033[?7l\033[2J\033[3J\033[H\033[?25l")
+    cache = {}
+
     try:
         while True:
+            agent = agents[current]
+            if agent.id not in cache:
+                sys.stdout.write("\033[2J\033[3J\033[H\033[2m加载数据...\033[0m")
+                sys.stdout.flush()
+                cache[agent.id] = _build_agent_data(agent.id, agent.name)
+
+            size = shutil.get_terminal_size((80, 24))
+            width = size.columns
+            height = size.lines
+
             buf = StringIO()
             _tables.console = RichConsole(
-                file=buf, width=orig.width, force_terminal=True,
+                file=buf, width=width, force_terminal=True,
             )
             render_tab_bar(agent_names, current)
-            data = cache[agents[current].id]
+            data = cache[agent.id]
             if data:
-                render_dashboard(**data)
+                render_dashboard(**data, session_limit=10, top_margin=False)
             else:
                 _tables.console.print(f"[yellow]暂无数据[/yellow]")
             _tables.console = orig
 
-            sys.stdout.write("\033[2J\033[H" + buf.getvalue())
+            screen, max_scroll = _fit_screen(buf.getvalue(), height, scroll_offset)
+            sys.stdout.write("\033[2J\033[3J\033[H" + screen)
             sys.stdout.flush()
 
             key = _read_key(tty, termios)
             if key == "left":
                 current = (current - 1) % len(agents)
+                scroll_offset = 0
             elif key == "right":
                 current = (current + 1) % len(agents)
+                scroll_offset = 0
+            elif key == "up":
+                scroll_offset = max(0, scroll_offset - 1)
+            elif key == "down":
+                scroll_offset = min(max_scroll, scroll_offset + 1)
+            elif key == "page_up":
+                scroll_offset = max(0, scroll_offset - max(1, height - 3))
+            elif key == "page_down":
+                scroll_offset = min(max_scroll, scroll_offset + max(1, height - 3))
             elif key == "quit":
                 break
     finally:
-        sys.stdout.write("\033[?25h\033[?1049l")
+        sys.stdout.write("\033[?7h\033[?25h\033[?1049l")
         sys.stdout.flush()
         _tables.console = orig
 
@@ -128,11 +176,27 @@ def _read_key(tty, termios):
                     return "left"
                 if ch3 == b"C":
                     return "right"
+                if ch3 == b"A":
+                    return "up"
+                if ch3 == b"B":
+                    return "down"
+                if ch3 in (b"5", b"6"):
+                    if select.select([fd], [], [], 0.05)[0]:
+                        _os.read(fd, 1)
+                    return "page_up" if ch3 == b"5" else "page_down"
             return "other"
-        if ch in (b"h", b"k"):
+        if ch == b"h":
             return "left"
-        if ch in (b"l", b"j"):
+        if ch == b"l":
             return "right"
+        if ch == b"k":
+            return "up"
+        if ch == b"j":
+            return "down"
+        if ch == b"b":
+            return "page_up"
+        if ch == b"f":
+            return "page_down"
         if ch in (b"q", b"Q", b"\x03"):
             return "quit"
         return "other"
@@ -166,7 +230,8 @@ def main():
 
     agent_ids = {a.id for a in agents}
 
-    console.print(f"[dim]检测到: {', '.join(a.name + ' ✓' for a in agents)}[/dim]")
+    if command != "dashboard":
+        console.print(f"[dim]检测到: {', '.join(a.name + ' ✓' for a in agents)}[/dim]")
 
     if not is_setup():
         setup(auto=True)

{token_tracker-0.2.2 → token_tracker-0.2.4}/src/ui/tables.py

@@ -117,14 +117,17 @@ def _fmt_duration(minutes: float) -> str:
     return f"{int(minutes)}min"
 
 
-def _bar_width() -> int:
-    return 20 if _width_mode() == "compact" else 30
+def _display_width(s: str) -> int:
+    w = 0
+    for ch in s:
+        w += 2 if ord(ch) > 0x7F else 1
+    return w
 
 
 def _append_bar(lines: Text, label: str, pct: float,
                 bar_width: int, suffix: str = "") -> None:
     filled = int(pct / 100 * bar_width)
-    bar = "=" * filled + "-" * (bar_width - filled)
+    bar = "█" * filled + "░" * (bar_width - filled)
     bar_style = _S.bar_high if pct > 80 else _S.bar_mid if pct > 50 else _S.bar_low
     lines.append(label, style=_S.dim)
     lines.append(bar, style=bar_style)
@@ -135,7 +138,7 @@ def _append_bar(lines: Text, label: str, pct: float,
 
 
 def _append_trend(lines: Text, current: float, previous: float) -> None:
-    arrow = "^" if current >= previous else "v"
+    arrow = "↑" if current >= previous else "↓"
     style = _S.bad if current >= previous else _S.good
     lines.append(f"{arrow}", style=style)
 
@@ -181,14 +184,21 @@ def _render_week_section(lines: Text, week: WeeklyStats,
 def render_tab_bar(agent_names: list[str], current: int) -> None:
     line = Text()
     line.append("  ")
+    compact = console.width < 72
     for i, name in enumerate(agent_names):
         if i > 0:
-            line.append(" | ", style=_S.dim)
+            line.append(" │ ", style=_S.dim)
+        label = AGENT_SHORT.get("claude-code" if name == "Claude Code" else name.lower(), name)
+        if compact and name == "Claude Code":
+            label = "CC"
+        elif compact:
+            label = name[:8]
         if i == current:
-            line.append(f" {name} ", style="bold reverse")
+            line.append(f" {label} ", style="bold reverse")
         else:
-            line.append(f" {name} ", style=_S.dim)
-    line.append("          < > 切换  q / ESC 退出", style=_S.dim)
+            line.append(f" {label} ", style=_S.dim)
+    help_text = "  ←→ jk q/ESC退出" if compact else "  ← → 切换  ↑ ↓ 滚动  q / ESC 退出"
+    line.append(help_text, style=_S.dim)
     console.print(line)
 
 
@@ -197,9 +207,11 @@ def _project_short(project: str) -> str:
 
 
 def _render_header(agents: list[str], total_tokens: int, total_cost: float,
-                   total_sessions: int, total_messages: int, days: int) -> None:
-    agent_text = " ".join(f"[{_S.good}]{a}[/{_S.good}]" for a in agents)
-    console.print()
+                   total_sessions: int, total_messages: int, days: int,
+                   top_margin: bool = True) -> None:
+    agent_text = " ".join(f"[{_S.good}]●[/{_S.good}] {a}" for a in agents)
+    if top_margin:
+        console.print()
     console.print(Panel(
         f"[bold]Token Tracker[/bold]  {agent_text}",
         border_style="blue",
@@ -259,6 +271,8 @@ def render_dashboard(
     rate_limits: RateLimits | None = None,
     p90: P90Limits | None = None,
     agents: list[str] | None = None,
+    session_limit: int = 10,
+    top_margin: bool = True,
 ) -> None:
     if not daily_stats:
         console.print(f"[{_S.warn}]暂无数据[/{_S.warn}]")
@@ -269,7 +283,15 @@ def render_dashboard(
     total_msgs = sum(s.message_count for s in daily_stats)
     total_sessions = sum(s.session_count for s in daily_stats)
 
-    _render_header(agents or ["Claude Code"], total_tokens, total_cost, total_sessions, total_msgs, len(daily_stats))
+    _render_header(
+        agents or ["Claude Code"],
+        total_tokens,
+        total_cost,
+        total_sessions,
+        total_msgs,
+        len(daily_stats),
+        top_margin=top_margin,
+    )
 
     # --- 本月概览 ---
     if monthly_stats:
@@ -297,8 +319,8 @@ def render_dashboard(
             _render_idle_panel(rate_limits, cur_week, last_week)
 
     # --- 最近十条会话 ---
-    if sessions:
-        _render_recent_sessions(sessions[:10])
+    if sessions and session_limit > 0:
+        _render_recent_sessions(sessions[:session_limit])
 
     console.print()
 
@@ -611,7 +633,7 @@ def _render_model_breakdown(stats: list[MonthlyStats]) -> None:
     for model, tokens in sorted_models[:8]:
         pct = tokens / total * 100 if total > 0 else 0
         bar_width = int(pct / 100 * 20)
-        bar_text = "=" * bar_width + "-" * (20 - bar_width)
+        bar_text = "█" * bar_width + "░" * (20 - bar_width)
 
         if pct > 50:
             bar_style = _S.token_bold
@@ -694,7 +716,7 @@ def _render_daily_panel(
     week: WeeklyStats | None = None,
     last_week: WeeklyStats | None = None,
 ) -> None:
-    bw = _bar_width()
+    bar_width = 20 if _width_mode() == "compact" else 30
     lines = Text()
     lines.append("当日数据面板 (P90)\n\n", style="bold")
 
@@ -707,9 +729,9 @@ def _render_daily_panel(
     for label, current, limit, unit_fmt in p90_items:
         pct = min(current / limit * 100, 100) if limit > 0 else 0
         max_pct = max(max_pct, pct)
-        display_label = f"  {label}" + " " * (14 - len(label))
+        display_label = f"  {label}" + " " * (14 - _display_width(label))
         suffix = f"  {unit_fmt(current)} / {unit_fmt(limit)}"
-        _append_bar(lines, display_label, pct, bw, suffix)
+        _append_bar(lines, display_label, pct, bar_width, suffix)
         lines.append("\n")
 
     lines.append(f"  Token     {_fmt_tokens(today.total_tokens)}", style=_S.token)
@@ -762,14 +784,14 @@ def _render_active_block(
     remaining_h = remaining_min // 60
     remaining_m = remaining_min % 60
 
-    bw = _bar_width()
+    bar_width = 20 if _width_mode() == "compact" else 30
 
     lines = Text()
     lines.append("当前 5h&7d 数据面板\n\n", style="bold")
 
     if rate_limits and rate_limits.five_hour_pct is not None:
         _render_rate_bar(lines, "5h 限额", rate_limits.five_hour_pct,
-                         rate_limits.five_hour_resets_at, bw)
+                         rate_limits.five_hour_resets_at, bar_width)
 
     lines.append(f"  时间      ", style=_S.dim)
     lines.append(f"已用 {elapsed_min}min / 剩余 {remaining_h}h{remaining_m:02d}m\n", style=_S.dim)
@@ -788,7 +810,7 @@ def _render_active_block(
     if rate_limits and rate_limits.seven_day_pct is not None:
         lines.append("\n\n")
         _render_rate_bar(lines, "7d 限额", rate_limits.seven_day_pct,
-                         rate_limits.seven_day_resets_at, bw, "%m-%d %H:%M")
+                         rate_limits.seven_day_resets_at, bar_width, "%m-%d %H:%M")
         if week:
             _render_week_section(lines, week, last_week)
 
@@ -803,19 +825,19 @@ def _render_idle_panel(
     week: WeeklyStats | None = None,
     last_week: WeeklyStats | None = None,
 ) -> None:
-    bw = _bar_width()
+    bar_width = 20 if _width_mode() == "compact" else 30
     lines = Text()
     lines.append("限额数据面板\n\n", style="bold")
 
     if rate_limits.five_hour_pct is not None:
         _render_rate_bar(lines, "5h 限额", rate_limits.five_hour_pct,
-                         rate_limits.five_hour_resets_at, bw)
+                         rate_limits.five_hour_resets_at, bar_width)
 
     if rate_limits.seven_day_pct is not None:
         if rate_limits.five_hour_pct is not None:
             lines.append("\n")
         _render_rate_bar(lines, "7d 限额", rate_limits.seven_day_pct,
-                         rate_limits.seven_day_resets_at, bw, "%m-%d %H:%M")
+                         rate_limits.seven_day_resets_at, bar_width, "%m-%d %H:%M")
         if week:
             _render_week_section(lines, week, last_week)
 

{token_tracker-0.2.2 → token_tracker-0.2.4}/token_tracker.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: token-tracker
-Version: 0.2.2
+Version: 0.2.4
 Summary: Track token usage across local AI agents (Claude Code, Codex)
 Requires-Python: >=3.11
 Requires-Dist: rich>=13.7

token_tracker-0.2.2/src/analyzer/aggregator.py

@@ -1,108 +0,0 @@
-from collections import defaultdict
-from datetime import timedelta
-
-from ..adapters.types import DailyStats, MonthlyStats, SessionStats, UsageEntry, WeeklyStats
-from .cost import calculate_cost
-
-
-def _accumulate(stat, entry: UsageEntry) -> None:
-    cost = calculate_cost(entry)
-    stat.input_tokens += entry.input_tokens
-    stat.output_tokens += entry.output_tokens
-    stat.cache_creation_tokens += entry.cache_creation_tokens
-    stat.cache_read_tokens += entry.cache_read_tokens
-    stat.total_tokens += entry.total_tokens
-    stat.cost_usd += cost
-    stat.message_count += entry.message_count
-    if hasattr(stat, "models"):
-        stat.models[entry.model] = stat.models.get(entry.model, 0) + entry.total_tokens
-
-
-def aggregate_daily(entries: list[UsageEntry]) -> list[DailyStats]:
-    by_date: dict[str, DailyStats] = {}
-    sessions: dict[str, set[str]] = defaultdict(set)
-
-    for e in entries:
-        key = e.timestamp.strftime("%Y-%m-%d")
-        if key not in by_date:
-            by_date[key] = DailyStats(date=key)
-        _accumulate(by_date[key], e)
-        sessions[key].add(e.session_id)
-
-    for key, sids in sessions.items():
-        by_date[key].session_count = len(sids)
-
-    return sorted(by_date.values(), key=lambda s: s.date)
-
-
-def aggregate_monthly(entries: list[UsageEntry]) -> list[MonthlyStats]:
-    by_month: dict[str, MonthlyStats] = {}
-    sessions: dict[str, set[str]] = defaultdict(set)
-
-    for e in entries:
-        key = e.timestamp.strftime("%Y-%m")
-        if key not in by_month:
-            by_month[key] = MonthlyStats(month=key)
-        _accumulate(by_month[key], e)
-        sessions[key].add(e.session_id)
-
-    for key, sids in sessions.items():
-        by_month[key].session_count = len(sids)
-
-    return sorted(by_month.values(), key=lambda s: s.month)
-
-
-def aggregate_weekly(entries: list[UsageEntry]) -> list[WeeklyStats]:
-    by_week: dict[str, WeeklyStats] = {}
-    sessions: dict[str, set[str]] = defaultdict(set)
-
-    for e in entries:
-        monday = e.timestamp.date() - timedelta(days=e.timestamp.weekday())
-        sunday = monday + timedelta(days=6)
-        key = monday.isoformat()
-        if key not in by_week:
-            by_week[key] = WeeklyStats(
-                week=key,
-                week_start=monday.strftime("%m-%d"),
-                week_end=sunday.strftime("%m-%d"),
-            )
-        _accumulate(by_week[key], e)
-        sessions[key].add(e.session_id)
-
-    for key, sids in sessions.items():
-        by_week[key].session_count = len(sids)
-
-    return sorted(by_week.values(), key=lambda s: s.week)
-
-
-def aggregate_sessions(entries: list[UsageEntry]) -> list[SessionStats]:
-    by_session: dict[str, list[UsageEntry]] = defaultdict(list)
-    for e in entries:
-        by_session[e.session_id].append(e)
-
-    sessions: list[SessionStats] = []
-    for session_id, session_entries in by_session.items():
-        session_entries.sort(key=lambda e: e.timestamp)
-        first = session_entries[0]
-        last = session_entries[-1]
-        duration = (last.timestamp - first.timestamp).total_seconds() / 60
-
-        models: dict[str, int] = defaultdict(int)
-        for e in session_entries:
-            models[e.model] += e.total_tokens
-        primary_model = max(models, key=models.get) if models else "unknown"
-
-        s = SessionStats(
-            session_id=session_id,
-            project=first.project,
-            model=primary_model,
-            start_time=first.timestamp,
-            end_time=last.timestamp,
-            duration_minutes=round(duration, 1),
-        )
-        for e in session_entries:
-            _accumulate(s, e)
-        sessions.append(s)
-
-    sessions.sort(key=lambda s: s.start_time, reverse=True)
-    return sessions