groknroll 2.0.0__py3-none-any.whl

groknroll/clients/portkey.py

@@ -0,0 +1,94 @@
+from collections import defaultdict
+from typing import Any
+
+from portkey_ai import AsyncPortkey, Portkey
+from portkey_ai.api_resources.types.chat_complete_type import ChatCompletions
+
+from groknroll.clients.base_lm import BaseLM
+from groknroll.core.types import ModelUsageSummary, UsageSummary
+
+
+class PortkeyClient(BaseLM):
+    """
+    LM Client for running models with the Portkey API.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        model_name: str | None = None,
+        base_url: str | None = "https://api.portkey.ai/v1",
+        **kwargs,
+    ):
+        super().__init__(model_name=model_name, **kwargs)
+        self.client = Portkey(api_key=api_key, base_url=base_url)
+        self.async_client = AsyncPortkey(api_key=api_key, base_url=base_url)
+        self.model_name = model_name
+
+        # Per-model usage tracking
+        self.model_call_counts: dict[str, int] = defaultdict(int)
+        self.model_input_tokens: dict[str, int] = defaultdict(int)
+        self.model_output_tokens: dict[str, int] = defaultdict(int)
+        self.model_total_tokens: dict[str, int] = defaultdict(int)
+
+    def completion(self, prompt: str | list[dict[str, Any]], model: str | None = None) -> str:
+        if isinstance(prompt, str):
+            messages = [{"role": "user", "content": prompt}]
+        elif isinstance(prompt, list) and all(isinstance(item, dict) for item in prompt):
+            messages = prompt
+        else:
+            raise ValueError(f"Invalid prompt type: {type(prompt)}")
+
+        model = model or self.model_name
+        if not model:
+            raise ValueError("Model name is required for Portkey client.")
+
+        response = self.client.chat.completions.create(
+            model=model,
+            messages=messages,
+        )
+        self._track_cost(response, model)
+        return response.choices[0].message.content
+
+    async def acompletion(self, prompt: str | dict[str, Any], model: str | None = None) -> str:
+        if isinstance(prompt, str):
+            messages = [{"role": "user", "content": prompt}]
+        elif isinstance(prompt, list) and all(isinstance(item, dict) for item in prompt):
+            messages = prompt
+        else:
+            raise ValueError(f"Invalid prompt type: {type(prompt)}")
+
+        model = model or self.model_name
+        if not model:
+            raise ValueError("Model name is required for Portkey client.")
+
+        response = await self.async_client.chat.completions.create(model=model, messages=messages)
+        self._track_cost(response, model)
+        return response.choices[0].message.content
+
+    def _track_cost(self, response: ChatCompletions, model: str):
+        self.model_call_counts[model] += 1
+        self.model_input_tokens[model] += response.usage.prompt_tokens
+        self.model_output_tokens[model] += response.usage.completion_tokens
+        self.model_total_tokens[model] += response.usage.total_tokens
+
+        # Track last call for handler to read
+        self.last_prompt_tokens = response.usage.prompt_tokens
+        self.last_completion_tokens = response.usage.completion_tokens
+
+    def get_usage_summary(self) -> UsageSummary:
+        model_summaries = {}
+        for model in self.model_call_counts:
+            model_summaries[model] = ModelUsageSummary(
+                total_calls=self.model_call_counts[model],
+                total_input_tokens=self.model_input_tokens[model],
+                total_output_tokens=self.model_output_tokens[model],
+            )
+        return UsageSummary(model_usage_summaries=model_summaries)
+
+    def get_last_usage(self) -> ModelUsageSummary:
+        return ModelUsageSummary(
+            total_calls=1,
+            total_input_tokens=self.last_prompt_tokens,
+            total_output_tokens=self.last_completion_tokens,
+        )

groknroll/core/__init__.py

@@ -0,0 +1,9 @@
+"""
+groknroll Core - Agent logic with integrated RLM
+"""
+
+from groknroll.core.agent import GroknrollAgent
+from groknroll.core.rlm_integration import RLMIntegration
+from groknroll.core.context import ProjectContext
+
+__all__ = ["GroknrollAgent", "RLMIntegration", "ProjectContext"]

groknroll/core/agent.py

@@ -0,0 +1,339 @@
+"""
+GroknrollAgent - The Ultimate CLI Coding Agent
+
+Main orchestrator combining RLM, project context, and autonomous workflows.
+"""
+
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+
+from groknroll.core.rlm_integration import RLMIntegration, RLMConfig, RLMResult
+from groknroll.core.context import ProjectContext
+from groknroll.storage.database import Database
+
+
+@dataclass
+class AgentConfig:
+    """Configuration for GroknrollAgent"""
+    model: str = "gpt-4o-mini"
+    max_cost: float = 5.0
+    timeout: int = 300
+    auto_index: bool = True
+
+
+class GroknrollAgent:
+    """
+    The Ultimate CLI Coding Agent
+
+    Features:
+    - Unlimited context via RLM
+    - Project-aware with persistent state
+    - Autonomous multi-step workflows
+    - Self-correcting and verifying
+    - Local and private
+    """
+
+    def __init__(
+        self,
+        project_path: Optional[Path] = None,
+        config: Optional[AgentConfig] = None
+    ):
+        """
+        Initialize groknroll agent
+
+        Args:
+            project_path: Path to project (uses current dir if None)
+            config: Agent configuration
+        """
+        self.config = config or AgentConfig()
+
+        # Set project path
+        self.project_path = project_path or Path.cwd()
+        if not self.project_path.exists():
+            raise ValueError(f"Project path does not exist: {self.project_path}")
+
+        # Initialize components
+        self.db = Database()
+        self.context = ProjectContext(self.project_path, self.db)
+
+        # Initialize RLM
+        rlm_config = RLMConfig(
+            model=self.config.model,
+            max_cost=self.config.max_cost,
+            timeout_seconds=self.config.timeout
+        )
+        self.rlm = RLMIntegration(rlm_config)
+
+        # Auto-index if configured
+        if self.config.auto_index:
+            self._ensure_indexed()
+
+    def _ensure_indexed(self) -> None:
+        """Ensure project is indexed"""
+        overview = self.context.get_project_overview()
+
+        # Index if never indexed or very old
+        if overview["total_files"] == 0:
+            print("Indexing project for first time...")
+            stats = self.context.index_project()
+            print(f"✓ Indexed {stats['indexed']} files ({stats['total_lines']:,} lines)")
+
+    # =========================================================================
+    # Core Chat & Analysis
+    # =========================================================================
+
+    def chat(self, message: str, context: Optional[Dict[str, Any]] = None) -> str:
+        """
+        Chat with agent about project
+
+        Args:
+            message: User message
+            context: Additional context
+
+        Returns:
+            Agent response
+        """
+        # Add project context
+        project_context = {
+            "project_name": self.context.project.name,
+            "project_path": str(self.project_path),
+            "total_files": self.context.project.total_files,
+            **(context or {})
+        }
+
+        # Execute with RLM
+        result = self.rlm.complete(
+            task=message,
+            context=project_context
+        )
+
+        # Log execution
+        if result.success:
+            self.context.log_execution(
+                task=message,
+                response=result.response,
+                total_cost=result.total_cost,
+                total_time=result.total_time,
+                iterations=result.iterations,
+                status="success"
+            )
+
+        return result.response if result.success else f"Error: {result.error}"
+
+    def analyze_code(
+        self,
+        file_path: Optional[Path] = None,
+        code: Optional[str] = None,
+        analysis_type: str = "review"
+    ) -> Dict[str, Any]:
+        """
+        Analyze code
+
+        Args:
+            file_path: Path to file (or provide code directly)
+            code: Code string (or provide file_path)
+            analysis_type: Type of analysis (review, security, complexity, etc)
+
+        Returns:
+            Analysis results
+        """
+        if file_path and not code:
+            with open(file_path, 'r') as f:
+                code = f.read()
+
+        if not code:
+            raise ValueError("Must provide either file_path or code")
+
+        # Determine language
+        language = "python"  # Default
+        if file_path:
+            language = self.context._detect_language(file_path.suffix)
+
+        # Analyze with RLM
+        result = self.rlm.analyze_code(
+            code=code,
+            analysis_type=analysis_type,
+            language=language
+        )
+
+        if result.success:
+            # Parse response into structured format
+            analysis_results = {
+                "analysis": result.response,
+                "file": str(file_path) if file_path else None,
+                "language": language,
+                "type": analysis_type
+            }
+
+            # Save analysis
+            self.context.save_analysis(
+                analysis_type=analysis_type,
+                results=analysis_results,
+                target_path=str(file_path) if file_path else None,
+                execution_time=result.total_time
+            )
+
+            return analysis_results
+
+        return {"error": result.error}
+
+    def analyze_project(self, detailed: bool = False) -> Dict[str, Any]:
+        """
+        Analyze entire project
+
+        Args:
+            detailed: Include detailed analysis
+
+        Returns:
+            Project analysis
+        """
+        overview = self.context.get_project_overview()
+
+        analysis_prompt = f"""Analyze this project:
+
+Name: {overview['name']}
+Files: {overview['total_files']}
+Lines of Code: {overview['total_lines']:,}
+
+Languages:
+{self._format_language_stats(overview['languages'])}
+
+Provide:
+1. Project structure assessment
+2. Code quality overview
+3. Potential issues
+4. Recommendations
+"""
+
+        if detailed:
+            analysis_prompt += "\n5. Detailed analysis of key files\n6. Architecture suggestions"
+
+        result = self.rlm.complete(
+            task=analysis_prompt,
+            context=overview
+        )
+
+        if result.success:
+            analysis_results = {
+                "overview": overview,
+                "analysis": result.response,
+                "metrics": {
+                    "cost": result.total_cost,
+                    "time": result.total_time,
+                    "iterations": result.iterations
+                }
+            }
+
+            self.context.save_analysis(
+                analysis_type="project_overview",
+                results=analysis_results,
+                execution_time=result.total_time
+            )
+
+            return analysis_results
+
+        return {"error": result.error}
+
+    # =========================================================================
+    # Code Search & Understanding
+    # =========================================================================
+
+    def search_code(self, query: str, language: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        Search codebase
+
+        Args:
+            query: Search query
+            language: Filter by language
+
+        Returns:
+            List of matching files
+        """
+        return self.context.search_files(query, language)
+
+    def explain_code(self, file_path: Path) -> str:
+        """Explain what code does"""
+        with open(file_path, 'r') as f:
+            code = f.read()
+
+        language = self.context._detect_language(file_path.suffix)
+
+        result = self.rlm.analyze_code(
+            code=code,
+            analysis_type="explain",
+            language=language
+        )
+
+        return result.response if result.success else f"Error: {result.error}"
+
+    # =========================================================================
+    # Statistics & History
+    # =========================================================================
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get usage statistics"""
+        exec_stats = self.context.get_execution_stats()
+        overview = self.context.get_project_overview()
+
+        return {
+            "project": {
+                "name": overview["name"],
+                "files": overview["total_files"],
+                "lines": overview["total_lines"],
+                "languages": overview["languages"]
+            },
+            "executions": exec_stats,
+            "rlm": self.rlm.get_stats()
+        }
+
+    def get_history(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """Get recent execution history"""
+        executions = self.db.get_recent_executions(
+            project_id=self.context.project.id,
+            limit=limit
+        )
+
+        return [
+            {
+                "task": e.task[:100] + "..." if len(e.task) > 100 else e.task,
+                "status": e.status,
+                "cost": e.total_cost,
+                "time": e.total_time,
+                "timestamp": e.started_at
+            }
+            for e in executions
+        ]
+
+    # =========================================================================
+    # Project Management
+    # =========================================================================
+
+    def reindex_project(self, force: bool = True) -> Dict[str, Any]:
+        """Re-index project"""
+        print("Re-indexing project...")
+        stats = self.context.index_project(force=force)
+        print(f"✓ Indexed {stats['indexed']} files")
+        return stats
+
+    def get_project_info(self) -> Dict[str, Any]:
+        """Get project information"""
+        return self.context.get_project_overview()
+
+    # =========================================================================
+    # Utilities
+    # =========================================================================
+
+    def _format_language_stats(self, language_stats: Dict[str, Dict[str, int]]) -> str:
+        """Format language statistics"""
+        lines = []
+        for lang, stats in sorted(language_stats.items(), key=lambda x: x[1]['lines'], reverse=True):
+            lines.append(f"  {lang}: {stats['files']} files, {stats['lines']:,} lines")
+        return "\n".join(lines)
+
+    def reset_rlm(self) -> None:
+        """Reset RLM environment"""
+        self.rlm.reset()
+
+    def __repr__(self) -> str:
+        return f"GroknrollAgent(project={self.project_path.name})"

groknroll/core/comms_utils.py

@@ -0,0 +1,264 @@
+"""
+Communication utilities for RLM socket protocol.
+
+Protocol: 4-byte big-endian length prefix + JSON payload.
+Used for communication between LMHandler and environment subprocesses.
+"""
+
+import json
+import socket
+import struct
+from dataclasses import dataclass
+from typing import Any
+
+from groknroll.core.types import RLMChatCompletion
+
+# =============================================================================
+# Message Dataclasses
+# =============================================================================
+
+
+@dataclass
+class LMRequest:
+    """Request message sent to the LM Handler.
+
+    Supports both single prompt (prompt field) and batched prompts (prompts field).
+    """
+
+    prompt: str | dict[str, Any] | None = None
+    prompts: list[str | dict[str, Any]] | None = None
+    model: str | None = None
+    depth: int = 0
+
+    @property
+    def is_batched(self) -> bool:
+        """Check if this is a batched request."""
+        return self.prompts is not None and len(self.prompts) > 0
+
+    def to_dict(self) -> dict:
+        """Convert to dict, excluding None values."""
+        d = {}
+        if self.prompt is not None:
+            d["prompt"] = self.prompt
+        if self.prompts is not None:
+            d["prompts"] = self.prompts
+        if self.model is not None:
+            d["model"] = self.model
+        d["depth"] = self.depth
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "LMRequest":
+        """Create from dict."""
+        return cls(
+            prompt=data.get("prompt"),
+            prompts=data.get("prompts"),
+            model=data.get("model"),
+            depth=data.get("depth", -1),  # TODO: Default should throw an error
+        )
+
+
+@dataclass
+class LMResponse:
+    """Response message from the LM Handler.
+
+    Supports both single response (chat_completion) and batched responses (chat_completions).
+    """
+
+    error: str | None = None
+    chat_completion: RLMChatCompletion | None = None
+    chat_completions: list[RLMChatCompletion] | None = None
+
+    @property
+    def success(self) -> bool:
+        """Check if response was successful."""
+        return self.error is None
+
+    @property
+    def is_batched(self) -> bool:
+        """Check if this is a batched response."""
+        return self.chat_completions is not None
+
+    def to_dict(self) -> dict:
+        """Convert to dict, excluding None values."""
+        if self.error is not None:
+            return {
+                "error": self.error,
+                "chat_completion": None,
+                "chat_completions": None,
+            }
+        if self.chat_completions is not None:
+            return {
+                "chat_completions": [c.to_dict() for c in self.chat_completions],
+                "chat_completion": None,
+                "error": None,
+            }
+        if self.chat_completion is not None:
+            return {
+                "chat_completion": self.chat_completion.to_dict(),
+                "chat_completions": None,
+                "error": None,
+            }
+        return {
+            "error": "No chat completion or error provided.",
+            "chat_completion": None,
+            "chat_completions": None,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "LMResponse":
+        """Create from dict."""
+        chat_completions = None
+        if data.get("chat_completions"):
+            chat_completions = [RLMChatCompletion.from_dict(c) for c in data["chat_completions"]]
+
+        chat_completion = None
+        if data.get("chat_completion"):
+            chat_completion = RLMChatCompletion.from_dict(data["chat_completion"])
+
+        return cls(
+            error=data.get("error"),
+            chat_completion=chat_completion,
+            chat_completions=chat_completions,
+        )
+
+    @classmethod
+    def success_response(cls, chat_completion: RLMChatCompletion) -> "LMResponse":
+        """Create a successful single response."""
+        return cls(chat_completion=chat_completion)
+
+    @classmethod
+    def batched_success_response(cls, chat_completions: list[RLMChatCompletion]) -> "LMResponse":
+        """Create a successful batched response."""
+        return cls(chat_completions=chat_completions)
+
+    @classmethod
+    def error_response(cls, error: str) -> "LMResponse":
+        """Create an error response."""
+        return cls(error=error)
+
+
+# =============================================================================
+# Socket Protocol Helpers
+# =============================================================================
+
+
+def socket_send(sock: socket.socket, data: dict) -> None:
+    """Send a length-prefixed JSON message over socket.
+
+    Protocol: 4-byte big-endian length prefix + UTF-8 JSON payload.
+    """
+    payload = json.dumps(data).encode("utf-8")
+    sock.sendall(struct.pack(">I", len(payload)) + payload)
+
+
+def socket_recv(sock: socket.socket) -> dict:
+    """Receive a length-prefixed JSON message from socket.
+
+    Protocol: 4-byte big-endian length prefix + UTF-8 JSON payload.
+    Returns empty dict if connection closed before length received.
+
+    Raises:
+        ConnectionError: If connection closes mid-message.
+    """
+    raw_len = sock.recv(4)
+    if not raw_len:
+        return {}
+
+    length = struct.unpack(">I", raw_len)[0]
+    payload = b""
+    while len(payload) < length:
+        chunk = sock.recv(length - len(payload))
+        if not chunk:
+            raise ConnectionError("Connection closed before message complete")
+        payload += chunk
+
+    return json.loads(payload.decode("utf-8"))
+
+
+def socket_request(address: tuple[str, int], data: dict, timeout: int = 300) -> dict:
+    """Send a request and receive a response over a new socket connection.
+
+    Opens a new TCP connection, sends the request, waits for response, then closes.
+
+    Args:
+        address: (host, port) tuple to connect to.
+        data: Dictionary to send as JSON.
+        timeout: Socket timeout in seconds (default 300).
+
+    Returns:
+        Response dictionary.
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(timeout)
+        sock.connect(address)
+        socket_send(sock, data)
+        return socket_recv(sock)
+
+
+# =============================================================================
+# Typed Request Helpers
+# =============================================================================
+
+
+def send_lm_request(
+    address: tuple[str, int], request: LMRequest, timeout: int = 300, depth: int | None = None
+) -> LMResponse:
+    """Send an LM request and return typed response.
+
+    Args:
+        address: (host, port) tuple of LM Handler server.
+        request: LMRequest to send.
+        timeout: Socket timeout in seconds.
+        depth: Optional depth to override request depth.
+
+    Returns:
+        LMResponse with content or error.
+    """
+    try:
+        if depth is not None:
+            request.depth = depth
+        response_data = socket_request(address, request.to_dict(), timeout)
+        return LMResponse.from_dict(response_data)
+    except Exception as e:
+        return LMResponse.error_response(f"Request failed: {e}")
+
+
+def send_lm_request_batched(
+    address: tuple[str, int],
+    prompts: list[str | dict[str, Any]],
+    model: str | None = None,
+    timeout: int = 300,
+    depth: int = 0,
+) -> list[LMResponse]:
+    """Send a batched LM request and return a list of typed responses.
+
+    Args:
+        address: (host, port) tuple of LM Handler server.
+        prompts: List of prompts to send.
+        model: Optional model name to use.
+        timeout: Socket timeout in seconds.
+        depth: Depth for routing (default 0).
+
+    Returns:
+        List of LMResponse objects, one per prompt, in the same order.
+    """
+    try:
+        request = LMRequest(prompts=prompts, model=model, depth=depth)
+        response_data = socket_request(address, request.to_dict(), timeout)
+        response = LMResponse.from_dict(response_data)
+
+        if not response.success:
+            # Return error responses for all prompts
+            return [LMResponse.error_response(response.error)] * len(prompts)
+
+        if response.chat_completions is None:
+            return [LMResponse.error_response("No completions returned")] * len(prompts)
+
+        # Convert batched response to list of individual responses
+        return [
+            LMResponse.success_response(chat_completion)
+            for chat_completion in response.chat_completions
+        ]
+    except Exception as e:
+        return [LMResponse.error_response(f"Request failed: {e}")] * len(prompts)