groknroll 2.0.0__py3-none-any.whl

groknroll/__init__.py

@@ -0,0 +1,36 @@
+"""
+groknroll - The Ultimate CLI Coding Agent with RLM Core
+
+Better than Claude Code. Local, unlimited context, autonomous.
+Includes Recursive Language Models (RLM) for infinite context handling.
+"""
+
+__version__ = "2.0.0"
+__author__ = "Michael Thornton"
+
+# RLM Core exports
+from groknroll.core.rlm import RLM
+from groknroll.core.types import RLMChatCompletion, REPLResult, RLMIteration
+from groknroll.core.exceptions import RLMError, REPLExecutionError, CostLimitExceededError
+
+# groknroll CLI exports
+from groknroll.core.agent import GroknrollAgent
+
+# Oracle Agent exports
+from groknroll.oracle import OracleAgent, CodebaseIndexer
+
+__all__ = [
+    # RLM Core
+    "RLM",
+    "RLMChatCompletion",
+    "REPLResult",
+    "RLMIteration",
+    "RLMError",
+    "REPLExecutionError",
+    "CostLimitExceededError",
+    # groknroll Agent
+    "GroknrollAgent",
+    # Oracle Agent
+    "OracleAgent",
+    "CodebaseIndexer",
+]

groknroll/__main__.py

@@ -0,0 +1,9 @@
+"""
+groknroll CLI entry point
+"""
+
+import sys
+from groknroll.cli.main import main
+
+if __name__ == "__main__":
+    sys.exit(main())

groknroll/agents/__init__.py

@@ -0,0 +1,18 @@
+"""
+Multi-agent system for groknroll
+
+Provides build and plan agents with different permission levels.
+"""
+
+from groknroll.agents.base_agent import BaseAgent, AgentCapability
+from groknroll.agents.build_agent import BuildAgent
+from groknroll.agents.plan_agent import PlanAgent
+from groknroll.agents.agent_manager import AgentManager
+
+__all__ = [
+    "BaseAgent",
+    "AgentCapability",
+    "BuildAgent",
+    "PlanAgent",
+    "AgentManager",
+]

groknroll/agents/agent_manager.py

@@ -0,0 +1,187 @@
+"""
+Agent Manager
+
+Manages multiple agents and handles agent switching.
+"""
+
+from pathlib import Path
+from typing import Dict, Optional, Any
+from dataclasses import dataclass
+
+from groknroll.agents.base_agent import BaseAgent, AgentResponse
+from groknroll.agents.build_agent import BuildAgent
+from groknroll.agents.plan_agent import PlanAgent
+
+
+@dataclass
+class AgentInfo:
+    """Information about an agent"""
+    name: str
+    description: str
+    capabilities: list[str]
+    is_active: bool
+
+
+class AgentManager:
+    """
+    Agent Manager
+
+    Manages multiple agents and provides agent switching functionality.
+    Similar to OpenCode's Tab key agent switching.
+    """
+
+    def __init__(
+        self,
+        project_path: Path,
+        model: str = "gpt-4o-mini",
+        max_cost: float = 5.0,
+        timeout: int = 300
+    ):
+        """
+        Initialize agent manager
+
+        Args:
+            project_path: Project root path
+            model: Default model for agents
+            max_cost: Default max cost
+            timeout: Default timeout
+        """
+        self.project_path = project_path
+        self.model = model
+        self.max_cost = max_cost
+        self.timeout = timeout
+
+        # Initialize agents
+        self.agents: Dict[str, BaseAgent] = {
+            "build": BuildAgent(
+                project_path=project_path,
+                model=model,
+                max_cost=max_cost,
+                timeout=timeout
+            ),
+            "plan": PlanAgent(
+                project_path=project_path,
+                model=model,
+                max_cost=max_cost,
+                timeout=timeout
+            )
+        }
+
+        # Current agent
+        self.current_agent_name = "build"  # Default to build agent
+
+    @property
+    def current_agent(self) -> BaseAgent:
+        """Get current active agent"""
+        return self.agents[self.current_agent_name]
+
+    def switch(self, agent_name: str) -> bool:
+        """
+        Switch to different agent
+
+        Args:
+            agent_name: Agent name (build/plan)
+
+        Returns:
+            True if switched successfully
+        """
+        if agent_name not in self.agents:
+            return False
+
+        self.current_agent_name = agent_name
+        return True
+
+    def execute(
+        self,
+        task: str,
+        agent: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> AgentResponse:
+        """
+        Execute task with current or specified agent
+
+        Args:
+            task: Task description
+            agent: Agent name (uses current if None)
+            context: Additional context
+
+        Returns:
+            AgentResponse
+        """
+        # Use specified agent or current
+        agent_name = agent or self.current_agent_name
+
+        if agent_name not in self.agents:
+            return AgentResponse(
+                success=False,
+                message=f"Unknown agent: {agent_name}",
+                agent_name=agent_name,
+                task=task
+            )
+
+        # Execute with agent
+        return self.agents[agent_name].execute(task, context)
+
+    def get_agent(self, name: str) -> Optional[BaseAgent]:
+        """Get agent by name"""
+        return self.agents.get(name)
+
+    def list_agents(self) -> list[AgentInfo]:
+        """List all available agents"""
+        return [
+            AgentInfo(
+                name=name,
+                description=agent.config.description,
+                capabilities=agent.get_capabilities(),
+                is_active=(name == self.current_agent_name)
+            )
+            for name, agent in self.agents.items()
+        ]
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics for all agents"""
+        return {
+            "current_agent": self.current_agent_name,
+            "agents": {
+                name: agent.get_stats()
+                for name, agent in self.agents.items()
+            }
+        }
+
+    def register_agent(self, name: str, agent: BaseAgent) -> None:
+        """
+        Register custom agent
+
+        Args:
+            name: Agent name
+            agent: Agent instance
+        """
+        self.agents[name] = agent
+
+    def unregister_agent(self, name: str) -> bool:
+        """
+        Unregister agent
+
+        Args:
+            name: Agent name
+
+        Returns:
+            True if unregistered successfully
+        """
+        if name in ["build", "plan"]:
+            # Cannot unregister core agents
+            return False
+
+        if name in self.agents:
+            del self.agents[name]
+
+            # Switch to build if current agent was removed
+            if self.current_agent_name == name:
+                self.current_agent_name = "build"
+
+            return True
+
+        return False
+
+    def __repr__(self) -> str:
+        return f"AgentManager(current={self.current_agent_name}, agents={list(self.agents.keys())})"

groknroll/agents/base_agent.py

@@ -0,0 +1,118 @@
+"""
+Base Agent Interface
+
+Defines the common interface for all groknroll agents.
+"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+from dataclasses import dataclass
+from enum import Enum
+
+
+class AgentCapability(Enum):
+    """Agent capabilities"""
+    READ_FILES = "read_files"
+    WRITE_FILES = "write_files"
+    EDIT_FILES = "edit_files"
+    DELETE_FILES = "delete_files"
+    EXECUTE_BASH = "execute_bash"
+    GIT_OPERATIONS = "git_operations"
+    ANALYZE_CODE = "analyze_code"
+    SEARCH_CODE = "search_code"
+
+
+@dataclass
+class AgentConfig:
+    """Configuration for an agent"""
+    name: str
+    description: str
+    capabilities: List[AgentCapability]
+    model: str = "gpt-4o-mini"
+    max_cost: float = 5.0
+    timeout: int = 300
+    verbose: bool = False
+
+
+@dataclass
+class AgentResponse:
+    """Response from agent execution"""
+    success: bool
+    message: str
+    agent_name: str
+    task: str
+    cost: float = 0.0
+    time: float = 0.0
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class BaseAgent(ABC):
+    """
+    Base class for all groknroll agents
+
+    Agents have different capabilities and permission levels.
+    """
+
+    def __init__(self, config: AgentConfig, project_path: Path):
+        """
+        Initialize agent
+
+        Args:
+            config: Agent configuration
+            project_path: Project root path
+        """
+        self.config = config
+        self.project_path = project_path
+        self.execution_history: List[AgentResponse] = []
+
+    @abstractmethod
+    def execute(self, task: str, context: Optional[Dict[str, Any]] = None) -> AgentResponse:
+        """
+        Execute task
+
+        Args:
+            task: Task description
+            context: Additional context
+
+        Returns:
+            AgentResponse
+        """
+        pass
+
+    def can(self, capability: AgentCapability) -> bool:
+        """Check if agent has capability"""
+        return capability in self.config.capabilities
+
+    def require(self, capability: AgentCapability) -> None:
+        """Require capability (raises error if not available)"""
+        if not self.can(capability):
+            raise PermissionError(
+                f"Agent '{self.config.name}' does not have capability: {capability.value}"
+            )
+
+    def get_capabilities(self) -> List[str]:
+        """Get list of capability names"""
+        return [cap.value for cap in self.config.capabilities]
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get agent statistics"""
+        successful = [r for r in self.execution_history if r.success]
+        failed = [r for r in self.execution_history if not r.success]
+
+        return {
+            "name": self.config.name,
+            "total_executions": len(self.execution_history),
+            "successful": len(successful),
+            "failed": len(failed),
+            "total_cost": sum(r.cost for r in self.execution_history),
+            "total_time": sum(r.time for r in self.execution_history),
+            "capabilities": self.get_capabilities()
+        }
+
+    def _log_execution(self, response: AgentResponse) -> None:
+        """Log execution to history"""
+        self.execution_history.append(response)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.config.name})"

groknroll/agents/build_agent.py

@@ -0,0 +1,231 @@
+"""
+Build Agent
+
+Full-access agent that can read, write, execute bash, and use git.
+This is the primary agent for implementing features and making changes.
+"""
+
+from pathlib import Path
+from typing import Dict, Any, Optional
+import time
+
+from groknroll.agents.base_agent import (
+    BaseAgent, AgentConfig, AgentCapability, AgentResponse
+)
+from groknroll.core.rlm_integration import RLMIntegration, RLMConfig
+from groknroll.operations.file_ops import FileOperations
+from groknroll.operations.bash_ops import BashOperations
+from groknroll.operations.git_ops import GitOperations
+
+
+class BuildAgent(BaseAgent):
+    """
+    Build Agent - Full Access
+
+    Capabilities:
+    - Read/write/edit/delete files
+    - Execute bash commands
+    - Git operations
+    - Code analysis
+    - Code search
+
+    Use for:
+    - Implementing new features
+    - Fixing bugs
+    - Refactoring code
+    - Running tests
+    - Building projects
+    """
+
+    def __init__(
+        self,
+        project_path: Path,
+        model: str = "gpt-4o-mini",
+        max_cost: float = 5.0,
+        timeout: int = 300
+    ):
+        """
+        Initialize build agent
+
+        Args:
+            project_path: Project root path
+            model: LLM model to use
+            max_cost: Maximum cost per execution
+            timeout: Timeout in seconds
+        """
+        # Build agent has all capabilities
+        config = AgentConfig(
+            name="build",
+            description="Full-access agent for building and modifying code",
+            capabilities=[
+                AgentCapability.READ_FILES,
+                AgentCapability.WRITE_FILES,
+                AgentCapability.EDIT_FILES,
+                AgentCapability.DELETE_FILES,
+                AgentCapability.EXECUTE_BASH,
+                AgentCapability.GIT_OPERATIONS,
+                AgentCapability.ANALYZE_CODE,
+                AgentCapability.SEARCH_CODE,
+            ],
+            model=model,
+            max_cost=max_cost,
+            timeout=timeout
+        )
+
+        super().__init__(config, project_path)
+
+        # Initialize operations
+        self.file_ops = FileOperations(project_path)
+        self.bash_ops = BashOperations(project_path)
+
+        # Initialize git ops (may fail if not a git repo)
+        try:
+            self.git_ops = GitOperations(project_path)
+        except RuntimeError:
+            self.git_ops = None
+
+        # Initialize RLM
+        rlm_config = RLMConfig(
+            model=model,
+            max_cost=max_cost,
+            timeout_seconds=timeout
+        )
+        self.rlm = RLMIntegration(rlm_config)
+
+    def execute(self, task: str, context: Optional[Dict[str, Any]] = None) -> AgentResponse:
+        """
+        Execute build task
+
+        Args:
+            task: Task description
+            context: Additional context
+
+        Returns:
+            AgentResponse
+        """
+        start_time = time.time()
+
+        try:
+            # Prepare context with available operations
+            exec_context = {
+                "agent": "build",
+                "capabilities": self.get_capabilities(),
+                "project_path": str(self.project_path),
+                "operations": {
+                    "file": "Available: read, write, edit, delete",
+                    "bash": "Available: execute commands",
+                    "git": "Available: status, add, commit, push, etc." if self.git_ops else "Not available"
+                },
+                **(context or {})
+            }
+
+            # Add instructions for using operations
+            enhanced_task = f"""Task: {task}
+
+You are the BUILD agent with full access to:
+- File operations (read, write, edit, delete)
+- Bash execution
+- Git operations
+
+You can use RLM to execute Python code that calls these operations.
+
+Available in context:
+- file_ops: FileOperations instance
+- bash_ops: BashOperations instance
+- git_ops: GitOperations instance (or None)
+
+Example usage in RLM code:
+```python
+# Read file
+result = file_ops.read_file(Path("example.py"))
+if result.success:
+    content = result.message
+
+# Write file
+result = file_ops.write_file(Path("new.py"), "print('hello')")
+
+# Execute bash
+result = bash_ops.execute("ls -la")
+print(result.stdout)
+
+# Git operations
+status = git_ops.status()
+print(f"Branch: {{status.branch}}")
+```
+
+Execute the task using these operations.
+"""
+
+            # Execute with RLM
+            result = self.rlm.complete(
+                task=enhanced_task,
+                context=exec_context
+            )
+
+            elapsed_time = time.time() - start_time
+
+            response = AgentResponse(
+                success=result.success,
+                message=result.response if result.success else result.error or "Unknown error",
+                agent_name=self.config.name,
+                task=task,
+                cost=result.total_cost,
+                time=elapsed_time,
+                metadata={
+                    "iterations": result.iterations,
+                    "rlm_success": result.success
+                }
+            )
+
+            self._log_execution(response)
+            return response
+
+        except Exception as e:
+            elapsed_time = time.time() - start_time
+
+            response = AgentResponse(
+                success=False,
+                message=f"Build agent error: {e}",
+                agent_name=self.config.name,
+                task=task,
+                time=elapsed_time
+            )
+
+            self._log_execution(response)
+            return response
+
+    # =========================================================================
+    # Convenience Methods (Direct Operations)
+    # =========================================================================
+
+    def read_file(self, path: Path) -> str:
+        """Read file (convenience method)"""
+        self.require(AgentCapability.READ_FILES)
+        result = self.file_ops.read_file(path)
+        if not result.success:
+            raise RuntimeError(result.message)
+        return result.message
+
+    def write_file(self, path: Path, content: str) -> None:
+        """Write file (convenience method)"""
+        self.require(AgentCapability.WRITE_FILES)
+        result = self.file_ops.write_file(path, content, overwrite=True)
+        if not result.success:
+            raise RuntimeError(result.message)
+
+    def run_command(self, command: str) -> str:
+        """Run bash command (convenience method)"""
+        self.require(AgentCapability.EXECUTE_BASH)
+        result = self.bash_ops.execute(command)
+        if not result.success:
+            raise RuntimeError(result.stderr)
+        return result.stdout
+
+    def git_status(self) -> str:
+        """Get git status (convenience method)"""
+        self.require(AgentCapability.GIT_OPERATIONS)
+        if not self.git_ops:
+            raise RuntimeError("Git not available")
+
+        status = self.git_ops.status()
+        return f"Branch: {status.branch}, Staged: {len(status.staged)}, Unstaged: {len(status.unstaged)}"