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

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

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

{token_tracker-0.2.1 → token_tracker-0.2.2}/README.md

@@ -49,6 +49,7 @@ curl -sSL https://raw.githubusercontent.com/stormzhang/token-tracker/master/inst
 
 ```bash
 pip install token-tracker
+tt setup
 ```
 
 ## 使用

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

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

token_tracker-0.2.2/src/analyzer/aggregator.py

@@ -0,0 +1,108 @@
+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

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

@@ -1,4 +1,5 @@
 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
@@ -48,7 +49,6 @@ 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)
@@ -140,10 +140,18 @@ def _read_key(tty, termios):
         termios.tcsetattr(fd, termios.TCSADRAIN, old)
 
 
+def _get_version() -> str:
+    from importlib.metadata import version
+    return version("token-tracker")
+
+
 def main():
     args = sys.argv[1:]
     command = args[0] if args else "dashboard"
 
+    if command in ("--version", "-v", "-V"):
+        print(f"tt {_get_version()}")
+        return
     if command == "setup":
         setup()
         return
@@ -215,7 +223,7 @@ def main():
         render_sessions(stats, limit)
     else:
         console.print(f"[red]未知命令: {command}[/red]")
-        console.print("[dim]可用命令: dashboard, daily, weekly, monthly, sessions, claude, codex, setup, unsetup[/dim]")
+        console.print("[dim]可用命令: dashboard, daily, weekly, monthly, sessions, claude, codex, setup, unsetup, --version[/dim]")
         sys.exit(1)
 
 

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

@@ -117,17 +117,14 @@ def _fmt_duration(minutes: float) -> str:
     return f"{int(minutes)}min"
 
 
-def _display_width(s: str) -> int:
-    w = 0
-    for ch in s:
-        w += 2 if ord(ch) > 0x7F else 1
-    return w
+def _bar_width() -> int:
+    return 20 if _width_mode() == "compact" else 30
 
 
 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)
@@ -138,7 +135,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 "↓"
+    arrow = "^" if current >= previous else "v"
     style = _S.bad if current >= previous else _S.good
     lines.append(f"{arrow}", style=style)
 
@@ -186,12 +183,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)
 
 
@@ -201,7 +198,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}]●[/{_S.good}] {a}" for a in agents)
+    agent_text = " ".join(f"[{_S.good}]{a}[/{_S.good}]" for a in agents)
     console.print()
     console.print(Panel(
         f"[bold]Token Tracker[/bold]  {agent_text}",
@@ -614,7 +611,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
@@ -697,7 +694,7 @@ def _render_daily_panel(
     week: WeeklyStats | None = None,
     last_week: WeeklyStats | None = None,
 ) -> None:
-    bar_width = 20 if _width_mode() == "compact" else 30
+    bw = _bar_width()
     lines = Text()
     lines.append("当日数据面板 (P90)\n\n", style="bold")
 
@@ -710,9 +707,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 - _display_width(label))
+        display_label = f"  {label}" + " " * (14 - len(label))
         suffix = f"  {unit_fmt(current)} / {unit_fmt(limit)}"
-        _append_bar(lines, display_label, pct, bar_width, suffix)
+        _append_bar(lines, display_label, pct, bw, suffix)
         lines.append("\n")
 
     lines.append(f"  Token     {_fmt_tokens(today.total_tokens)}", style=_S.token)
@@ -765,14 +762,14 @@ def _render_active_block(
     remaining_h = remaining_min // 60
     remaining_m = remaining_min % 60
 
-    bar_width = 20 if _width_mode() == "compact" else 30
+    bw = _bar_width()
 
     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, bar_width)
+                         rate_limits.five_hour_resets_at, bw)
 
     lines.append(f"  时间      ", style=_S.dim)
     lines.append(f"已用 {elapsed_min}min / 剩余 {remaining_h}h{remaining_m:02d}m\n", style=_S.dim)
@@ -791,7 +788,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, bar_width, "%m-%d %H:%M")
+                         rate_limits.seven_day_resets_at, bw, "%m-%d %H:%M")
         if week:
             _render_week_section(lines, week, last_week)
 
@@ -806,19 +803,19 @@ def _render_idle_panel(
     week: WeeklyStats | None = None,
     last_week: WeeklyStats | None = None,
 ) -> None:
-    bar_width = 20 if _width_mode() == "compact" else 30
+    bw = _bar_width()
     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, bar_width)
+                         rate_limits.five_hour_resets_at, bw)
 
     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, bar_width, "%m-%d %H:%M")
+                         rate_limits.seven_day_resets_at, bw, "%m-%d %H:%M")
         if week:
             _render_week_section(lines, week, last_week)
 

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

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

token_tracker-0.2.1/src/analyzer/aggregator.py

@@ -1,133 +0,0 @@
-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