onecoder 0.0.2__py3-none-any.whl

onecoder/agent.py

@@ -0,0 +1,95 @@
+import os
+from google.adk.agents import LlmAgent
+from google.adk.models import Gemini, LiteLlm
+from dotenv import load_dotenv
+
+from .agents import (
+    create_documentation_agent,
+    create_orchestrator_agent,
+    create_refactoring_agent,
+    create_file_reader_agent,
+    create_file_writer_agent,
+    create_research_agent
+)
+from .config_manager import config_manager
+
+load_dotenv(dotenv_path=os.path.join(os.path.dirname(__file__), "..", ".env"))
+
+# --- LLM Configuration ---
+def get_model():
+    # 1. Check user configuration via config_manager
+    model_config = config_manager.get_model_config()
+    if model_config and model_config.get("model_name"):
+        return LiteLlm(
+            model=model_config.get("model_name"),
+            api_key=model_config.get("api_key"),
+            base_url=model_config.get("base_url"),
+        )
+
+    # 2. Priority: Gemini (Default)
+    gemini_api_key = os.getenv("GEMINI_API_KEY")
+    if gemini_api_key:
+        return Gemini(
+            model="gemini-2.0-flash-exp",
+            api_key=gemini_api_key
+        )
+
+    # 3. Priority: OpenAI
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if openai_api_key:
+        return LiteLlm(
+            model="openai/gpt-4o",
+            api_key=openai_api_key
+        )
+
+    # 4. Check for OLLAMA_API_KEY (Defaulting to qwen coder)
+    ollama_api_key = os.getenv("OLLAMA_API_KEY")
+    if ollama_api_key:
+        base_url = os.getenv("OLLAMA_BASE_URL", "https://ollama.com")
+        return LiteLlm(
+            model="ollama/qwen3-coder:480b-cloud",
+            api_key=ollama_api_key,
+            base_url=base_url,
+        )
+
+    # 5. Fallback to OpenRouter
+    openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
+    if openrouter_api_key:
+        return LiteLlm(
+            model="openrouter/xiaomi/mimo-v2-flash:free",
+            api_key=openrouter_api_key,
+            base_url="https://openrouter.ai/api/v1",
+        )
+    
+    raise ValueError(
+        "No API key found. Please set GEMINI_API_KEY, OPENAI_API_KEY, OLLAMA_API_KEY, or OPENROUTER_API_KEY, "
+        "or configure the model using 'onecoder config model'."
+    )
+
+# --- Agent Instances ---
+_root_agent = None
+
+def get_root_agent():
+    global _root_agent
+    if _root_agent is None:
+        model = get_model()
+        
+        # Create specialist agents
+        refactoring_agent = create_refactoring_agent(model)
+        documentation_agent = create_documentation_agent(model)
+        file_reader_agent = create_file_reader_agent(model)
+        file_writer_agent = create_file_writer_agent(model)
+        research_agent = create_research_agent(model)
+
+        # Create the orchestrator as root_agent
+        _root_agent = create_orchestrator_agent(
+            model,
+            sub_agents=[
+                refactoring_agent,
+                documentation_agent,
+                file_reader_agent,
+                file_writer_agent,
+                research_agent
+            ]
+        )
+    return _root_agent

onecoder/agentic_tool_search/dynamic_tool_search.py

@@ -0,0 +1,64 @@
+# onecoder/agentic_tool_search/dynamic_tool_search.py
+
+import inspect
+import numpy as np
+
+class DynamicToolExecutor:
+    """
+    Manages the dynamic finding and execution of tools based on semantic search.
+    """
+    def __init__(self, model, registry):
+        self.model = model
+        self.registry = registry
+
+    def _cosine_similarity(self, v1, v2):
+        """Calculates the cosine similarity between two vectors."""
+        dot_product = np.dot(v1, v2)
+        norm_v1 = np.linalg.norm(v1)
+        norm_v2 = np.linalg.norm(v2)
+        return dot_product / (norm_v1 * norm_v2) if norm_v1 > 0 and norm_v2 > 0 else 0.0
+
+    async def find_and_execute_tool(self, query: str, tool_args: dict = None) -> dict:
+        """
+        Dynamically finds and executes the most appropriate tool for a given query.
+
+        This function performs a semantic search over the descriptions of all
+        registered tools to find the best match for the user's query. Once the
+        tool is identified, it is executed with the provided arguments.
+
+        Args:
+            query: The natural language query describing the task.
+            tool_args: A dictionary of arguments to be passed to the selected tool.
+
+        Returns:
+            The result of the executed tool, or an error message if no
+            suitable tool is found.
+        """
+        if tool_args is None:
+            tool_args = {}
+
+        # 1. Find the best tool using semantic search
+        tool_descriptions = self.registry.get_all_tool_descriptions()
+        query_embedding = self.model.encode(query)
+        description_embeddings = self.model.encode(tool_descriptions)
+
+        similarities = [self._cosine_similarity(query_embedding, desc_emb) for desc_emb in description_embeddings]
+        best_tool_index = np.argmax(similarities)
+        best_tool_description = tool_descriptions[best_tool_index]
+        best_tool_name = self.registry.get_tool_name_from_description(best_tool_description)
+
+        # 2. Execute the best tool
+        tool_function = self.registry.get_tool_function(best_tool_name)
+        if tool_function:
+            print(f"Agent decided to use tool: '{best_tool_name}' for query: '{query}'")
+
+            sig = inspect.signature(tool_function)
+            valid_args = {key: value for key, value in tool_args.items() if key in sig.parameters}
+
+            if 'query' in sig.parameters:
+                valid_args['query'] = query
+
+            result = await tool_function(**valid_args)
+            return result
+        else:
+            return {"error": "Could not find a suitable tool for the query."}

onecoder/agentic_tool_search/registry.py

@@ -0,0 +1,33 @@
+# onecoder/agentic_tool_search/registry.py
+
+class ToolRegistry:
+    """A simple, in-memory registry for discoverable tools."""
+    def __init__(self):
+        self._tools = {}
+        self.tool_metadata = []
+
+    def register(self, tool_function, name, description, data_source=None):
+        """Registers a tool, making it available for search and execution."""
+        self._tools[name] = {
+            "function": tool_function,
+            "data_source": data_source
+        }
+        self.tool_metadata.append({
+            "name": name,
+            "description": description,
+        })
+
+    def get_tool_function(self, name):
+        return self._tools.get(name, {}).get("function")
+
+    def get_tool_data_source(self, name):
+        return self._tools.get(name, {}).get("data_source")
+
+    def get_all_tool_descriptions(self):
+        return [item['description'] for item in self.tool_metadata]
+
+    def get_tool_name_from_description(self, description):
+        for item in self.tool_metadata:
+            if item['description'] == description:
+                return item['name']
+        return None

onecoder/agents/__init__.py

@@ -0,0 +1,7 @@
+from .refactoring_agent import create_refactoring_agent
+from .documentation_agent import create_documentation_agent
+from .orchestrator_agent import create_orchestrator_agent
+from .file_reader_agent import create_file_reader_agent
+from .file_writer_agent import create_file_writer_agent
+from .research_agent import create_research_agent
+from .task_suggestion_agent import TaskSuggester

onecoder/agents/documentation_agent.py

@@ -0,0 +1,12 @@
+from google.adk.agents import LlmAgent
+from google.adk.models.lite_llm import LiteLlm
+
+
+def create_documentation_agent(model: LiteLlm) -> LlmAgent:
+    """Create a documentation agent."""
+    return LlmAgent(
+        name="documentation_agent",
+        model=model,
+        instruction="You are an expert technical writer. Your task is to write clear and concise documentation for the given code.",
+        output_key="documentation",
+    )

onecoder/agents/file_reader_agent.py

@@ -0,0 +1,19 @@
+from google.adk.agents import LlmAgent
+from google.adk.models.lite_llm import LiteLlm
+from ..tools.file_tools import read_file_tool, list_directory_tool
+
+
+def create_file_reader_agent(model: LiteLlm) -> LlmAgent:
+    """Create a file reader agent."""
+    return LlmAgent(
+        name="file_reader_agent",
+        model=model,
+        instruction=(
+            "You are a specialized file reader agent. Your ONLY job is to execute the `read_file_tool` or `list_directory_tool`. "
+            "When you receive a request, you must call the appropriate tool and return its output EXACTLY. "
+            "DO NOT add any conversational filler, explanations, or labels. "
+            "Your entire response MUST be just the content returned by the tool."
+        ),
+        tools=[read_file_tool, list_directory_tool],
+        output_key="file_content",
+    )

onecoder/agents/file_writer_agent.py

@@ -0,0 +1,19 @@
+from google.adk.agents import LlmAgent
+from google.adk.models.lite_llm import LiteLlm
+from ..tools.file_tools import write_file_tool
+
+
+def create_file_writer_agent(model: LiteLlm) -> LlmAgent:
+    """Create a file writer agent."""
+    return LlmAgent(
+        name="file_writer_agent",
+        model=model,
+        instruction=(
+            "You are a specialized file writer agent. Your ONLY job is to execute the `write_file_tool`. "
+            "When you receive a request, you must call the tool and return its output EXACTLY. "
+            "DO NOT add any conversational filler, explanations, or confirmation messages. "
+            "Your entire response MUST be just the string returned by the tool."
+        ),
+        tools=[write_file_tool],
+        output_key="write_status",
+    )

onecoder/agents/orchestrator_agent.py

@@ -0,0 +1,51 @@
+from typing import List, Optional
+from google.adk.agents import LlmAgent, BaseAgent
+from google.adk.models.lite_llm import LiteLlm
+from ..tools import registry
+from ..knowledge import ProjectKnowledge
+
+def create_orchestrator_agent(model: LiteLlm, sub_agents: Optional[List[BaseAgent]] = None) -> LlmAgent:
+    """Create an orchestrator agent that routes to specialist agents or uses tools."""
+
+    # Get available tools from registry for the prompt
+    tool_descriptions = registry.get_tool_descriptions()
+
+    # Load Project Knowledge (Governance & Context)
+    pk = ProjectKnowledge()
+    durable_context = pk.get_durable_context()
+    agents_guidelines = durable_context.get("agents_guidelines", "")
+
+    governance_section = ""
+    if agents_guidelines:
+        governance_section = f"\n\nGOVERNANCE & POLICY (Must Follow):\n{agents_guidelines}\n"
+
+    return LlmAgent(
+        name="orchestrator_agent",
+        model=model,
+        sub_agents=sub_agents or [],
+        instruction=(
+            "You are the OneCoder Orchestrator, a high-level coordination agent for a multi-agent coding system.\n"
+            f"{governance_section}\n"
+            "YOUR MISSION:\n"
+            "Analyze user requests and either solve them directly using your available tools or DELEGATE to a specialist sub-agent.\n\n"
+            "SPECIALIST SUB-AGENTS:\n"
+            "- 'refactoring_specialist': Code improvements, optimizations, and modernizing legacy code.\n"
+            "- 'documentation_specialist': Writing docstrings, READMEs, and technical documentation.\n"
+            "- 'file_reader_agent': Essential for exploring the codebase and reading file contents.\n"
+            "- 'file_writer_agent': Used to apply changes or create new files.\n"
+            "- 'research_agent': Optimized for broad codebase research, indexing, and structural analysis.\n\n"
+            "EXTERNAL CAPABILITIES:\n"
+            "- 'shell_executor': Can run any shell command. Use this for system queries or if a tool is missing.\n"
+            "- 'gemini_ask': Use this to query the Gemini CLI for assistance.\n"
+            "- **IMAGE GENERATION**: Image generation with 'nanobanana' requires the interactive Gemini TUI. If the user asks for images, instruct them to 'run gemini' in their terminal.\n\n"
+            "AVAILABLE TOOLS:\n"
+            f"{tool_descriptions}\n\n"
+            "STRATEGY:\n"
+            "1. **Analyze**: Understand if the task is deep research, focused refactoring, or simple file manipulation.\n"
+            "2. **Delegate**: If a specialist exists for the task, call that sub-agent.\n"
+            "3. **Synthesize**: When a sub-agent returns, summarize the findings and present them clearly to the user.\n\n"
+            "RESPONSE STYLE:\n"
+            "Maintain a helpful, professional engineer tone. Use markdown for code blocks and reports."
+        ),
+        output_key="final_response",
+    )

onecoder/agents/refactoring_agent.py

@@ -0,0 +1,12 @@
+from google.adk.agents import LlmAgent
+from google.adk.models.lite_llm import LiteLlm
+
+
+def create_refactoring_agent(model: LiteLlm) -> LlmAgent:
+    """Create a refactoring agent."""
+    return LlmAgent(
+        name="refactoring_agent",
+        model=model,
+        instruction="You are an expert software engineer. Your task is to refactor the given code to improve its readability, performance, and maintainability.",
+        output_key="refactored_code",
+    )

onecoder/agents/research_agent.py

@@ -0,0 +1,31 @@
+# onecoder/agents/research_agent.py
+
+from google.adk.agents import LlmAgent
+from google.adk.models.lite_llm import LiteLlm
+from ..tools.executor import executor
+
+def create_research_agent(model: LiteLlm) -> LlmAgent:
+    """
+    Create a research agent that uses the 'Agentic Search' pattern.
+    It can dynamically discover and use tools to analyze the repository.
+    """
+    
+    async def agentic_search(task_description: str) -> str:
+        """
+        Dynamically find and execute the best tool for the repository research task.
+        """
+        result = await executor.find_and_execute_tool(task_description)
+        return str(result)
+
+    return LlmAgent(
+        name="research_agent",
+        model=model,
+        instruction=(
+            "You are a repository research specialist. Your goal is to provide deep analysis of the codebase. "
+            "You have access to a powerful 'agentic_search' tool that can find and execute various repository tools (like indexing, symbols, file tree). "
+            "When asked to analyze, index, or search the repository, use 'agentic_search' with a descriptive task. "
+            "Your response should synthesize the information you find into a clear report."
+        ),
+        tools=[agentic_search],
+        output_key="research_report",
+    )

onecoder/agents/task_suggestion_agent.py

@@ -0,0 +1,88 @@
+import os
+import json
+import logging
+from typing import List, Dict, Any
+
+try:
+    import litellm
+except ImportError:
+    litellm = None
+
+logger = logging.getLogger(__name__)
+
+class TaskSuggester:
+    """
+    Analyzes project context and suggests actionable tasks using an LLM.
+    """
+    def __init__(self, model_name: str = "openrouter/xiaomi/mimo-v2-flash:free"):
+        self.model_name = os.getenv("ONECODER_MODEL", model_name)
+        self.api_key = os.getenv("OPENROUTER_API_KEY")
+
+    def suggest_next_tasks(self, context: List[Dict[str, Any]]) -> List[Dict[str, str]]:
+        """
+        Generates task suggestions based on sprint context.
+        """
+        if not litellm or not self.api_key:
+            logger.warning("LLM dependencies not met. Returning empty suggestions.")
+            return []
+
+        prompt = self._construct_prompt(context)
+        
+        try:
+            response = litellm.completion(
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                api_key=self.api_key,
+                base_url="https://openrouter.ai/api/v1",
+                response_format={"type": "json_object"}
+            )
+            
+            content = response.choices[0].message.content
+            return self._parse_response(content)
+        except Exception as e:
+            logger.error(f"Task suggestion failed: {e}")
+            return []
+
+    def _construct_prompt(self, context: List[Dict[str, Any]]) -> str:
+        sprints_str = json.dumps(context, indent=2)
+        return f"""
+        You are an expert Agile Technical Project Manager and Architect.
+        Analyze the following context from recent sprints (goals, completed tasks, learnings, backlogs) and suggest 3-5 high-impact next tasks.
+        
+        Focus on:
+        1. carrying over important incomplete work.
+        2. applying 'learnings' to improved workflows or automated fixes.
+        3. logically progressing towards sprint goals.
+
+        Context:
+        {sprints_str}
+
+        Return a JSON object with a key "suggestions" containing a list of objects, each with:
+        - "title": Short, actionable title (e.g., "Implement retry logic for API").
+        - "rationale": Why this is important based on context.
+        - "type": One of "feature", "fix", "chore", "governance".
+        
+        Example:
+        {{
+            "suggestions": [
+                {{ "title": "...", "rationale": "...", "type": "..." }}
+            ]
+        }}
+        """
+
+    def _parse_response(self, content: str) -> List[Dict[str, str]]:
+        try:
+            data = json.loads(content)
+            if isinstance(data, dict) and "suggestions" in data:
+                return data["suggestions"]
+            elif isinstance(data, list):
+                return data
+            return []
+        except json.JSONDecodeError:
+            # Simple fallback extraction if JSON fails
+            import re
+            suggestions = []
+            matches = re.findall(r'"title":\s*"(.*?)"', content)
+            for m in matches:
+                suggestions.append({"title": m, "rationale": "Extracted from text", "type": "task"})
+            return suggestions