code-meter 0.1.0__py3-none-any.whl

code_meter/cli.py

@@ -0,0 +1,334 @@
+
+"""Typer CLI interface for code-meter."""
+
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from code_meter.analytics.reports import ReportGenerator
+from code_meter.config import get_config_file_path, load_config, save_config
+from code_meter.pricing.engine import PricingEngine
+from code_meter.providers.antigravity import AntigravityProvider
+from code_meter.providers.claude_code import ClaudeCodeProvider
+from code_meter.providers.codex import CodexProvider
+from code_meter.storage.database import Database
+from code_meter.storage.repository import UsageRepository
+from code_meter.ui.dashboard import render_dashboard
+from code_meter.ui.tables import (
+    render_daily_table,
+    render_models_table,
+    render_projects_table,
+    render_sessions_table,
+    render_status_panel,
+)
+from code_meter.watcher import run_watch_loop
+
+app = typer.Typer(
+    name="code-meter",
+    help="Local AI coding token usage tracker and cost estimator.",
+    add_completion=False,
+    invoke_without_command=True,
+)
+
+console = Console()
+
+
+def _get_services():
+    """Helper to initialize config, database, repository, pricing engine, and providers."""
+    config = load_config()
+    db_path = config.get_db_path()
+    claude_dir = config.get_claude_dir()
+    codex_dir = config.get_codex_dir()
+    antigravity_dir = config.get_antigravity_dir()
+
+    db = Database(db_path)
+    repository = UsageRepository(db)
+    pricing_engine = PricingEngine(repository)
+
+    providers = [
+        ClaudeCodeProvider(claude_dir),
+        CodexProvider(codex_dir),
+        AntigravityProvider(antigravity_dir),
+    ]
+
+    report_gen = ReportGenerator(pricing_engine)
+
+    return config, repository, pricing_engine, providers, report_gen
+
+
+def _perform_scan(quiet: bool = False) -> int:
+    """Execute scan across all AI providers and return number of new records saved."""
+    config, repo, pricing_engine, providers, _ = _get_services()
+    existing_states = repo.get_scan_states()
+
+    total_new_records = 0
+    total_files_scanned = 0
+
+    for provider in providers:
+        result = provider.scan(existing_states)
+        new_records_count = repo.save_records(result.records)
+        repo.save_prompts(result.prompts)
+        repo.save_code_changes(result.code_changes)
+        repo.update_scan_states(result.updated_states)
+
+        total_new_records += new_records_count
+        total_files_scanned += result.files_scanned
+
+    if not quiet:
+        console.print(
+            f"[bold green]Scan complete:[/bold green] Scanned {total_files_scanned} files across "
+            f"{len(providers)} providers, added {total_new_records} new records."
+        )
+
+    return total_new_records
+
+
+@app.callback()
+def main_callback(ctx: typer.Context):
+    """Default action when running `code-meter` without subcommands."""
+    if ctx.invoked_subcommand is None:
+        _perform_scan(quiet=True)
+        config, repo, pricing_engine, providers, report_gen = _get_services()
+
+        records = repo.query_usage_events()
+        if not records:
+            console.print("[yellow]No usage data available yet.[/yellow]")
+            console.print("[dim]Scanned providers: Claude Code, Codex, Antigravity[/dim]")
+            return
+
+        summary = report_gen.generate_summary(records, filter_date_str=datetime.now(timezone.utc).strftime("%Y-%m-%d"))
+        console.clear()
+        render_dashboard(summary, title_suffix="Overview", console=console)
+
+
+@app.command("scan")
+def scan_cmd():
+    """Scan local Claude Code directories for new token usage records."""
+    _perform_scan(quiet=False)
+
+
+@app.command("today")
+def today_cmd():
+    """Display usage statistics for today."""
+    _perform_scan(quiet=True)
+    _, repo, _, _, report_gen = _get_services()
+
+    today_start = datetime.now(timezone.utc).replace(hour=0, minute=0, second=0, microsecond=0)
+    records = repo.query_usage_events(start_date=today_start)
+
+    if not records:
+        console.print("[yellow]No usage recorded today.[/yellow]")
+        return
+
+    summary = report_gen.generate_summary(records, filter_date_str=today_start.strftime("%Y-%m-%d"))
+    render_dashboard(summary, title_suffix="Today", console=console)
+
+
+@app.command("week")
+def week_cmd():
+    """Display usage statistics for the past 7 days."""
+    _perform_scan(quiet=True)
+    _, repo, _, _, report_gen = _get_services()
+
+    week_start = datetime.now(timezone.utc) - timedelta(days=7)
+    records = repo.query_usage_events(start_date=week_start)
+
+    if not records:
+        console.print("[yellow]No usage recorded in the last 7 days.[/yellow]")
+        return
+
+    summary = report_gen.generate_summary(records, filter_date_str=datetime.now(timezone.utc).strftime("%Y-%m-%d"))
+    render_dashboard(summary, title_suffix="Last 7 Days", console=console)
+
+
+@app.command("month")
+def month_cmd():
+    """Display usage statistics for the past 30 days."""
+    _perform_scan(quiet=True)
+    _, repo, _, _, report_gen = _get_services()
+
+    month_start = datetime.now(timezone.utc) - timedelta(days=30)
+    records = repo.query_usage_events(start_date=month_start)
+
+    if not records:
+        console.print("[yellow]No usage recorded in the last 30 days.[/yellow]")
+        return
+
+    summary = report_gen.generate_summary(records, filter_date_str=datetime.now(timezone.utc).strftime("%Y-%m-%d"))
+    render_dashboard(summary, title_suffix="Last 30 Days", console=console)
+
+
+@app.command("status")
+def status_cmd():
+    """Display system status (DB path, file counts, record totals)."""
+    _perform_scan(quiet=True)
+    _, repo, _, _, _ = _get_services()
+    summary = repo.get_status_summary()
+    render_status_panel(summary, console=console)
+
+
+@app.command("report")
+def report_cmd(
+    model: Optional[str] = typer.Option(None, "--model", help="Filter by model name"),
+    project: Optional[str] = typer.Option(None, "--project", help="Filter by project ID or path"),
+    provider: Optional[str] = typer.Option(None, "--provider", help="Filter by provider"),
+    days: Optional[int] = typer.Option(None, "--days", help="Number of days to include"),
+):
+    """Display detailed aggregated report with optional filters."""
+    _perform_scan(quiet=True)
+    _, repo, pricing_engine, _, report_gen = _get_services()
+
+    start_date = datetime.now(timezone.utc) - timedelta(days=days) if days else None
+    records = repo.query_usage_events(
+        provider=provider,
+        model=model,
+        project_id=project,
+        start_date=start_date,
+    )
+
+    if not records:
+        console.print("[yellow]No matching usage records found.[/yellow]")
+        return
+
+    record_costs_list = [
+        pricing_engine.calculate_cost(
+            r.provider, r.model, r.input_tokens, r.output_tokens, r.cache_read_tokens, r.cache_write_tokens, r.timestamp
+        )
+        for r in records
+    ]
+
+    daily_stats = report_gen.aggregate_by_day(records, record_costs_list)
+    render_daily_table(daily_stats, console=console)
+
+
+@app.command("models")
+def models_cmd():
+    """Display token usage and cost aggregated by model."""
+    _perform_scan(quiet=True)
+    _, repo, pricing_engine, _, report_gen = _get_services()
+    records = repo.query_usage_events()
+    if not records:
+        console.print("[yellow]No usage records found.[/yellow]")
+        return
+
+    costs = [
+        pricing_engine.calculate_cost(
+            r.provider, r.model, r.input_tokens, r.output_tokens, r.cache_read_tokens, r.cache_write_tokens, r.timestamp
+        )
+        for r in records
+    ]
+    model_stats = report_gen.aggregate_by_model(records, costs)
+    render_models_table(model_stats, console=console)
+
+
+@app.command("projects")
+def projects_cmd():
+    """Display token usage and cost aggregated by project/directory."""
+    _perform_scan(quiet=True)
+    _, repo, pricing_engine, _, report_gen = _get_services()
+    records = repo.query_usage_events()
+    if not records:
+        console.print("[yellow]No usage records found.[/yellow]")
+        return
+
+    costs = [
+        pricing_engine.calculate_cost(
+            r.provider, r.model, r.input_tokens, r.output_tokens, r.cache_read_tokens, r.cache_write_tokens, r.timestamp
+        )
+        for r in records
+    ]
+    project_stats = report_gen.aggregate_by_project(records, costs)
+    render_projects_table(project_stats, console=console)
+
+
+@app.command("sessions")
+def sessions_cmd():
+    """Display token usage and cost aggregated by session ID."""
+    _perform_scan(quiet=True)
+    _, repo, pricing_engine, _, report_gen = _get_services()
+    records = repo.query_usage_events()
+    if not records:
+        console.print("[yellow]No usage records found.[/yellow]")
+        return
+
+    costs = [
+        pricing_engine.calculate_cost(
+            r.provider, r.model, r.input_tokens, r.output_tokens, r.cache_read_tokens, r.cache_write_tokens, r.timestamp
+        )
+        for r in records
+    ]
+    session_stats = report_gen.aggregate_by_session(records, costs)
+    render_sessions_table(session_stats, console=console)
+
+
+@app.command("export")
+def export_cmd(
+    format: str = typer.Option("csv", "--format", "-f", help="Export format: csv or json"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file path"),
+    days: Optional[int] = typer.Option(None, "--days", help="Number of days to include"),
+    model: Optional[str] = typer.Option(None, "--model", help="Filter by model"),
+    project: Optional[str] = typer.Option(None, "--project", help="Filter by project"),
+):
+    """Export usage records to CSV or JSON format."""
+    _perform_scan(quiet=True)
+    _, repo, _, _, report_gen = _get_services()
+
+    start_date = datetime.now(timezone.utc) - timedelta(days=days) if days else None
+    records = repo.query_usage_events(model=model, project_id=project, start_date=start_date)
+
+    if not records:
+        console.print("[yellow]No matching records to export.[/yellow]")
+        return
+
+    content = report_gen.export_records(records, format)
+
+    if output:
+        output = Path(output).resolve()
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(content, encoding="utf-8")
+        console.print(f"[bold green]Exported {len(records)} records to:[/bold green] {output}")
+    else:
+        sys.stdout.write(content)
+
+
+@app.command("config")
+def config_cmd():
+    """Display current configuration file path and contents."""
+    config_file = get_config_file_path()
+    config = load_config()
+    console.print(f"[bold cyan]Configuration File:[/bold cyan] {config_file}\n")
+    console.print(f"[bold white]General DB Path:[/bold white]       {config.get_db_path()}")
+    console.print(f"[bold white]Claude Directory:[/bold white]      {config.get_claude_dir()}")
+    console.print(f"[bold white]Codex Directory:[/bold white]       {config.get_codex_dir()}")
+    console.print(f"[bold white]Antigravity Directory:[/bold white] {config.get_antigravity_dir()}")
+    console.print(f"[bold white]Refresh Seconds:[/bold white]       {config.get_refresh_seconds()}")
+    console.print(f"[bold white]Currency:[/bold white]              {config.pricing.currency}")
+
+
+@app.command("watch")
+def watch_cmd():
+    """Monitor local session log files in real-time and auto-update metrics."""
+    config, repo, pricing_engine, providers, report_gen = _get_services()
+
+    def update_and_render():
+        _perform_scan(quiet=True)
+        records = repo.query_usage_events()
+        summary = report_gen.generate_summary(records, filter_date_str=datetime.now(timezone.utc).strftime("%Y-%m-%d"))
+        console.clear()
+        render_dashboard(summary, title_suffix="Watch Mode (Live)", console=console)
+
+    target_dir = providers[0].claude_dir if providers else config.get_claude_dir()
+    run_watch_loop(
+        target_dir=target_dir,
+        on_change_callback=update_and_render,
+        refresh_seconds=config.get_refresh_seconds(),
+        console=console,
+    )
+
+
+if __name__ == "__main__":
+    app()

code_meter/config.py

@@ -0,0 +1,116 @@
+"""Configuration management for code-meter."""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+from pydantic import BaseModel, Field
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore
+
+import tomli_w
+
+
+class GeneralConfig(BaseModel):
+    database: str = "~/.local/share/code-meter/usage.db"
+
+
+class ClaudeCodeConfig(BaseModel):
+    directory: str = "~/.claude"
+
+
+class CodexConfig(BaseModel):
+    directory: str = "~/.codex"
+
+
+class AntigravityConfig(BaseModel):
+    directory: str = "~/.gemini/antigravity-ide"
+
+
+class UIConfig(BaseModel):
+    refresh_seconds: int = 2
+
+
+class PricingConfig(BaseModel):
+    currency: str = "USD"
+
+
+class Config(BaseModel):
+    general: GeneralConfig = Field(default_factory=GeneralConfig)
+    claude_code: ClaudeCodeConfig = Field(default_factory=ClaudeCodeConfig)
+    codex: CodexConfig = Field(default_factory=CodexConfig)
+    antigravity: AntigravityConfig = Field(default_factory=AntigravityConfig)
+    ui: UIConfig = Field(default_factory=UIConfig)
+    pricing: PricingConfig = Field(default_factory=PricingConfig)
+
+    def get_db_path(self) -> Path:
+        raw_db = os.environ.get("CODE_METER_DB", os.environ.get("CLAUDE_METER_DB", self.general.database))
+        path = Path(os.path.expanduser(raw_db)).resolve()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return path
+
+    def get_claude_dir(self) -> Path:
+        raw_dir = os.environ.get("CODE_METER_CLAUDE_DIR", os.environ.get("CLAUDE_METER_CLAUDE_DIR", self.claude_code.directory))
+        return Path(os.path.expanduser(raw_dir)).resolve()
+
+    def get_codex_dir(self) -> Path:
+        raw_dir = os.environ.get("CODE_METER_CODEX_DIR", self.codex.directory)
+        return Path(os.path.expanduser(raw_dir)).resolve()
+
+    def get_antigravity_dir(self) -> Path:
+        raw_dir = os.environ.get("CODE_METER_ANTIGRAVITY_DIR", self.antigravity.directory)
+        return Path(os.path.expanduser(raw_dir)).resolve()
+
+    def get_refresh_seconds(self) -> int:
+        env_val = os.environ.get("CODE_METER_REFRESH", os.environ.get("CLAUDE_METER_REFRESH"))
+        if env_val:
+            try:
+                return int(env_val)
+            except ValueError:
+                pass
+        return self.ui.refresh_seconds
+
+
+def get_config_dir() -> Path:
+    """Get platform-appropriate config directory (~/.config/code-meter or %APPDATA%/code-meter)."""
+    if os.name == "nt":
+        base = os.environ.get("APPDATA")
+        if base:
+            path = Path(base) / "code-meter"
+        else:
+            path = Path.home() / ".config" / "code-meter"
+    else:
+        path = Path.home() / ".config" / "code-meter"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def get_config_file_path() -> Path:
+    return get_config_dir() / "config.toml"
+
+
+def load_config() -> Config:
+    """Load configuration from config.toml, returning default config if not present."""
+    config_file = get_config_file_path()
+    if not config_file.exists():
+        config = Config()
+        save_config(config)
+        return config
+
+    try:
+        with open(config_file, "rb") as f:
+            data = tomllib.load(f)
+        return Config(**data)
+    except Exception:
+        return Config()
+
+
+def save_config(config: Config) -> Path:
+    """Save configuration to config.toml."""
+    config_file = get_config_file_path()
+    data = config.model_dump()
+    with open(config_file, "wb") as f:
+        tomli_w.dump(data, f)
+    return config_file

code_meter/models/__init__.py

@@ -0,0 +1,13 @@
+"""Data models for code-meter."""
+
+from code_meter.models.usage import UsageRecord
+from code_meter.models.project import ProjectStats, ModelStats, SessionStats, DailyStats, AggregateSummary
+
+__all__ = [
+    "UsageRecord",
+    "ProjectStats",
+    "ModelStats",
+    "SessionStats",
+    "DailyStats",
+    "AggregateSummary",
+]

code_meter/models/project.py

@@ -0,0 +1,85 @@
+"""Analytics summary models for reporting and UI."""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+
+class ModelStats(BaseModel):
+    """Token usage and cost aggregated by model."""
+
+    model: str
+    request_count: int = 0
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_write_tokens: int = 0
+    total_tokens: int = 0
+    estimated_cost_usd: Optional[float] = None
+
+
+class ProjectStats(BaseModel):
+    """Token usage and cost aggregated by project/directory."""
+
+    project_name: str
+    project_path: Optional[str] = None
+    request_count: int = 0
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_write_tokens: int = 0
+    total_tokens: int = 0
+    estimated_cost_usd: Optional[float] = None
+
+
+class SessionStats(BaseModel):
+    """Token usage and cost aggregated by session ID."""
+
+    session_id: str
+    project_name: str = "Unknown"
+    project_path: Optional[str] = None
+    primary_model: str = "Unknown"
+    request_count: int = 0
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_write_tokens: int = 0
+    total_tokens: int = 0
+    estimated_cost_usd: Optional[float] = None
+    first_seen: Optional[str] = None
+    last_seen: Optional[str] = None
+
+
+class DailyStats(BaseModel):
+    """Token usage and cost aggregated by date (YYYY-MM-DD)."""
+
+    date_str: str
+    request_count: int = 0
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_write_tokens: int = 0
+    total_tokens: int = 0
+    estimated_cost_usd: Optional[float] = None
+
+
+class AggregateSummary(BaseModel):
+    """Overall token usage, cost, and burn rate summary."""
+
+    total_requests: int = 0
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_write_tokens: int = 0
+    total_tokens: int = 0
+
+    estimated_cost_usd: Optional[float] = None
+    unpriced_requests: int = 0
+
+    tokens_per_hour: Optional[float] = None
+    tokens_per_day: Optional[float] = None
+    cost_per_hour: Optional[float] = None
+    cost_per_day: Optional[float] = None
+
+    by_model: List[ModelStats] = Field(default_factory=list)
+    by_project: List[ProjectStats] = Field(default_factory=list)
+    today_summary: Optional[DailyStats] = None

code_meter/models/usage.py

@@ -0,0 +1,61 @@
+"""Normalized UsageRecord, SessionPrompt, and SessionCodeChange models."""
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+from pydantic import BaseModel, Field
+
+
+class UsageRecord(BaseModel):
+    """Normalized usage event from any AI provider."""
+
+    provider: str
+    request_id: Optional[str] = None
+    session_id: Optional[str] = None
+    timestamp: datetime
+
+    user_id: Optional[str] = None
+    project_id: Optional[str] = None
+    project_path: Optional[str] = None
+
+    model: str
+
+    input_tokens: int = 0
+    output_tokens: int = 0
+
+    cache_read_tokens: int = 0
+    cache_write_tokens: int = 0
+
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+    # Agent-level tracking readiness
+    agent_id: Optional[str] = None
+    task_id: Optional[str] = None
+    tool_name: Optional[str] = None
+
+    @property
+    def total_tokens(self) -> int:
+        return self.input_tokens + self.output_tokens + self.cache_read_tokens + self.cache_write_tokens
+
+
+class SessionPrompt(BaseModel):
+    """Record of a user prompt asked during an AI session."""
+
+    provider: str
+    session_id: str
+    prompt_id: str
+    timestamp: datetime
+    prompt_text: str
+    project_id: Optional[str] = None
+
+
+class SessionCodeChange(BaseModel):
+    """Record of code changes / diffs made during an AI session."""
+
+    provider: str
+    session_id: str
+    change_id: str
+    timestamp: datetime
+    file_path: str
+    change_type: str  # e.g., 'edit', 'write', 'snapshot', 'tool_call'
+    diff_summary: str
+    project_id: Optional[str] = None

code_meter/pricing/__init__.py

@@ -0,0 +1,14 @@
+"""Pricing engine package."""
+
+from code_meter.pricing.anthropic import DEFAULT_ANTHROPIC_PRICING
+from code_meter.pricing.engine import DEFAULT_PRICING, PricingEngine
+from code_meter.pricing.google import DEFAULT_GOOGLE_PRICING
+from code_meter.pricing.openai import DEFAULT_OPENAI_PRICING
+
+__all__ = [
+    "PricingEngine",
+    "DEFAULT_PRICING",
+    "DEFAULT_ANTHROPIC_PRICING",
+    "DEFAULT_OPENAI_PRICING",
+    "DEFAULT_GOOGLE_PRICING",
+]