onecoder 0.0.2__py3-none-any.whl

onecoder/tools/external_tools.py

@@ -0,0 +1,106 @@
+# onecoder/tools/external_tools.py
+
+import subprocess
+import os
+from ..governance.probllm import ProbLLMGuardian
+
+def shell_executor_tool(command: str) -> str:
+    """
+    Executes a shell command and returns its output (stdout and stderr).
+    Use this for running general system commands, testing, or querying tools.
+
+    Args:
+        command: The full shell command to execute.
+
+    Returns:
+        The command output or an error message.
+    """
+    try:
+        # ProbLLM Governance Check
+        # Resolve path to governance.yaml relative to repository root
+        # onecoder-cli/onecoder/tools/external_tools.py -> ../../../governance.yaml
+        gov_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", "governance.yaml"))
+
+        # Instantiate Guardian on demand
+        local_guardian = ProbLLMGuardian(gov_path)
+
+        is_safe, message = local_guardian.validate_tool_execution("shell_execute", {"command": command})
+        if not is_safe:
+            return f"GOVERNANCE BLOCK: {message}. Please verify 'governance.yaml' policies."
+
+        # Run the command
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        output = ""
+        if result.stdout:
+            output += f"STDOUT:\n{result.stdout}\n"
+        if result.stderr:
+            output += f"STDERR:\n{result.stderr}\n"
+        
+        raw_response = output or f"Command exited with code {result.returncode}"
+
+        # ProbLLM Output Validation
+        is_safe, message = local_guardian.validate_output(raw_response)
+        if not is_safe:
+            return f"GOVERNANCE BLOCK: {message}"
+
+        if not output and result.returncode == 0:
+            return "Command executed successfully with no output."
+
+        return raw_response
+
+    except subprocess.TimeoutExpired:
+        return "Error: Command timed out after 30 seconds."
+    except Exception as e:
+        return f"An error occurred while executing the command: {e}"
+
+
+def gemini_tool(query: str) -> str:
+    """
+    Executes a Gemini CLI command ('gemini ask') for general queries.
+    Note: For image generation (nanobanana), inform the user that it must be done 
+    interactively within the Gemini TUI.
+
+    Args:
+        query: The query or instruction to pass to 'gemini ask'.
+
+    Returns:
+        The result from Gemini CLI or an error/guidance message.
+    """
+    # Check if the query is about image generation
+    image_keywords = ["image", "generate", "draw", "picture", "nanobanana"]
+    if any(keyword in query.lower() for keyword in image_keywords):
+        return (
+            "To generate images with 'nanobanana', you must use the Gemini TUI. "
+            "Run 'gemini' in your terminal and use the interactive prompt there."
+        )
+
+    try:
+        # Construct the 'gemini ask' command
+        # We escape single quotes in the query to avoid shell injection issues
+        escaped_query = query.replace("'", "'\\''")
+        command = f"gemini ask '{escaped_query}'"
+        
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=60, # Gemini might take longer
+        )
+
+        if result.returncode == 0:
+            return result.stdout
+        else:
+            return f"Error running gemini: {result.stderr}"
+
+    except subprocess.TimeoutExpired:
+        return "Error: Gemini command timed out."
+    except Exception as e:
+        return f"An error occurred while running Gemini: {e}"

onecoder/tools/file_tools.py

@@ -0,0 +1,77 @@
+# onecoder/tools/file_tools.py
+
+
+def write_file_tool(filepath: str, content: str) -> str:
+    """
+    Writes content to a file at the given filepath.
+
+    Args:
+        filepath: The path to the file.
+        content: The content to write to the file.
+
+    Returns:
+        A success message or an error message if the file cannot be written.
+    """
+    try:
+        with open(filepath, "w") as f:
+            f.write(content)
+
+        # Trigger hooks
+        try:
+            from onecoder.hooks import hooks_manager
+            hooks_manager.on_file_edit(filepath)
+        except ImportError:
+            pass # Ignore if hooks module is not available or has circular import
+        except Exception as e:
+            print(f"Warning: Failed to trigger hooks: {e}")
+
+        return f"Successfully wrote content to {filepath}"
+    except Exception as e:
+        return f"An error occurred while writing to the file: {e}"
+
+
+def read_file_tool(filepath: str) -> str:
+    """
+    Reads the contents of a file at the given filepath.
+
+    Args:
+        filepath: The path to the file.
+
+    Returns:
+        The content of the file, or an error message if the file cannot be read.
+    """
+    try:
+        with open(filepath, "r") as f:
+            return f.read()
+    except FileNotFoundError:
+        return f"Error: File not found at {filepath}"
+    except Exception as e:
+        return f"An error occurred while reading the file: {e}"
+
+
+def list_directory_tool(directory: str = ".") -> str:
+    """
+    Lists the contents of a directory.
+
+    Args:
+        directory: The path to the directory to list.
+
+    Returns:
+        A string containing the directory listing, or an error message if the directory cannot be read.
+    """
+    import os
+
+    try:
+        items = os.listdir(directory)
+        files = [
+            item for item in items if os.path.isfile(os.path.join(directory, item))
+        ]
+        dirs = [item for item in items if os.path.isdir(os.path.join(directory, item))]
+        result = f"Directory: {directory}\n"
+        if dirs:
+            result += f"Directories: {', '.join(dirs)}\n"
+        if files:
+            result += f"Files: {', '.join(files)}"
+        return result
+    except Exception as e:
+        return f"An error occurred while listing directory {directory}: {e}"

onecoder/tools/interface.py

@@ -0,0 +1,25 @@
+# onecoder/tools/interface.py
+
+from typing import Any, Callable, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+class BaseTool(BaseModel):
+    """Base class for all tools in the system."""
+    name: str
+    description: str
+    func: Callable
+    parameters: Optional[Dict[str, Any]] = None
+
+    def execute(self, **kwargs) -> Any:
+        """Execute the tool function with the given arguments."""
+        return self.func(**kwargs)
+
+    async def execute_async(self, **kwargs) -> Any:
+        """Execute the tool function asynchronously if it is a coroutine."""
+        from ..metrics import TTUMetrics
+        TTUMetrics.get_instance().track_first_tool_call()
+        
+        import asyncio
+        if asyncio.iscoroutinefunction(self.func):
+            return await self.func(**kwargs)
+        return self.func(**kwargs)

onecoder/tools/jules_tools.py

@@ -0,0 +1,122 @@
+"""Jules API integration tool for OneCoder.
+
+This module provides tool functions that wrap the JulesAPIClient for use
+in the ADK tool registry and backward compatibility with existing tests.
+"""
+
+import os
+import requests
+from typing import Union
+from ..jules_client import JulesAPIClient, JulesAPIError, JulesAuthError, JulesNotFoundError
+
+
+def jules_delegate_tool(prompt: str, source: Union[str, None] = None) -> str:
+    """Delegate a coding task to Google Jules.
+    
+    Args:
+        prompt: The coding task description
+        source: GitHub source (e.g., 'sources/github/owner/repo'). 
+                Defaults to JULES_SOURCE env var.
+    
+    Returns:
+        Status message with session ID and initial response
+    """
+    try:
+        # Initialize client
+        client = JulesAPIClient()
+        
+        # Create session
+        session = client.create_session(prompt, source=source)
+        
+        # Get initial activities
+        try:
+            activities = client.list_activities(session.id, page_size=5)
+        except JulesNotFoundError:
+            # Activities might not be available yet
+            activities = []
+        
+        # Format response
+        result = f"✓ Jules session created: {session.id}\n"
+        result += f"Task: {prompt}\n"
+        result += f"Source: {source or os.environ.get('JULES_SOURCE')}\n\n"
+        
+        if activities:
+            result += "Initial Activities:\n"
+            for activity in activities[:3]:
+                if activity.activity_type == "plan_generated":
+                    plan = activity.data.get("planGenerated", {}).get("plan", {})
+                    steps = len(plan.get("steps", []))
+                    result += f"- Plan generated with {steps} steps\n"
+                elif activity.activity_type == "progress_updated":
+                    progress = activity.data.get("progressUpdated", {})
+                    result += f"- {progress.get('title', 'Progress update')}\n"
+        
+        result += f"\nMonitor progress at: https://jules.google.com/sessions/{session.id}"
+        return result
+        
+    except JulesAuthError as e:
+        return f"Error: JULES_API_KEY environment variable not set"
+    except JulesAPIError as e:
+        return f"Error: {str(e)}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def jules_status_tool(session_id: str) -> str:
+    """Check the status of a Jules session.
+    
+    Args:
+        session_id: The Jules session ID
+    
+    Returns:
+        Current status and recent activities
+    """
+    try:
+        # Initialize client
+        client = JulesAPIClient()
+        
+        # Get session info
+        session = client.get_session(session_id)
+        
+        # Get recent activities
+        try:
+            activities = client.list_activities(session_id, page_size=10)
+        except JulesNotFoundError:
+            activities = []
+        
+        # Format response
+        result = f"Session: {session_id}\n"
+        result += f"Title: {session.title or 'N/A'}\n"
+        result += f"Prompt: {session.prompt or 'N/A'}\n\n"
+        
+        # Check for PR output
+        pr_output = client.detect_pr_output(session_id)
+        if pr_output:
+            result += "Outputs:\n"
+            result += f"- PR: {pr_output['url']}\n"
+            result += f"  Title: {pr_output['title']}\n"
+        
+        # Show recent activities
+        if activities:
+            result += "\nRecent Activities:\n"
+            for activity in activities[:5]:
+                if activity.activity_type == "plan_generated":
+                    result += f"- [{activity.originator}] Plan generated\n"
+                elif activity.activity_type == "progress_updated":
+                    progress = activity.data.get("progressUpdated", {})
+                    result += f"- [{activity.originator}] {progress.get('title', 'Progress')}\n"
+                elif activity.activity_type == "session_completed":
+                    result += f"- [{activity.originator}] Session completed ✓\n"
+        
+        return result
+        
+    except JulesNotFoundError:
+        return f"Jules session with ID '{session_id}' not found."
+    except JulesAuthError:
+        return "Error: JULES_API_KEY environment variable not set"
+    except JulesAPIError as e:
+        return f"Error communicating with Jules API: {str(e)}"
+    except requests.exceptions.RequestException as e:
+        return f"Error communicating with Jules API: {str(e)}"
+    except Exception as e:
+        return f"Error: {str(e)}"

onecoder/tools/kit_tools.py

@@ -0,0 +1,122 @@
+# onecoder/tools/kit_tools.py
+
+import subprocess
+import json
+
+
+def kit_index_tool(directory: str = ".") -> str:
+    """
+    Uses kit to build and return a comprehensive index of the repository.
+
+    Args:
+        directory: The path to the repository directory to index.
+
+    Returns:
+        A JSON string containing the repository index, or an error message.
+    """
+    try:
+        # Run kit index command
+        result = subprocess.run(
+            ["kit", "index", "."],
+            cwd=directory,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        if result.returncode == 0:
+            # Parse and return the JSON
+            try:
+                index_data = json.loads(result.stdout)
+                return json.dumps(index_data, indent=2)
+            except json.JSONDecodeError:
+                return (
+                    f"Kit index completed but output is not valid JSON: {result.stdout}"
+                )
+        else:
+            return f"Error running kit index: {result.stderr}"
+
+    except subprocess.TimeoutExpired:
+        return "Error: kit index command timed out"
+    except FileNotFoundError:
+        return "Error: kit command not found. Make sure kit is installed."
+    except Exception as e:
+        return f"An error occurred while running kit index: {e}"
+
+
+def kit_file_tree_tool(directory: str = ".") -> str:
+    """
+    Uses kit to get the file tree structure of a repository.
+
+    Args:
+        directory: The path to the repository directory.
+
+    Returns:
+        A string containing the file tree structure, or an error message.
+    """
+    import tempfile
+    import os
+
+    try:
+        # Create a temporary file to store the output
+        with tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix='.json') as tmp:
+            tmp_path = tmp.name
+
+        result = subprocess.run(
+            ["kit", "file-tree", directory, "--output", tmp_path], 
+            capture_output=True, 
+            text=True, 
+            timeout=10
+        )
+
+        if result.returncode == 0:
+            with open(tmp_path, 'r') as f:
+                content = f.read()
+            os.remove(tmp_path)
+            try:
+                return json.loads(content)
+            except json.JSONDecodeError:
+                return f"Error: Invalid JSON from kit: {content}"
+        else:
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+            return f"Error running kit file-tree: {result.stderr}"
+
+    except subprocess.TimeoutExpired:
+        return "Error: kit file-tree command timed out"
+    except Exception as e:
+        return f"An error occurred while running kit file-tree: {e}"
+
+
+def kit_symbols_tool(directory: str = ".") -> str:
+    """
+    Uses kit to extract code symbols from the repository.
+
+    Args:
+        directory: The path to the repository directory.
+
+    Returns:
+        A JSON string containing code symbols, or an error message.
+    """
+    try:
+        result = subprocess.run(
+            ["kit", "symbols", directory, "--format", "json"],
+            cwd=directory,
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+
+        if result.returncode == 0:
+            try:
+                symbols_data = json.loads(result.stdout)
+                return json.dumps(symbols_data, indent=2)
+            except json.JSONDecodeError:
+                return f"Kit symbols completed but output is not valid JSON: {result.stdout}"
+        else:
+            return f"Error running kit symbols: {result.stderr}"
+
+    except subprocess.TimeoutExpired:
+        return "Error: kit symbols command timed out"
+    except Exception as e:
+        return f"An error occurred while running kit symbols: {e}"

onecoder/tools/registry.py

@@ -0,0 +1,32 @@
+# onecoder/tools/registry.py
+
+from typing import Dict, List, Optional
+from .interface import BaseTool
+
+class ToolRegistry:
+    """A registry for managing and discovering tools."""
+    
+    def __init__(self):
+        self._tools: Dict[str, BaseTool] = {}
+
+    def register(self, tool: BaseTool):
+        """Register a tool in the registry."""
+        self._tools[tool.name] = tool
+
+    def get_tool(self, name: str) -> Optional[BaseTool]:
+        """Retrieve a tool by name."""
+        return self._tools.get(name)
+
+    def list_tools(self) -> List[BaseTool]:
+        """List all registered tools."""
+        return list(self._tools.values())
+
+    def get_tool_descriptions(self) -> str:
+        """Get a formatted string of all tool names and descriptions."""
+        descriptions = []
+        for tool in self._tools.values():
+            descriptions.append(f"- {tool.name}: {tool.description}")
+        return "\n".join(descriptions)
+
+# Global registry instance
+registry = ToolRegistry()

onecoder/tui/__init__.py

@@ -0,0 +1,5 @@
+"""OneCoder Textual TUI package."""
+
+from .app import OneCoderApp
+
+__all__ = ["OneCoderApp"]