repr-cli 0.2.16__py3-none-any.whl → 0.2.18__py3-none-any.whl

repr/hooks.py

@@ -516,12 +516,13 @@ def _spawn_background_generate(repo_path: Path) -> None:
     log_file = log_dir / "auto_generate.log"
     
     # Build command - use sys.executable to find repr command
-    # repr generate --repo <path> --local --json
+    # repr generate --weeks 1 --json --batch-size <queue_size>
+    # Note: We rely on default model config for synthesis
     cmd = [
         sys.executable, "-m", "repr",
         "generate",
         "--repo", str(repo_path),
-        "--local",  # Always use local LLM for auto-generation
+        "--days", "7",  # limit context to 1 week for quick update
         "--json",
     ]
     

repr/loaders/__init__.py

@@ -0,0 +1,22 @@
+"""
+Session loaders for different AI assistant formats.
+
+Supported formats:
+- Claude Code: ~/.claude/projects/<project>/*.jsonl
+- Clawdbot: ~/.clawdbot/agents/<id>/sessions/*.jsonl
+- Gemini Antigravity: ~/.gemini/antigravity/brain/<conversation-id>/
+"""
+
+from .claude_code import ClaudeCodeLoader
+from .clawdbot import ClawdbotLoader
+from .gemini_antigravity import GeminiAntigravityLoader
+from .base import SessionLoader, detect_session_source, load_sessions_for_project
+
+__all__ = [
+    "SessionLoader",
+    "ClaudeCodeLoader",
+    "ClawdbotLoader",
+    "GeminiAntigravityLoader",
+    "detect_session_source",
+    "load_sessions_for_project",
+]

repr/loaders/base.py

@@ -0,0 +1,156 @@
+"""
+Base session loader interface and utilities.
+"""
+
+import os
+from abc import ABC, abstractmethod
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Iterator
+
+from ..models import Session
+
+
+class SessionLoader(ABC):
+    """Abstract base class for session loaders."""
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Loader name (e.g., 'claude_code', 'clawdbot')."""
+        pass
+    
+    @abstractmethod
+    def find_sessions(
+        self,
+        project_path: str | Path,
+        since: datetime | None = None,
+    ) -> list[Path]:
+        """
+        Find session files for a project.
+        
+        Args:
+            project_path: Path to the project/repo
+            since: Only return sessions after this time
+        
+        Returns:
+            List of session file paths
+        """
+        pass
+    
+    @abstractmethod
+    def load_session(self, path: Path) -> Session | None:
+        """
+        Load a single session from a file.
+        
+        Args:
+            path: Path to the session file
+        
+        Returns:
+            Session object or None if loading fails
+        """
+        pass
+    
+    def load_sessions(
+        self,
+        project_path: str | Path,
+        since: datetime | None = None,
+    ) -> Iterator[Session]:
+        """
+        Load all sessions for a project.
+        
+        Args:
+            project_path: Path to the project/repo
+            since: Only return sessions after this time
+        
+        Yields:
+            Session objects
+        """
+        for path in self.find_sessions(project_path, since):
+            session = self.load_session(path)
+            if session:
+                yield session
+
+
+def detect_session_source(project_path: str | Path) -> list[str]:
+    """
+    Detect which session sources are available for a project.
+    
+    Args:
+        project_path: Path to the project/repo
+    
+    Returns:
+        List of available sources: ["claude_code", "clawdbot", "gemini_antigravity"]
+    """
+    from .claude_code import ClaudeCodeLoader
+    from .clawdbot import ClawdbotLoader
+    from .gemini_antigravity import GeminiAntigravityLoader
+    
+    sources = []
+    project_path = Path(project_path).resolve()
+    
+    # Check Claude Code
+    claude_loader = ClaudeCodeLoader()
+    if claude_loader.find_sessions(project_path):
+        sources.append("claude_code")
+    
+    # Check Clawdbot
+    clawdbot_loader = ClawdbotLoader()
+    if clawdbot_loader.find_sessions(project_path):
+        sources.append("clawdbot")
+    
+    # Check Gemini Antigravity
+    gemini_loader = GeminiAntigravityLoader()
+    if gemini_loader.find_sessions(project_path):
+        sources.append("gemini_antigravity")
+    
+    return sources
+
+
+def load_sessions_for_project(
+    project_path: str | Path,
+    sources: list[str] | None = None,
+    since: datetime | None = None,
+    days_back: int | None = None,
+) -> list[Session]:
+    """
+    Load sessions from all sources for a project.
+    
+    Args:
+        project_path: Path to the project/repo
+        sources: Specific sources to use, or None for auto-detect
+        since: Only return sessions after this time
+        days_back: Alternative to since: load sessions from last N days
+    
+    Returns:
+        List of sessions sorted by start time
+    """
+    from .claude_code import ClaudeCodeLoader
+    from .clawdbot import ClawdbotLoader
+    from .gemini_antigravity import GeminiAntigravityLoader
+    
+    # Calculate since from days_back if provided
+    if days_back is not None and since is None:
+        since = datetime.now() - timedelta(days=days_back)
+    
+    # Auto-detect sources if not specified
+    if sources is None:
+        sources = detect_session_source(project_path)
+    
+    # Load from all sources
+    loaders = {
+        "claude_code": ClaudeCodeLoader(),
+        "clawdbot": ClawdbotLoader(),
+        "gemini_antigravity": GeminiAntigravityLoader(),
+    }
+    
+    all_sessions = []
+    for source in sources:
+        if source in loaders:
+            loader = loaders[source]
+            for session in loader.load_sessions(project_path, since):
+                all_sessions.append(session)
+    
+    # Sort by start time
+    all_sessions.sort(key=lambda s: s.started_at)
+    return all_sessions

repr/loaders/claude_code.py

@@ -0,0 +1,287 @@
+"""
+Session loader for Claude Code format.
+
+Claude Code stores sessions as JSONL files in:
+~/.claude/projects/<project-path-encoded>/*.jsonl
+
+Each line is a JSON object with fields like:
+- type: "user", "assistant", "progress", "tool_use", etc.
+- sessionId: UUID of the session
+- uuid: UUID of this message
+- timestamp: ISO timestamp
+- message: {role, content} for user/assistant types
+- cwd: Working directory
+- gitBranch: Current git branch
+"""
+
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Iterator
+
+from ..models import (
+    ContentBlock,
+    ContentBlockType,
+    MessageRole,
+    Session,
+    SessionMessage,
+)
+from .base import SessionLoader
+
+
+class ClaudeCodeLoader(SessionLoader):
+    """Loader for Claude Code session files."""
+    
+    CLAUDE_HOME = Path.home() / ".claude" / "projects"
+    
+    @property
+    def name(self) -> str:
+        return "claude_code"
+    
+    def _encode_project_path(self, project_path: Path) -> str:
+        """
+        Encode a project path to Claude Code's directory naming convention.
+        
+        Claude Code uses path with / replaced by - and leading -.
+        e.g., /Users/mendrika/Projects/foo -> -Users-mendrika-Projects-foo
+        """
+        path_str = str(project_path.resolve())
+        # Replace path separators with dashes, remove leading slash
+        encoded = path_str.replace("/", "-")
+        if encoded.startswith("-"):
+            pass  # Keep leading dash
+        else:
+            encoded = "-" + encoded
+        return encoded
+    
+    def _decode_project_path(self, encoded: str) -> Path:
+        """
+        Decode Claude Code's directory name back to a path.
+        """
+        # Replace dashes with slashes, but skip leading dash
+        if encoded.startswith("-"):
+            decoded = encoded[1:].replace("-", "/")
+        else:
+            decoded = encoded.replace("-", "/")
+        return Path("/" + decoded)
+    
+    def find_sessions(
+        self,
+        project_path: str | Path,
+        since: datetime | None = None,
+    ) -> list[Path]:
+        """Find Claude Code session files for a project."""
+        project_path = Path(project_path).resolve()
+        
+        if not self.CLAUDE_HOME.exists():
+            return []
+        
+        # Try exact encoded path match
+        encoded = self._encode_project_path(project_path)
+        project_dir = self.CLAUDE_HOME / encoded
+        
+        if not project_dir.exists():
+            # Try to find by scanning directories (handles path variations)
+            for dir_path in self.CLAUDE_HOME.iterdir():
+                if dir_path.is_dir():
+                    decoded = self._decode_project_path(dir_path.name)
+                    # Check if project_path is a prefix or match
+                    try:
+                        if project_path == decoded or decoded.is_relative_to(project_path):
+                            project_dir = dir_path
+                            break
+                        if project_path.is_relative_to(decoded):
+                            project_dir = dir_path
+                            break
+                    except (ValueError, TypeError):
+                        continue
+            else:
+                return []
+        
+        # Find all .jsonl files
+        session_files = []
+        for file_path in project_dir.glob("*.jsonl"):
+            if since is not None:
+                # Quick check: file modification time
+                mtime = datetime.fromtimestamp(file_path.stat().st_mtime)
+                # Handle timezone-aware since
+                if since.tzinfo is not None:
+                    from datetime import timezone
+                    mtime = mtime.replace(tzinfo=timezone.utc)
+                if mtime < since:
+                    continue
+            session_files.append(file_path)
+        
+        return sorted(session_files)
+    
+    def load_session(self, path: Path) -> Session | None:
+        """Load a Claude Code session from a JSONL file."""
+        try:
+            messages = []
+            session_id = None
+            cwd = None
+            git_branch = None
+            model = None
+            started_at = None
+            ended_at = None
+            
+            with open(path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    
+                    try:
+                        entry = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    
+                    entry_type = entry.get("type")
+                    timestamp_str = entry.get("timestamp")
+                    
+                    # Extract session metadata
+                    if session_id is None and entry.get("sessionId"):
+                        session_id = entry["sessionId"]
+                    if cwd is None and entry.get("cwd"):
+                        cwd = entry["cwd"]
+                    if git_branch is None and entry.get("gitBranch"):
+                        git_branch = entry["gitBranch"]
+                    
+                    # Track timestamps
+                    if timestamp_str:
+                        try:
+                            ts = datetime.fromisoformat(timestamp_str.replace("Z", "+00:00"))
+                            if started_at is None or ts < started_at:
+                                started_at = ts
+                            if ended_at is None or ts > ended_at:
+                                ended_at = ts
+                        except (ValueError, TypeError):
+                            pass
+                    
+                    # Process user/assistant messages
+                    if entry_type == "user":
+                        msg_data = entry.get("message", {})
+                        content = self._parse_content(msg_data.get("content", ""))
+                        if content:
+                            messages.append(SessionMessage(
+                                timestamp=timestamp_str or started_at or datetime.now(),
+                                role=MessageRole.USER,
+                                content=content,
+                                uuid=entry.get("uuid"),
+                            ))
+                    
+                    elif entry_type == "assistant":
+                        msg_data = entry.get("message", {})
+                        content_raw = msg_data.get("content", [])
+                        content = self._parse_assistant_content(content_raw)
+                        
+                        # Extract model
+                        if model is None and msg_data.get("model"):
+                            model = msg_data["model"]
+                        
+                        if content:
+                            messages.append(SessionMessage(
+                                timestamp=timestamp_str or ended_at or datetime.now(),
+                                role=MessageRole.ASSISTANT,
+                                content=content,
+                                uuid=entry.get("uuid"),
+                            ))
+            
+            if not session_id or not messages:
+                return None
+            
+            return Session(
+                id=session_id,
+                started_at=started_at or datetime.now(),
+                ended_at=ended_at,
+                channel="cli",  # Claude Code is CLI-based
+                messages=messages,
+                cwd=cwd,
+                git_branch=git_branch,
+                model=model,
+            )
+            
+        except Exception as e:
+            # Log error but don't crash
+            import sys
+            print(f"Error loading Claude Code session {path}: {e}", file=sys.stderr)
+            return None
+    
+    def _parse_content(self, content) -> list[ContentBlock]:
+        """Parse message content into ContentBlocks."""
+        blocks = []
+        
+        if isinstance(content, str):
+            if content.strip():
+                blocks.append(ContentBlock(
+                    type=ContentBlockType.TEXT,
+                    text=content,
+                ))
+        elif isinstance(content, list):
+            for item in content:
+                if isinstance(item, str):
+                    if item.strip():
+                        blocks.append(ContentBlock(
+                            type=ContentBlockType.TEXT,
+                            text=item,
+                        ))
+                elif isinstance(item, dict):
+                    item_type = item.get("type", "text")
+                    if item_type == "text":
+                        text = item.get("text", "")
+                        if text.strip():
+                            blocks.append(ContentBlock(
+                                type=ContentBlockType.TEXT,
+                                text=text,
+                            ))
+                    elif item_type == "tool_use":
+                        blocks.append(ContentBlock(
+                            type=ContentBlockType.TOOL_CALL,
+                            name=item.get("name"),
+                            input=item.get("input"),
+                        ))
+        
+        return blocks
+    
+    def _parse_assistant_content(self, content) -> list[ContentBlock]:
+        """Parse assistant message content including tool calls and thinking."""
+        blocks = []
+        
+        if isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict):
+                    item_type = item.get("type", "text")
+                    
+                    if item_type == "text":
+                        text = item.get("text", "")
+                        if text.strip():
+                            blocks.append(ContentBlock(
+                                type=ContentBlockType.TEXT,
+                                text=text,
+                            ))
+                    elif item_type == "tool_use":
+                        blocks.append(ContentBlock(
+                            type=ContentBlockType.TOOL_CALL,
+                            name=item.get("name"),
+                            input=item.get("input"),
+                        ))
+                    elif item_type == "thinking":
+                        thinking = item.get("thinking", "")
+                        if thinking.strip():
+                            blocks.append(ContentBlock(
+                                type=ContentBlockType.THINKING,
+                                text=thinking,
+                            ))
+                elif isinstance(item, str) and item.strip():
+                    blocks.append(ContentBlock(
+                        type=ContentBlockType.TEXT,
+                        text=item,
+                    ))
+        elif isinstance(content, str) and content.strip():
+            blocks.append(ContentBlock(
+                type=ContentBlockType.TEXT,
+                text=content,
+            ))
+        
+        return blocks