klaude-code 1.7.1__tar.gz → 1.8.0__tar.gz

{klaude_code-1.7.1 → klaude_code-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.7.1
+Version: 1.8.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
@@ -297,6 +297,18 @@ klaude session clean --min 10
 klaude session clean-all
 ```
 
+### Cost Tracking
+
+View aggregated usage statistics across all sessions:
+
+```bash
+# Show all historical usage data
+klaude cost
+
+# Show usage for the last 7 days only
+klaude cost --days 7
+```
+
 ### Slash Commands
 
 Inside the interactive session (`klaude`), use these commands to streamline your workflow:

{klaude_code-1.7.1 → klaude_code-1.8.0}/README.md

@@ -276,6 +276,18 @@ klaude session clean --min 10
 klaude session clean-all
 ```
 
+### Cost Tracking
+
+View aggregated usage statistics across all sessions:
+
+```bash
+# Show all historical usage data
+klaude cost
+
+# Show usage for the last 7 days only
+klaude cost --days 7
+```
+
 ### Slash Commands
 
 Inside the interactive session (`klaude`), use these commands to streamline your workflow:

{klaude_code-1.7.1 → klaude_code-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.7.1"
+version = "1.8.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"

klaude_code-1.8.0/src/klaude_code/cli/cost_cmd.py

@@ -0,0 +1,338 @@
+"""Cost command for aggregating usage statistics across all sessions."""
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+
+from rich.box import Box
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from klaude_code.command.status_cmd import format_cost, format_tokens
+from klaude_code.protocol import model
+from klaude_code.session.codec import decode_jsonl_line
+
+ASCII_HORIZONAL = Box(" -- \n    \n -- \n    \n -- \n -- \n    \n -- \n")
+
+
+@dataclass
+class ModelUsageStats:
+    """Aggregated usage stats for a single model."""
+
+    model_name: str
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cached_tokens: int = 0
+    cost_usd: float = 0.0
+    cost_cny: float = 0.0
+
+    @property
+    def total_tokens(self) -> int:
+        return self.input_tokens + self.output_tokens
+
+    def add_usage(self, usage: model.Usage) -> None:
+        self.input_tokens += usage.input_tokens
+        self.output_tokens += usage.output_tokens
+        self.cached_tokens += usage.cached_tokens
+        if usage.total_cost is not None:
+            if usage.currency == "CNY":
+                self.cost_cny += usage.total_cost
+            else:
+                self.cost_usd += usage.total_cost
+
+
+@dataclass
+class DailyStats:
+    """Aggregated stats for a single day."""
+
+    date: str
+    by_model: dict[str, ModelUsageStats] = field(default_factory=lambda: dict[str, ModelUsageStats]())
+
+    def add_task_metadata(self, meta: model.TaskMetadata, date_str: str) -> None:
+        """Add a TaskMetadata to this day's stats."""
+        del date_str  # unused, date is already set
+        if not meta.usage or not meta.model_name:
+            return
+
+        model_key = meta.model_name
+        if model_key not in self.by_model:
+            self.by_model[model_key] = ModelUsageStats(model_name=model_key)
+
+        self.by_model[model_key].add_usage(meta.usage)
+
+    def get_subtotal(self) -> ModelUsageStats:
+        """Get subtotal across all models for this day."""
+        subtotal = ModelUsageStats(model_name="(subtotal)")
+        for stats in self.by_model.values():
+            subtotal.input_tokens += stats.input_tokens
+            subtotal.output_tokens += stats.output_tokens
+            subtotal.cached_tokens += stats.cached_tokens
+            subtotal.cost_usd += stats.cost_usd
+            subtotal.cost_cny += stats.cost_cny
+        return subtotal
+
+
+def iter_all_sessions() -> list[tuple[str, Path]]:
+    """Iterate over all sessions across all projects.
+
+    Returns list of (session_id, events_file_path) tuples.
+    """
+    projects_dir = Path.home() / ".klaude" / "projects"
+    if not projects_dir.exists():
+        return []
+
+    sessions: list[tuple[str, Path]] = []
+    for project_dir in projects_dir.iterdir():
+        if not project_dir.is_dir():
+            continue
+        sessions_dir = project_dir / "sessions"
+        if not sessions_dir.exists():
+            continue
+        for session_dir in sessions_dir.iterdir():
+            if not session_dir.is_dir():
+                continue
+            events_file = session_dir / "events.jsonl"
+            meta_file = session_dir / "meta.json"
+            # Skip sub-agent sessions by checking meta.json
+            if meta_file.exists():
+                import json
+
+                try:
+                    meta = json.loads(meta_file.read_text(encoding="utf-8"))
+                    if meta.get("sub_agent_state") is not None:
+                        continue
+                except (json.JSONDecodeError, OSError):
+                    pass
+            if events_file.exists():
+                sessions.append((session_dir.name, events_file))
+
+    return sessions
+
+
+def extract_task_metadata_from_events(events_path: Path) -> list[tuple[str, model.TaskMetadataItem]]:
+    """Extract TaskMetadataItem entries from events.jsonl with their dates.
+
+    Returns list of (date_str, TaskMetadataItem) tuples.
+    """
+    results: list[tuple[str, model.TaskMetadataItem]] = []
+    try:
+        content = events_path.read_text(encoding="utf-8")
+    except OSError:
+        return results
+
+    for line in content.splitlines():
+        item = decode_jsonl_line(line)
+        if isinstance(item, model.TaskMetadataItem):
+            date_str = item.created_at.strftime("%Y-%m-%d")
+            results.append((date_str, item))
+
+    return results
+
+
+def aggregate_all_sessions() -> dict[str, DailyStats]:
+    """Aggregate usage stats from all sessions, grouped by date.
+
+    Returns dict mapping date string to DailyStats.
+    """
+    daily_stats: dict[str, DailyStats] = defaultdict(lambda: DailyStats(date=""))
+
+    sessions = iter_all_sessions()
+    for _session_id, events_path in sessions:
+        metadata_items = extract_task_metadata_from_events(events_path)
+        for date_str, metadata_item in metadata_items:
+            if daily_stats[date_str].date == "":
+                daily_stats[date_str] = DailyStats(date=date_str)
+
+            # Process main agent metadata
+            daily_stats[date_str].add_task_metadata(metadata_item.main_agent, date_str)
+
+            # Process sub-agent metadata
+            for sub_meta in metadata_item.sub_agent_task_metadata:
+                daily_stats[date_str].add_task_metadata(sub_meta, date_str)
+
+    return dict(daily_stats)
+
+
+def format_cost_dual(cost_usd: float, cost_cny: float) -> tuple[str, str]:
+    """Format costs for both currencies."""
+    usd_str = format_cost(cost_usd if cost_usd > 0 else None, "USD")
+    cny_str = format_cost(cost_cny if cost_cny > 0 else None, "CNY")
+    return usd_str, cny_str
+
+
+def format_date_display(date_str: str) -> str:
+    """Format date string YYYY-MM-DD to 'YYYY M-D' for table display."""
+    parts = date_str.split("-")
+    if len(parts) == 3:
+        month = int(parts[1])
+        day = int(parts[2])
+        return f"{parts[0]} {month}-{day}"
+    return date_str
+
+
+def render_cost_table(daily_stats: dict[str, DailyStats]) -> Table:
+    """Render the cost table using rich."""
+    table = Table(
+        title="Usage Statistics",
+        show_header=True,
+        header_style="bold",
+        padding=(0, 1, 0, 2),
+        box=ASCII_HORIZONAL,
+    )
+
+    table.add_column("Date", style="cyan", no_wrap=True)
+    table.add_column("Model", no_wrap=True)
+    table.add_column("Input", justify="right", no_wrap=True)
+    table.add_column("Output", justify="right", no_wrap=True)
+    table.add_column("Cache", justify="right", no_wrap=True)
+    table.add_column("Total", justify="right", no_wrap=True)
+    table.add_column("USD", justify="right", no_wrap=True)
+    table.add_column("CNY", justify="right", no_wrap=True)
+
+    # Sort dates
+    sorted_dates = sorted(daily_stats.keys())
+
+    # Track global totals by model
+    global_by_model: dict[str, ModelUsageStats] = {}
+
+    def sort_by_cost(stats: ModelUsageStats) -> tuple[float, float]:
+        """Sort key: USD desc, then CNY desc."""
+        return (-stats.cost_usd, -stats.cost_cny)
+
+    for date_str in sorted_dates:
+        day = daily_stats[date_str]
+        sorted_models = [s.model_name for s in sorted(day.by_model.values(), key=sort_by_cost)]
+
+        first_row = True
+        for model_name in sorted_models:
+            stats = day.by_model[model_name]
+            usd_str, cny_str = format_cost_dual(stats.cost_usd, stats.cost_cny)
+
+            # Accumulate to global totals
+            if model_name not in global_by_model:
+                global_by_model[model_name] = ModelUsageStats(model_name=model_name)
+            global_by_model[model_name].input_tokens += stats.input_tokens
+            global_by_model[model_name].output_tokens += stats.output_tokens
+            global_by_model[model_name].cached_tokens += stats.cached_tokens
+            global_by_model[model_name].cost_usd += stats.cost_usd
+            global_by_model[model_name].cost_cny += stats.cost_cny
+
+            table.add_row(
+                format_date_display(date_str) if first_row else "",
+                f"- {model_name}",
+                format_tokens(stats.input_tokens),
+                format_tokens(stats.output_tokens),
+                format_tokens(stats.cached_tokens),
+                format_tokens(stats.total_tokens),
+                usd_str,
+                cny_str,
+            )
+            first_row = False
+
+        # Add subtotal row for this day
+        subtotal = day.get_subtotal()
+        usd_str, cny_str = format_cost_dual(subtotal.cost_usd, subtotal.cost_cny)
+        table.add_row(
+            "",
+            "[cyan]  (subtotal)[/cyan]",
+            f"[cyan]{format_tokens(subtotal.input_tokens)}[/cyan]",
+            f"[cyan]{format_tokens(subtotal.output_tokens)}[/cyan]",
+            f"[cyan]{format_tokens(subtotal.cached_tokens)}[/cyan]",
+            f"[cyan]{format_tokens(subtotal.total_tokens)}[/cyan]",
+            f"[cyan]{usd_str}[/cyan]",
+            f"[cyan]{cny_str}[/cyan]",
+        )
+
+        # Add separator between days
+        if date_str != sorted_dates[-1]:
+            table.add_section()
+
+    # Add final section for totals
+    table.add_section()
+
+    # Build date range label for Total
+    if sorted_dates:
+        first_date = format_date_display(sorted_dates[0])
+        last_date = format_date_display(sorted_dates[-1])
+        if first_date == last_date:
+            total_label = f"[bold]Total[/bold]\n[dim]{first_date}[/dim]"
+        else:
+            total_label = f"[bold]Total[/bold]\n[dim]{first_date} ~[/dim]\n[dim]{last_date}[/dim]"
+    else:
+        total_label = "[bold]Total[/bold]"
+
+    # Add per-model totals
+    sorted_global_models = [s.model_name for s in sorted(global_by_model.values(), key=sort_by_cost)]
+    first_total_row = True
+    for model_name in sorted_global_models:
+        stats = global_by_model[model_name]
+        usd_str, cny_str = format_cost_dual(stats.cost_usd, stats.cost_cny)
+        table.add_row(
+            total_label if first_total_row else "",
+            f"- {model_name}",
+            format_tokens(stats.input_tokens),
+            format_tokens(stats.output_tokens),
+            format_tokens(stats.cached_tokens),
+            format_tokens(stats.total_tokens),
+            usd_str,
+            cny_str,
+        )
+        first_total_row = False
+
+    # Add grand total row
+    grand_total = ModelUsageStats(model_name="(total)")
+    for stats in global_by_model.values():
+        grand_total.input_tokens += stats.input_tokens
+        grand_total.output_tokens += stats.output_tokens
+        grand_total.cached_tokens += stats.cached_tokens
+        grand_total.cost_usd += stats.cost_usd
+        grand_total.cost_cny += stats.cost_cny
+
+    usd_str, cny_str = format_cost_dual(grand_total.cost_usd, grand_total.cost_cny)
+    table.add_row(
+        "",
+        "[bold]  (total)[/bold]",
+        f"[bold]{format_tokens(grand_total.input_tokens)}[/bold]",
+        f"[bold]{format_tokens(grand_total.output_tokens)}[/bold]",
+        f"[bold]{format_tokens(grand_total.cached_tokens)}[/bold]",
+        f"[bold]{format_tokens(grand_total.total_tokens)}[/bold]",
+        f"[bold]{usd_str}[/bold]",
+        f"[bold]{cny_str}[/bold]",
+    )
+
+    return table
+
+
+def cost_command(
+    days: int | None = typer.Option(None, "--days", "-d", help="Limit to last N days"),
+) -> None:
+    """Display aggregated usage statistics across all sessions."""
+    daily_stats = aggregate_all_sessions()
+
+    if not daily_stats:
+        typer.echo("No usage data found.")
+        raise typer.Exit(0)
+
+    # Filter by days if specified
+    if days is not None:
+        cutoff = datetime.now().strftime("%Y-%m-%d")
+        from datetime import timedelta
+
+        cutoff_date = datetime.now() - timedelta(days=days)
+        cutoff = cutoff_date.strftime("%Y-%m-%d")
+        daily_stats = {k: v for k, v in daily_stats.items() if k >= cutoff}
+
+    if not daily_stats:
+        typer.echo(f"No usage data found in the last {days} days.")
+        raise typer.Exit(0)
+
+    table = render_cost_table(daily_stats)
+    console = Console()
+    console.print(table)
+
+
+def register_cost_commands(app: typer.Typer) -> None:
+    """Register cost command to the given Typer app."""
+    app.command("cost")(cost_command)

{klaude_code-1.7.1 → klaude_code-1.8.0}/src/klaude_code/cli/main.py

@@ -8,6 +8,7 @@ import typer
 
 from klaude_code.cli.auth_cmd import register_auth_commands
 from klaude_code.cli.config_cmd import register_config_commands
+from klaude_code.cli.cost_cmd import register_cost_commands
 from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, resolve_debug_settings
 from klaude_code.cli.self_update import register_self_update_commands, version_option_callback
 from klaude_code.cli.session_cmd import register_session_commands
@@ -115,6 +116,7 @@ app = typer.Typer(
 register_session_commands(app)
 register_auth_commands(app)
 register_config_commands(app)
+register_cost_commands(app)
 
 register_self_update_commands(app)
 

{klaude_code-1.7.1 → klaude_code-1.8.0}/src/klaude_code/command/status_cmd.py

@@ -64,7 +64,7 @@ def accumulate_session_usage(session: Session) -> AggregatedUsage:
     return AggregatedUsage(total=total, by_model=by_model, task_count=task_count)
 
 
-def _format_tokens(tokens: int) -> str:
+def format_tokens(tokens: int) -> str:
     """Format token count with K/M suffix for readability."""
     if tokens >= 1_000_000:
         return f"{tokens / 1_000_000:.2f}M"
@@ -73,7 +73,7 @@ def _format_tokens(tokens: int) -> str:
     return str(tokens)
 
 
-def _format_cost(cost: float | None, currency: str = "USD") -> str:
+def format_cost(cost: float | None, currency: str = "USD") -> str:
     """Format cost with currency symbol."""
     if cost is None:
         return "-"
@@ -93,13 +93,13 @@ def _format_model_usage_line(meta: model.TaskMetadata) -> str:
     if not usage:
         return f"      {model_label}: no usage data"
 
-    cost_str = _format_cost(usage.total_cost, usage.currency)
+    cost_str = format_cost(usage.total_cost, usage.currency)
     return (
         f"      {model_label}: "
-        f"{_format_tokens(usage.input_tokens)} input, "
-        f"{_format_tokens(usage.output_tokens)} output, "
-        f"{_format_tokens(usage.cached_tokens)} cache read, "
-        f"{_format_tokens(usage.reasoning_tokens)} thinking, "
+        f"{format_tokens(usage.input_tokens)} input, "
+        f"{format_tokens(usage.output_tokens)} output, "
+        f"{format_tokens(usage.cached_tokens)} cache read, "
+        f"{format_tokens(usage.reasoning_tokens)} thinking, "
         f"({cost_str})"
     )
 
@@ -109,7 +109,7 @@ def format_status_content(aggregated: AggregatedUsage) -> str:
     lines: list[str] = []
 
     # Total cost line
-    total_cost_str = _format_cost(aggregated.total.total_cost, aggregated.total.currency)
+    total_cost_str = format_cost(aggregated.total.total_cost, aggregated.total.currency)
     lines.append(f"Total cost: {total_cost_str}")
 
     # Per-model breakdown

{klaude_code-1.7.1 → klaude_code-1.8.0}/src/klaude_code/ui/terminal/selector.py

@@ -145,6 +145,19 @@ def _indent_multiline_tokens(
     return out
 
 
+def _normalize_search_key(value: str) -> str:
+    """Normalize a search key for loose matching.
+
+    This enables aliases like:
+    - gpt52 -> gpt-5.2
+    - gpt5.2 -> gpt-5.2
+
+    Strategy: case-fold + keep only alphanumeric characters.
+    """
+
+    return "".join(ch for ch in value.casefold() if ch.isalnum())
+
+
 def _filter_items[T](
     items: list[SelectItem[T]],
     filter_text: str,
@@ -155,8 +168,18 @@ def _filter_items[T](
     if not filter_text:
         return list(range(len(items))), True
 
-    needle = filter_text.lower()
-    matched = [i for i, it in enumerate(items) if needle in it.search_text.lower()]
+    needle = filter_text.casefold()
+    needle_norm = _normalize_search_key(filter_text)
+
+    def _is_match(it: SelectItem[T]) -> bool:
+        haystack = it.search_text.casefold()
+        if needle in haystack:
+            return True
+        if needle_norm:
+            return needle_norm in _normalize_search_key(it.search_text)
+        return False
+
+    matched = [i for i, it in enumerate(items) if _is_match(it)]
     if matched:
         return matched, True
     return list(range(len(items))), False