code-meter 0.1.0__py3-none-any.whl

code_meter/storage/repository.py

@@ -0,0 +1,482 @@
+"""Repository for database persistence of usage records, prompts, code changes, scan state, and pricing."""
+
+import json
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from code_meter.models.usage import SessionCodeChange, SessionPrompt, UsageRecord
+from code_meter.providers.base import FileScanState
+from code_meter.storage.database import Database
+
+logger = logging.getLogger(__name__)
+
+
+class UsageRepository:
+    """DAO for usage events, prompts, code changes, scan states, and pricing lookup."""
+
+    def __init__(self, db: Database):
+        self.db = db
+        self.db.initialize_schema()
+
+    def save_records(self, records: List[UsageRecord]) -> int:
+        """Batch insert usage records into SQLite, ignoring duplicates based on UNIQUE(provider, request_id)."""
+        if not records:
+            return 0
+
+        inserted_count = 0
+        now_str = datetime.now(timezone.utc).isoformat()
+
+        conn = self.db.get_connection()
+        try:
+            cursor = conn.cursor()
+            query = """
+                INSERT OR IGNORE INTO usage_events (
+                    provider, request_id, session_id, timestamp,
+                    user_id, project_id, project_path, model,
+                    input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+                    metadata_json, agent_id, task_id, tool_name, created_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
+            """
+
+            batch_data = []
+            for r in records:
+                meta_json = json.dumps(r.metadata) if r.metadata else None
+                ts_str = r.timestamp.isoformat() if isinstance(r.timestamp, datetime) else str(r.timestamp)
+                batch_data.append((
+                    r.provider,
+                    r.request_id,
+                    r.session_id,
+                    ts_str,
+                    r.user_id,
+                    r.project_id,
+                    r.project_path,
+                    r.model,
+                    r.input_tokens,
+                    r.output_tokens,
+                    r.cache_read_tokens,
+                    r.cache_write_tokens,
+                    meta_json,
+                    r.agent_id,
+                    r.task_id,
+                    r.tool_name,
+                    now_str,
+                ))
+
+            cursor.executemany(query, batch_data)
+            inserted_count = cursor.rowcount if cursor.rowcount > 0 else 0
+            conn.commit()
+        except Exception as e:
+            conn.rollback()
+            logger.error(f"Error saving records to database: {e}", exc_info=True)
+            raise
+        finally:
+            conn.close()
+
+        return inserted_count
+
+    def save_prompts(self, prompts: List[SessionPrompt]) -> int:
+        """Batch insert user session prompts into SQLite."""
+        if not prompts:
+            return 0
+
+        now_str = datetime.now(timezone.utc).isoformat()
+        conn = self.db.get_connection()
+        inserted_count = 0
+        try:
+            cursor = conn.cursor()
+            query = """
+                INSERT OR IGNORE INTO session_prompts (
+                    provider, session_id, prompt_id, timestamp, prompt_text, project_id, created_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?);
+            """
+            batch_data = [
+                (
+                    p.provider,
+                    p.session_id,
+                    p.prompt_id,
+                    p.timestamp.isoformat() if isinstance(p.timestamp, datetime) else str(p.timestamp),
+                    p.prompt_text,
+                    p.project_id,
+                    now_str,
+                )
+                for p in prompts
+            ]
+            cursor.executemany(query, batch_data)
+            inserted_count = cursor.rowcount if cursor.rowcount > 0 else 0
+            conn.commit()
+        finally:
+            conn.close()
+
+        return inserted_count
+
+    def save_code_changes(self, changes: List[SessionCodeChange]) -> int:
+        """Batch insert session code changes / diffs into SQLite."""
+        if not changes:
+            return 0
+
+        now_str = datetime.now(timezone.utc).isoformat()
+        conn = self.db.get_connection()
+        inserted_count = 0
+        try:
+            cursor = conn.cursor()
+            query = """
+                INSERT OR IGNORE INTO session_code_changes (
+                    provider, session_id, change_id, timestamp, file_path, change_type, diff_summary, project_id, created_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);
+            """
+            batch_data = [
+                (
+                    c.provider,
+                    c.session_id,
+                    c.change_id,
+                    c.timestamp.isoformat() if isinstance(c.timestamp, datetime) else str(c.timestamp),
+                    c.file_path,
+                    c.change_type,
+                    c.diff_summary,
+                    c.project_id,
+                    now_str,
+                )
+                for c in changes
+            ]
+            cursor.executemany(query, batch_data)
+            inserted_count = cursor.rowcount if cursor.rowcount > 0 else 0
+            conn.commit()
+        finally:
+            conn.close()
+
+        return inserted_count
+
+    def get_scan_states(self) -> Dict[str, FileScanState]:
+        """Load scan states for incremental scanning."""
+        states: Dict[str, FileScanState] = {}
+        conn = self.db.get_connection()
+        try:
+            cursor = conn.cursor()
+            cursor.execute("SELECT file_path, file_size, modified_time, read_offset FROM scan_state;")
+            for row in cursor.fetchall():
+                states[row["file_path"]] = FileScanState(
+                    file_path=row["file_path"],
+                    file_size=row["file_size"],
+                    modified_time=row["modified_time"],
+                    read_offset=row["read_offset"],
+                )
+        finally:
+            conn.close()
+        return states
+
+    def update_scan_states(self, states: List[FileScanState]) -> None:
+        """Upsert file scan states."""
+        if not states:
+            return
+        now_str = datetime.now(timezone.utc).isoformat()
+        conn = self.db.get_connection()
+        try:
+            cursor = conn.cursor()
+            query = """
+                INSERT INTO scan_state (file_path, file_size, modified_time, read_offset, updated_at)
+                VALUES (?, ?, ?, ?, ?)
+                ON CONFLICT(file_path) DO UPDATE SET
+                    file_size = excluded.file_size,
+                    modified_time = excluded.modified_time,
+                    read_offset = excluded.read_offset,
+                    updated_at = excluded.updated_at;
+            """
+            batch_data = [(s.file_path, s.file_size, s.modified_time, s.read_offset, now_str) for s in states]
+            cursor.executemany(query, batch_data)
+            conn.commit()
+        finally:
+            conn.close()
+
+    def save_pricing(self, pricing_records: List[Dict[str, Any]]) -> None:
+        """Upsert model pricing definitions into SQLite."""
+        if not pricing_records:
+            return
+        conn = self.db.get_connection()
+        try:
+            cursor = conn.cursor()
+            query = """
+                INSERT INTO pricing (
+                    provider, model, input_price_per_million, output_price_per_million,
+                    cache_read_price_per_million, cache_write_price_per_million, effective_from
+                ) VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(provider, model, effective_from) DO UPDATE SET
+                    input_price_per_million = excluded.input_price_per_million,
+                    output_price_per_million = excluded.output_price_per_million,
+                    cache_read_price_per_million = excluded.cache_read_price_per_million,
+                    cache_write_price_per_million = excluded.cache_write_price_per_million;
+            """
+            batch_data = [
+                (
+                    p["provider"],
+                    p["model"],
+                    p["input_price_per_million"],
+                    p["output_price_per_million"],
+                    p.get("cache_read_price_per_million", 0.0),
+                    p.get("cache_write_price_per_million", 0.0),
+                    p.get("effective_from", "2020-01-01T00:00:00Z"),
+                )
+                for p in pricing_records
+            ]
+            cursor.executemany(query, batch_data)
+            conn.commit()
+        finally:
+            conn.close()
+
+    def get_pricing_table(self) -> List[Dict[str, Any]]:
+        """Retrieve all pricing entries."""
+        conn = self.db.get_connection()
+        try:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                SELECT provider, model, input_price_per_million, output_price_per_million,
+                       cache_read_price_per_million, cache_write_price_per_million, effective_from
+                FROM pricing
+                ORDER BY provider, model, effective_from DESC;
+                """
+            )
+            return [dict(row) for row in cursor.fetchall()]
+        finally:
+            conn.close()
+
+    def query_usage_events(
+        self,
+        provider: Optional[str] = None,
+        model: Optional[str] = None,
+        project_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        limit: Optional[int] = None,
+    ) -> List[UsageRecord]:
+        """Query usage events with flexible filtering options."""
+        conditions: List[str] = []
+        params: List[Any] = []
+
+        if provider:
+            conditions.append("provider = ?")
+            params.append(provider)
+        if model:
+            conditions.append("model LIKE ?")
+            params.append(f"%{model}%")
+        if project_id:
+            conditions.append("(project_id LIKE ? OR project_path LIKE ?)")
+            params.append(f"%{project_id}%")
+            params.append(f"%{project_id}%")
+        if session_id:
+            conditions.append("session_id = ?")
+            params.append(session_id)
+        if start_date:
+            conditions.append("timestamp >= ?")
+            params.append(start_date.isoformat())
+        if end_date:
+            conditions.append("timestamp <= ?")
+            params.append(end_date.isoformat())
+
+        where_clause = f"WHERE {' AND '.join(conditions)}" if conditions else ""
+        limit_clause = f"LIMIT {limit}" if limit else ""
+
+        query = f"""
+            SELECT provider, request_id, session_id, timestamp,
+                   user_id, project_id, project_path, model,
+                   input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+                   metadata_json, agent_id, task_id, tool_name
+            FROM usage_events
+            {where_clause}
+            ORDER BY timestamp DESC
+            {limit_clause};
+        """
+
+        conn = self.db.get_connection()
+        records: List[UsageRecord] = []
+        try:
+            cursor = conn.cursor()
+            cursor.execute(query, params)
+            for row in cursor.fetchall():
+                meta = json.loads(row["metadata_json"]) if row["metadata_json"] else {}
+                ts_val = row["timestamp"]
+                try:
+                    ts = datetime.fromisoformat(ts_val)
+                except ValueError:
+                    ts = datetime.now(timezone.utc)
+
+                records.append(
+                    UsageRecord(
+                        provider=row["provider"],
+                        request_id=row["request_id"],
+                        session_id=row["session_id"],
+                        timestamp=ts,
+                        user_id=row["user_id"],
+                        project_id=row["project_id"],
+                        project_path=row["project_path"],
+                        model=row["model"],
+                        input_tokens=row["input_tokens"],
+                        output_tokens=row["output_tokens"],
+                        cache_read_tokens=row["cache_read_tokens"],
+                        cache_write_tokens=row["cache_write_tokens"],
+                        metadata=meta,
+                        agent_id=row["agent_id"],
+                        task_id=row["task_id"],
+                        tool_name=row["tool_name"],
+                    )
+                )
+        finally:
+            conn.close()
+
+        return records
+
+    def query_prompts(
+        self,
+        session_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+        limit: Optional[int] = 50,
+    ) -> List[SessionPrompt]:
+        """Query user prompts asked per session or project."""
+        conditions: List[str] = []
+        params: List[Any] = []
+
+        if session_id:
+            conditions.append("session_id = ?")
+            params.append(session_id)
+        if project_id:
+            conditions.append("project_id LIKE ?")
+            params.append(f"%{project_id}%")
+
+        where_clause = f"WHERE {' AND '.join(conditions)}" if conditions else ""
+        limit_clause = f"LIMIT {limit}" if limit else ""
+
+        query = f"""
+            SELECT provider, session_id, prompt_id, timestamp, prompt_text, project_id
+            FROM session_prompts
+            {where_clause}
+            ORDER BY timestamp DESC
+            {limit_clause};
+        """
+
+        conn = self.db.get_connection()
+        prompts: List[SessionPrompt] = []
+        try:
+            cursor = conn.cursor()
+            cursor.execute(query, params)
+            for row in cursor.fetchall():
+                ts_val = row["timestamp"]
+                try:
+                    ts = datetime.fromisoformat(ts_val)
+                except ValueError:
+                    ts = datetime.now(timezone.utc)
+
+                prompts.append(
+                    SessionPrompt(
+                        provider=row["provider"],
+                        session_id=row["session_id"],
+                        prompt_id=row["prompt_id"],
+                        timestamp=ts,
+                        prompt_text=row["prompt_text"],
+                        project_id=row["project_id"],
+                    )
+                )
+        finally:
+            conn.close()
+
+        return prompts
+
+    def query_code_changes(
+        self,
+        session_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+        file_path: Optional[str] = None,
+        limit: Optional[int] = 50,
+    ) -> List[SessionCodeChange]:
+        """Query code changes / diff history per session or file."""
+        conditions: List[str] = []
+        params: List[Any] = []
+
+        if session_id:
+            conditions.append("session_id = ?")
+            params.append(session_id)
+        if project_id:
+            conditions.append("project_id LIKE ?")
+            params.append(f"%{project_id}%")
+        if file_path:
+            conditions.append("file_path LIKE ?")
+            params.append(f"%{file_path}%")
+
+        where_clause = f"WHERE {' AND '.join(conditions)}" if conditions else ""
+        limit_clause = f"LIMIT {limit}" if limit else ""
+
+        query = f"""
+            SELECT provider, session_id, change_id, timestamp, file_path, change_type, diff_summary, project_id
+            FROM session_code_changes
+            {where_clause}
+            ORDER BY timestamp DESC
+            {limit_clause};
+        """
+
+        conn = self.db.get_connection()
+        changes: List[SessionCodeChange] = []
+        try:
+            cursor = conn.cursor()
+            cursor.execute(query, params)
+            for row in cursor.fetchall():
+                ts_val = row["timestamp"]
+                try:
+                    ts = datetime.fromisoformat(ts_val)
+                except ValueError:
+                    ts = datetime.now(timezone.utc)
+
+                changes.append(
+                    SessionCodeChange(
+                        provider=row["provider"],
+                        session_id=row["session_id"],
+                        change_id=row["change_id"],
+                        timestamp=ts,
+                        file_path=row["file_path"],
+                        change_type=row["change_type"],
+                        diff_summary=row["diff_summary"],
+                        project_id=row["project_id"],
+                    )
+                )
+        finally:
+            conn.close()
+
+        return changes
+
+    def get_status_summary(self) -> Dict[str, Any]:
+        """Return system status summary stats including prompts and code changes."""
+        conn = self.db.get_connection()
+        try:
+            cursor = conn.cursor()
+            cursor.execute("SELECT COUNT(*) FROM usage_events;")
+            total_records = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(*) FROM session_prompts;")
+            total_prompts = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(*) FROM session_code_changes;")
+            total_changes = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(DISTINCT session_id) FROM usage_events WHERE session_id IS NOT NULL;")
+            unique_sessions = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(DISTINCT project_id) FROM usage_events WHERE project_id IS NOT NULL;")
+            unique_projects = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(*) FROM scan_state;")
+            scanned_files = cursor.fetchone()[0]
+
+            db_bytes = self.db.db_path.stat().st_size if self.db.db_path.exists() else 0
+
+            return {
+                "db_path": str(self.db.db_path),
+                "db_size_bytes": db_bytes,
+                "total_records": total_records,
+                "total_prompts": total_prompts,
+                "total_code_changes": total_changes,
+                "unique_sessions": unique_sessions,
+                "unique_projects": unique_projects,
+                "scanned_files": scanned_files,
+            }
+        finally:
+            conn.close()

code_meter/ui/__init__.py

@@ -0,0 +1,19 @@
+"""UI package for terminal rendering with Rich."""
+
+from code_meter.ui.dashboard import render_dashboard
+from code_meter.ui.tables import (
+    render_models_table,
+    render_projects_table,
+    render_sessions_table,
+    render_daily_table,
+    render_status_panel,
+)
+
+__all__ = [
+    "render_dashboard",
+    "render_models_table",
+    "render_projects_table",
+    "render_sessions_table",
+    "render_daily_table",
+    "render_status_panel",
+]

code_meter/ui/dashboard.py

@@ -0,0 +1,111 @@
+"""Interactive Rich terminal dashboard layout."""
+
+from typing import Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from code_meter.models.project import AggregateSummary
+from code_meter.ui.tables import format_cost, format_tokens
+
+
+def render_dashboard(
+    summary: AggregateSummary,
+    title_suffix: str = "Overview",
+    console: Optional[Console] = None,
+) -> None:
+    c = console or Console()
+
+    header_text = Text()
+    header_text.append("CODE METER\n", style="bold cyan splash")
+    header_text.append(f"{title_suffix}", style="dim white")
+    header_panel = Panel(header_text, style="bold blue", expand=True)
+
+    metrics_table = Table.grid(padding=(0, 4))
+    metrics_table.add_column(style="bold white")
+    metrics_table.add_column(style="bold yellow", justify="right")
+
+    metrics_table.add_row("Requests", f"{summary.total_requests:,}")
+    metrics_table.add_row("Input Tokens", format_tokens(summary.input_tokens))
+    metrics_table.add_row("Output Tokens", format_tokens(summary.output_tokens))
+    metrics_table.add_row("Cache Read", format_tokens(summary.cache_read_tokens))
+    metrics_table.add_row("Cache Write", format_tokens(summary.cache_write_tokens))
+    metrics_table.add_row("Total Tokens", format_tokens(summary.total_tokens))
+    metrics_table.add_row("", "")
+    metrics_table.add_row("Estimated Cost", format_cost(summary.estimated_cost_usd))
+
+    metrics_panel = Panel(
+        metrics_table,
+        title="[bold green]Key Metrics[/bold green]",
+        border_style="green",
+    )
+
+    model_table = Table(title="BY MODEL", header_style="bold magenta", expand=True)
+    model_table.add_column("Model", style="cyan")
+    model_table.add_column("Tokens", justify="right", style="bold")
+    model_table.add_column("Cost", justify="right", style="bold green")
+
+    for m in summary.by_model[:5]:
+        model_table.add_row(
+            m.model,
+            format_tokens(m.total_tokens),
+            format_cost(m.estimated_cost_usd),
+        )
+
+    project_table = Table(title="BY PROJECT", header_style="bold blue", expand=True)
+    project_table.add_column("Project", style="cyan")
+    project_table.add_column("Tokens", justify="right", style="bold")
+    project_table.add_column("Cost", justify="right", style="bold green")
+
+    for p in summary.by_project[:5]:
+        project_table.add_row(
+            p.project_name,
+            format_tokens(p.total_tokens),
+            format_cost(p.estimated_cost_usd),
+        )
+
+    today_grid = Table.grid(padding=(0, 2))
+    today_grid.add_column(style="bold white")
+    today_grid.add_column(style="bold yellow", justify="right")
+
+    if summary.today_summary:
+        ts = summary.today_summary
+        today_grid.add_row("Requests", f"{ts.request_count:,}")
+        today_grid.add_row("Tokens", format_tokens(ts.total_tokens))
+        today_grid.add_row("Estimated Cost", format_cost(ts.estimated_cost_usd))
+    else:
+        today_grid.add_row("No usage recorded today", "")
+
+    today_panel = Panel(
+        today_grid,
+        title="[bold yellow]TODAY[/bold yellow]",
+        border_style="yellow",
+    )
+
+    burn_grid = Table.grid(padding=(0, 2))
+    burn_grid.add_column(style="bold white")
+    burn_grid.add_column(style="bold magenta", justify="right")
+
+    if summary.tokens_per_hour is not None:
+        burn_grid.add_row("Tokens/hour", format_tokens(int(summary.tokens_per_hour)))
+        if summary.cost_per_hour is not None:
+            burn_grid.add_row("Cost/hour", f"${summary.cost_per_hour:.2f}")
+        burn_grid.add_row("Tokens/day", format_tokens(int(summary.tokens_per_day or 0)))
+        if summary.cost_per_day is not None:
+            burn_grid.add_row("Cost/day", f"${summary.cost_per_day:.2f}")
+    else:
+        burn_grid.add_row("Insufficient data for burn rate", "")
+
+    burn_panel = Panel(
+        burn_grid,
+        title="[bold magenta]BURN RATE[/bold magenta]",
+        border_style="magenta",
+    )
+
+    c.print(header_panel)
+    c.print(metrics_panel)
+    c.print(model_table)
+    c.print(project_table)
+    c.print(today_panel)
+    c.print(burn_panel)