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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: token-tracker
-Version: 0.2.2
+Version: 0.2.3
 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.3}/pyproject.toml

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

token_tracker-0.2.3/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.3}/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)
@@ -72,14 +72,14 @@ def _show_interactive_dashboard(agents):
     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
     orig = _tables.console
 
     sys.stdout.write("\033[?1049h\033[?25l")
+    sys.stdout.write("\033[H\033[J\033[2m加载数据...\033[0m")
     sys.stdout.flush()
+    cache = {a.id: _build_agent_data(a.id, a.name) for a in agents}
+
     try:
         while True:
             buf = StringIO()
@@ -94,7 +94,7 @@ def _show_interactive_dashboard(agents):
                 _tables.console.print(f"[yellow]暂无数据[/yellow]")
             _tables.console = orig
 
-            sys.stdout.write("\033[2J\033[H" + buf.getvalue())
+            sys.stdout.write("\033[H\033[J" + buf.getvalue())
             sys.stdout.flush()
 
             key = _read_key(tty, termios)

{token_tracker-0.2.2 → token_tracker-0.2.3}/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)
 
@@ -183,12 +186,12 @@ def render_tab_bar(agent_names: list[str], current: int) -> None:
     line.append("  ")
     for i, name in enumerate(agent_names):
         if i > 0:
-            line.append(" | ", style=_S.dim)
+            line.append(" │ ", style=_S.dim)
         if i == current:
             line.append(f" {name} ", style="bold reverse")
         else:
             line.append(f" {name} ", style=_S.dim)
-    line.append("          < > 切换  q / ESC 退出", style=_S.dim)
+    line.append("          ← → 切换  q / ESC 退出", style=_S.dim)
     console.print(line)
 
 
@@ -198,7 +201,7 @@ 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)
+    agent_text = " ".join(f"[{_S.good}]●[/{_S.good}] {a}" for a in agents)
     console.print()
     console.print(Panel(
         f"[bold]Token Tracker[/bold]  {agent_text}",
@@ -611,7 +614,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 +697,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 +710,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 +765,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 +791,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 +806,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.3}/token_tracker.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: token-tracker
-Version: 0.2.2
+Version: 0.2.3
 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