code-meter 0.1.0__py3-none-any.whl

code_meter/providers/base.py

@@ -0,0 +1,42 @@
+"""Base UsageProvider interface for extensible multi-provider AI usage tracking."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional
+from pydantic import BaseModel, Field
+
+from code_meter.models.usage import SessionCodeChange, SessionPrompt, UsageRecord
+
+
+class FileScanState(BaseModel):
+    """Incremental scan state per file."""
+
+    file_path: str
+    file_size: int
+    modified_time: float
+    read_offset: int
+
+
+class ScanResult(BaseModel):
+    """Result of provider scan containing new records, prompts, code changes, and updated file states."""
+
+    records: List[UsageRecord] = Field(default_factory=list)
+    prompts: List[SessionPrompt] = Field(default_factory=list)
+    code_changes: List[SessionCodeChange] = Field(default_factory=list)
+    updated_states: List[FileScanState] = Field(default_factory=list)
+    files_scanned: int = 0
+    malformed_lines: int = 0
+
+
+class UsageProvider(ABC):
+    """Abstract interface for all AI coding agent usage providers."""
+
+    @property
+    @abstractmethod
+    def provider_name(self) -> str:
+        """Name identifier of provider (e.g., 'claude_code', 'codex', 'gemini')."""
+        pass
+
+    @abstractmethod
+    def scan(self, existing_states: Optional[Dict[str, FileScanState]] = None) -> ScanResult:
+        """Scan provider local storage and return normalized records, prompts, code changes, and state updates."""
+        pass

code_meter/providers/claude_code.py

@@ -0,0 +1,378 @@
+"""Claude Code provider for scanning local ~/.claude JSONL session files."""
+
+import hashlib
+import json
+import logging
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from code_meter.models.usage import SessionCodeChange, SessionPrompt, UsageRecord
+from code_meter.providers.base import FileScanState, ScanResult, UsageProvider
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeCodeProvider(UsageProvider):
+    """Scanner for Claude Code local JSONL session logs."""
+
+    def __init__(self, claude_dir: Path):
+        self.claude_dir = Path(os.path.expanduser(claude_dir)).resolve()
+
+    @property
+    def provider_name(self) -> str:
+        return "claude_code"
+
+    def scan(self, existing_states: Optional[Dict[str, FileScanState]] = None) -> ScanResult:
+        """Incrementally scan all *.jsonl files in Claude Code directory."""
+        existing = existing_states or {}
+        records: List[UsageRecord] = []
+        prompts: List[SessionPrompt] = []
+        code_changes: List[SessionCodeChange] = []
+        updated_states: List[FileScanState] = []
+        files_scanned = 0
+        malformed_lines = 0
+
+        if not self.claude_dir.exists():
+            logger.warning(f"Claude directory does not exist: {self.claude_dir}")
+            return ScanResult(records=[], prompts=[], code_changes=[], updated_states=[], files_scanned=0, malformed_lines=0)
+
+        jsonl_files = self._find_jsonl_files()
+
+        for file_path in jsonl_files:
+            try:
+                stat = file_path.stat()
+                file_str = str(file_path.resolve())
+                size = stat.st_size
+                mtime = stat.st_mtime
+
+                prev_state = existing.get(file_str)
+
+                if prev_state:
+                    if size == prev_state.file_size and mtime == prev_state.modified_time:
+                        updated_states.append(prev_state)
+                        continue
+
+                    if size < prev_state.file_size:
+                        start_offset = 0
+                    else:
+                        start_offset = prev_state.read_offset
+                else:
+                    start_offset = 0
+
+                files_scanned += 1
+                new_records, new_prompts, new_changes, new_offset, malformed = self._scan_file(
+                    file_path=file_path,
+                    start_offset=start_offset,
+                )
+
+                records.extend(new_records)
+                prompts.extend(new_prompts)
+                code_changes.extend(new_changes)
+                malformed_lines += malformed
+
+                updated_states.append(
+                    FileScanState(
+                        file_path=file_str,
+                        file_size=size,
+                        modified_time=mtime,
+                        read_offset=new_offset,
+                    )
+                )
+
+            except Exception as e:
+                logger.error(f"Error scanning file {file_path}: {e}", exc_info=True)
+
+        return ScanResult(
+            records=records,
+            prompts=prompts,
+            code_changes=code_changes,
+            updated_states=updated_states,
+            files_scanned=files_scanned,
+            malformed_lines=malformed_lines,
+        )
+
+    def _find_jsonl_files(self) -> List[Path]:
+        """Find all jsonl session files recursively under self.claude_dir."""
+        files: List[Path] = []
+        try:
+            for root, _, filenames in os.walk(self.claude_dir):
+                for fname in filenames:
+                    if fname.endswith(".jsonl") and fname != "history.jsonl":
+                        files.append(Path(root) / fname)
+        except PermissionError as e:
+            logger.warning(f"Permission denied accessing {self.claude_dir}: {e}")
+        return files
+
+    def _scan_file(
+        self, file_path: Path, start_offset: int
+    ) -> tuple[List[UsageRecord], List[SessionPrompt], List[SessionCodeChange], int, int]:
+        """Scan a single JSONL file from start_offset to EOF."""
+        records: List[UsageRecord] = []
+        prompts: List[SessionPrompt] = []
+        changes: List[SessionCodeChange] = []
+        malformed = 0
+        current_offset = start_offset
+
+        session_id_from_path = file_path.stem if file_path.name != "history.jsonl" else None
+        project_path_from_path = self._infer_project_path(file_path)
+        project_name = self._project_name_from_path(project_path_from_path) if project_path_from_path else None
+
+        line_index = 0
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            if start_offset > 0:
+                f.seek(start_offset)
+
+            while True:
+                line = f.readline()
+                if not line:
+                    break
+
+                current_offset = f.tell()
+                line_index += 1
+                line_str = line.strip()
+                if not line_str:
+                    continue
+
+                try:
+                    data = json.loads(line_str)
+                except Exception:
+                    malformed += 1
+                    continue
+
+                session_id = data.get("sessionId") or session_id_from_path or "unknown_session"
+                cwd = data.get("cwd") or project_path_from_path
+                p_name = self._project_name_from_path(cwd) if cwd else project_name
+
+                # 1. Parse assistant usage
+                rec = self._parse_usage_record(data, str(file_path.resolve()), session_id, cwd, p_name)
+                if rec:
+                    records.append(rec)
+
+                # 2. Parse user prompt
+                prompt = self._parse_user_prompt(data, session_id, p_name, line_index)
+                if prompt:
+                    prompts.append(prompt)
+
+                # 3. Parse code changes / file snapshots / tool edits
+                file_changes = self._parse_code_changes(data, session_id, p_name, line_index)
+                if file_changes:
+                    changes.extend(file_changes)
+
+        return records, prompts, changes, current_offset, malformed
+
+    def _parse_usage_record(
+        self,
+        data: dict,
+        file_path: str,
+        session_id: str,
+        cwd: Optional[str],
+        project_name: Optional[str],
+    ) -> Optional[UsageRecord]:
+        if not isinstance(data, dict):
+            return None
+
+        msg = data.get("message")
+        if not isinstance(msg, dict):
+            msg = {}
+
+        usage = msg.get("usage")
+        if not isinstance(usage, dict):
+            usage = data.get("usage")
+            if not isinstance(usage, dict):
+                return None
+
+        input_tokens = int(usage.get("input_tokens", 0) or 0)
+        output_tokens = int(usage.get("output_tokens", 0) or 0)
+        cache_read_tokens = int(usage.get("cache_read_input_tokens", 0) or 0)
+        cache_write_tokens = int(usage.get("cache_creation_input_tokens", 0) or 0)
+
+        if (input_tokens + output_tokens + cache_read_tokens + cache_write_tokens) == 0:
+            return None
+
+        model = msg.get("model") or data.get("model") or "unknown"
+        if not isinstance(model, str):
+            model = str(model)
+
+        raw_ts = data.get("timestamp") or msg.get("timestamp")
+        ts = self._parse_timestamp(raw_ts)
+
+        request_id = msg.get("id") or data.get("uuid") or data.get("id")
+        if not request_id or not isinstance(request_id, str):
+            request_id = self._generate_deterministic_id(
+                file_path=file_path,
+                timestamp=ts,
+                model=model,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                cache_read_tokens=cache_read_tokens,
+                cache_write_tokens=cache_write_tokens,
+            )
+
+        return UsageRecord(
+            provider="claude_code",
+            request_id=request_id,
+            session_id=session_id,
+            timestamp=ts,
+            user_id=data.get("user_id"),
+            project_id=project_name,
+            project_path=cwd,
+            model=model,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            cache_read_tokens=cache_read_tokens,
+            cache_write_tokens=cache_write_tokens,
+            metadata={"file_path": file_path, "type": data.get("type")},
+        )
+
+    def _parse_user_prompt(
+        self, data: dict, session_id: str, project_id: Optional[str], line_index: int
+    ) -> Optional[SessionPrompt]:
+        """Extract user prompt text if line represents a user message."""
+        line_type = data.get("type")
+        msg = data.get("message") if isinstance(data.get("message"), dict) else {}
+        role = msg.get("role") or data.get("role")
+
+        if line_type != "user" and role != "user":
+            return None
+
+        content = msg.get("content") or data.get("content")
+        prompt_text = ""
+
+        if isinstance(content, str):
+            prompt_text = content.strip()
+        elif isinstance(content, list):
+            texts = []
+            for block in content:
+                if isinstance(block, str):
+                    texts.append(block)
+                elif isinstance(block, dict) and block.get("type") == "text":
+                    texts.append(block.get("text", ""))
+            prompt_text = "\n".join(texts).strip()
+
+        if not prompt_text or prompt_text.startswith("<local-command-caveat>"):
+            return None
+
+        raw_ts = data.get("timestamp") or msg.get("timestamp")
+        ts = self._parse_timestamp(raw_ts)
+
+        prompt_id = data.get("promptId") or data.get("uuid") or f"prompt_{session_id}_{line_index}"
+
+        return SessionPrompt(
+            provider="claude_code",
+            session_id=session_id,
+            prompt_id=str(prompt_id),
+            timestamp=ts,
+            prompt_text=prompt_text,
+            project_id=project_id,
+        )
+
+    def _parse_code_changes(
+        self, data: dict, session_id: str, project_id: Optional[str], line_index: int
+    ) -> List[SessionCodeChange]:
+        """Extract code changes, file history snapshots, or edit tool calls."""
+        changes: List[SessionCodeChange] = []
+        raw_ts = data.get("timestamp")
+        ts = self._parse_timestamp(raw_ts)
+
+        # 1. file-history-snapshot
+        if data.get("type") == "file-history-snapshot":
+            snapshot = data.get("snapshot", {})
+            tracked = snapshot.get("trackedFileBackups", {})
+            if isinstance(tracked, dict):
+                for fpath, backup in tracked.items():
+                    change_id = f"snap_{session_id}_{hashlib.md5(fpath.encode()).hexdigest()[:8]}_{line_index}"
+                    summary = f"File snapshot backup: {backup.get('backupFileName', 'modified')}" if isinstance(backup, dict) else "File snapshot update"
+                    changes.append(
+                        SessionCodeChange(
+                            provider="claude_code",
+                            session_id=session_id,
+                            change_id=change_id,
+                            timestamp=ts,
+                            file_path=str(fpath),
+                            change_type="snapshot",
+                            diff_summary=summary,
+                            project_id=project_id,
+                        )
+                    )
+
+        # 2. Assistant tool call edits (Edit, Write, Replace, etc.)
+        msg = data.get("message")
+        if isinstance(msg, dict) and isinstance(msg.get("content"), list):
+            for idx, block in enumerate(msg.get("content", [])):
+                if isinstance(block, dict) and block.get("type") == "tool_use":
+                    tname = block.get("name", "")
+                    tinput = block.get("input", {})
+                    if isinstance(tinput, dict) and tname in ["Edit", "Write", "Replace", "StrReplace", "NotebookEditCell", "WriteFile", "EditFile"]:
+                        fpath = tinput.get("file_path") or tinput.get("path") or tinput.get("target_file") or "unknown_file"
+                        old_str = tinput.get("old_string") or tinput.get("TargetContent") or ""
+                        new_str = tinput.get("new_string") or tinput.get("ReplacementContent") or tinput.get("content") or ""
+
+                        diff_lines = []
+                        if old_str:
+                            diff_lines.append(f"- {old_str[:150]}")
+                        if new_str:
+                            diff_lines.append(f"+ {new_str[:150]}")
+                        diff_summary = "\n".join(diff_lines) if diff_lines else f"Tool action: {tname}"
+
+                        change_id = block.get("id") or f"edit_{session_id}_{line_index}_{idx}"
+                        changes.append(
+                            SessionCodeChange(
+                                provider="claude_code",
+                                session_id=session_id,
+                                change_id=str(change_id),
+                                timestamp=ts,
+                                file_path=str(fpath),
+                                change_type=tname.lower(),
+                                diff_summary=diff_summary,
+                                project_id=project_id,
+                            )
+                        )
+
+        return changes
+
+    def _parse_timestamp(self, raw_ts: Optional[str]) -> datetime:
+        if not raw_ts:
+            return datetime.now(timezone.utc)
+        if isinstance(raw_ts, (int, float)):
+            return datetime.fromtimestamp(raw_ts / 1000.0, tz=timezone.utc)
+        try:
+            ts_str = str(raw_ts).replace("Z", "+00:00")
+            return datetime.fromisoformat(ts_str)
+        except ValueError:
+            return datetime.now(timezone.utc)
+
+    def _generate_deterministic_id(
+        self,
+        file_path: str,
+        timestamp: datetime,
+        model: str,
+        input_tokens: int,
+        output_tokens: int,
+        cache_read_tokens: int,
+        cache_write_tokens: int,
+    ) -> str:
+        seed = f"claude_code:{file_path}:{timestamp.isoformat()}:{model}:{input_tokens}:{output_tokens}:{cache_read_tokens}:{cache_write_tokens}"
+        return "gen_" + hashlib.sha256(seed.encode("utf-8")).hexdigest()[:24]
+
+    def _infer_project_path(self, file_path: Path) -> Optional[str]:
+        try:
+            parent_dir = file_path.parent.name
+            if parent_dir.startswith("C--") or parent_dir.startswith("-"):
+                parts = parent_dir.split("--")
+                if len(parts) >= 2:
+                    drive = parts[0]
+                    rest = parts[1].replace("-", "/")
+                    return f"{drive}:/{rest}"
+                else:
+                    return parent_dir.replace("-", "/")
+        except Exception:
+            pass
+        return None
+
+    def _project_name_from_path(self, path_str: Optional[str]) -> Optional[str]:
+        if not path_str:
+            return None
+        clean = path_str.rstrip("/\\")
+        return os.path.basename(clean) or clean