@voria/cli 0.0.2

package/python/voria/core/llm/claude_provider.py

@@ -0,0 +1,188 @@
+"""Anthropic Claude LLM Provider"""
+
+import logging
+from typing import List, Dict, Any, Optional
+import httpx
+
+from .base import BaseLLMProvider, Message, LLMResponse
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeProvider(BaseLLMProvider):
+    """Anthropic Claude LLM Provider"""
+
+    API_ENDPOINT = "https://api.anthropic.com/v1/messages"
+    DEFAULT_MODEL = "claude-3-opus-20240229"
+
+    def __init__(self, api_key: str, model: str = DEFAULT_MODEL):
+        """
+        Initialize Claude provider
+
+        Args:
+            api_key: Anthropic API key
+            model: Model (claude-3-opus, claude-3-sonnet, claude-3-haiku)
+        """
+        super().__init__(api_key, model)
+        self.client = httpx.AsyncClient(
+            headers={
+                "x-api-key": api_key,
+                "anthropic-version": "2023-06-01",
+                "content-type": "application/json",
+            },
+            timeout=300.0,
+        )
+
+    async def generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ) -> LLMResponse:
+        """Generate response using Claude"""
+        try:
+            # Separate system message from user messages
+            system_content = ""
+            user_messages = []
+
+            for msg in messages:
+                if msg.role == "system":
+                    system_content = msg.content
+                else:
+                    user_messages.append({"role": msg.role, "content": msg.content})
+
+            payload = {
+                "model": self.model,
+                "max_tokens": max_tokens,
+                "messages": user_messages,
+                "temperature": temperature,
+            }
+
+            if system_content:
+                payload["system"] = system_content
+
+            logger.debug(f"Calling Claude API with {len(user_messages)} messages")
+
+            response = await self.client.post(self.API_ENDPOINT, json=payload)
+            response.raise_for_status()
+
+            data = response.json()
+            content = data["content"][0]["text"]
+
+            # Claude returns token usage directly
+            tokens_used = data.get("usage", {}).get("output_tokens", 0)
+            input_tokens = data.get("usage", {}).get("input_tokens", 0)
+            total_tokens = input_tokens + tokens_used
+
+            logger.info(
+                f"Claude API response: {tokens_used} output tokens "
+                f"({input_tokens} input, {total_tokens} total)"
+            )
+
+            return LLMResponse(
+                content=content,
+                tokens_used=total_tokens,
+                model=self.model,
+                provider="Claude",
+            )
+
+        except httpx.HTTPError as e:
+            logger.error(f"Claude API error: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Error generating with Claude: {e}")
+            raise
+
+    async def plan(self, issue_description: str) -> str:
+        """Generate implementation plan"""
+        system_message = Message(
+            role="system",
+            content="""You are an expert software architect with decades of experience.
+Create a detailed, step-by-step implementation plan for fixing this GitHub issue.
+Include analysis, approach, and testing strategy.""",
+        )
+
+        user_message = Message(
+            role="user", content=f"GitHub Issue:\n{issue_description}"
+        )
+
+        response = await self.generate(
+            [system_message, user_message], max_tokens=2000, temperature=0.7
+        )
+
+        return response.content
+
+    async def generate_patch(
+        self,
+        issue_description: str,
+        context_files: Dict[str, str],
+        previous_errors: Optional[str] = None,
+    ) -> str:
+        """Generate code patch in unified diff format"""
+        system_message = Message(
+            role="system",
+            content="""You are an expert code generator and software engineer.
+Generate a unified diff format patch to fix the issue.
+
+Use this format exactly:
+--- a/path/to/file
++++ b/path/to/file
+@@ -line,count +line,count @@
+ context line
+-removed line
++added line
+
+Generate complete, working patches that will fix the issue.""",
+        )
+
+        context = f"Issue:\n{issue_description}\n\n"
+        context += "Current Code:\n"
+        for filename, content in context_files.items():
+            context += f"\n--- {filename} ---\n{content}\n"
+
+        if previous_errors:
+            context += f"\nPrevious Attempt Errors:\n{previous_errors}"
+
+        user_message = Message(role="user", content=context)
+
+        response = await self.generate(
+            [system_message, user_message], max_tokens=3000, temperature=0.5
+        )
+
+        return response.content
+
+    async def analyze_test_failure(
+        self, test_output: str, code_context: str
+    ) -> Dict[str, Any]:
+        """Analyze test failure and suggest improvements"""
+        system_message = Message(
+            role="system",
+            content="""Analyze the test failure in detail.
+Provide:
+1. Root cause analysis
+2. Why the fix didn't work
+3. Specific suggestions for improvement
+4. Next approach to try
+
+Be technical and precise.""",
+        )
+
+        user_message = Message(
+            role="user",
+            content=f"""Test Output:
+{test_output}
+
+Code Context:
+{code_context}""",
+        )
+
+        response = await self.generate(
+            [system_message, user_message], max_tokens=1500, temperature=0.7
+        )
+
+        return {
+            "analysis": response.content,
+            "provider": "Claude",
+            "tokens_used": response.tokens_used,
+        }
+
+    async def close(self):
+        """Close HTTP client"""
+        await self.client.aclose()

package/python/voria/core/llm/gemini_provider.py

@@ -0,0 +1,148 @@
+"""Google Gemini LLM Provider"""
+
+import logging
+from typing import List, Dict, Any, Optional
+import httpx
+
+from .base import BaseLLMProvider, Message, LLMResponse
+
+logger = logging.getLogger(__name__)
+
+
+class GeminiProvider(BaseLLMProvider):
+    """Google Gemini Pro LLM Provider"""
+
+    API_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/models"
+    DEFAULT_MODEL = "gemini-pro"
+
+    def __init__(self, api_key: str, model: str = DEFAULT_MODEL):
+        """
+        Initialize Gemini provider
+
+        Args:
+            api_key: Google API key
+            model: Model (gemini-pro, gemini-pro-vision, etc)
+        """
+        super().__init__(api_key, model)
+        self.client = httpx.AsyncClient(timeout=300.0)
+
+    async def generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ) -> LLMResponse:
+        """Generate response using Gemini"""
+        try:
+            # Convert messages to Gemini format
+            contents = []
+            for msg in messages:
+                contents.append(
+                    {
+                        "role": "user" if msg.role == "user" else "model",
+                        "parts": [{"text": msg.content}],
+                    }
+                )
+
+            payload = {
+                "contents": contents,
+                "generationConfig": {
+                    "maxOutputTokens": max_tokens,
+                    "temperature": temperature,
+                },
+            }
+
+            url = f"{self.API_ENDPOINT}/{self.model}:generateContent?key={self.api_key}"
+
+            logger.debug(f"Calling Gemini API with {len(messages)} messages")
+
+            response = await self.client.post(url, json=payload)
+            response.raise_for_status()
+
+            data = response.json()
+            content = data["candidates"][0]["content"]["parts"][0]["text"]
+
+            # Estimate tokens (Gemini doesn't always return token count)
+            tokens_used = len(content.split()) * 1.3  # Rough estimate
+
+            logger.info(f"Gemini API response: ~{int(tokens_used)} tokens")
+
+            return LLMResponse(
+                content=content,
+                tokens_used=int(tokens_used),
+                model=self.model,
+                provider="Gemini",
+            )
+
+        except httpx.HTTPError as e:
+            logger.error(f"Gemini API error: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Error generating with Gemini: {e}")
+            raise
+
+    async def plan(self, issue_description: str) -> str:
+        """Generate implementation plan"""
+        system_message = Message(
+            role="system",
+            content="""You are an expert software architect.
+Create a detailed implementation plan for fixing this GitHub issue.""",
+        )
+
+        user_message = Message(role="user", content=f"Issue:\n{issue_description}")
+
+        response = await self.generate([system_message, user_message], max_tokens=2000)
+
+        return response.content
+
+    async def generate_patch(
+        self,
+        issue_description: str,
+        context_files: Dict[str, str],
+        previous_errors: Optional[str] = None,
+    ) -> str:
+        """Generate code patch"""
+        system_message = Message(
+            role="system", content="""Generate a unified diff format patch."""
+        )
+
+        context = f"Issue:\n{issue_description}\n\n"
+        for filename, content in context_files.items():
+            context += f"\n--- {filename} ---\n{content}\n"
+
+        if previous_errors:
+            context += f"\nPrevious Errors:\n{previous_errors}"
+
+        user_message = Message(role="user", content=context)
+
+        response = await self.generate(
+            [system_message, user_message], max_tokens=3000, temperature=0.5
+        )
+
+        return response.content
+
+    async def analyze_test_failure(
+        self, test_output: str, code_context: str
+    ) -> Dict[str, Any]:
+        """Analyze test failure"""
+        system_message = Message(
+            role="system", content="Analyze the test failure and suggest fixes."
+        )
+
+        user_message = Message(
+            role="user",
+            content=f"""Test Output:
+{test_output}
+
+Code:
+{code_context}""",
+        )
+
+        response = await self.generate([system_message, user_message], max_tokens=1500)
+
+        return {
+            "analysis": response.content,
+            "provider": "Gemini",
+            "tokens_used": response.tokens_used,
+        }
+
+    async def close(self):
+        """Close HTTP client"""
+        await self.client.aclose()

package/python/voria/core/llm/modal_provider.py

@@ -0,0 +1,228 @@
+"""Modal Z.ai GLM-5.1 LLM Provider Integration
+
+Modal Research provides the Z.ai GLM-5.1-FP8 model via their API.
+Docs: https://modal.com
+Model: zai-org/GLM-5.1-FP8 (745B parameters)
+"""
+
+import logging
+from typing import List, Dict, Any, Optional
+import httpx
+import asyncio
+
+from .base import BaseLLMProvider, Message, LLMResponse
+
+logger = logging.getLogger(__name__)
+
+
+class ModalProvider(BaseLLMProvider):
+    """Modal Z.ai GLM-5.1 LLM Provider"""
+
+    API_ENDPOINT = "https://api.us-west-2.modal.direct/v1/chat/completions"
+    DEFAULT_MODEL = "zai-org/GLM-5.1-FP8"
+
+    def __init__(self, api_key: str, model: str = DEFAULT_MODEL):
+        """
+        Initialize Modal provider
+
+        Args:
+            api_key: Modal API token
+            model: Model identifier (default: GLM-5.1-FP8)
+        """
+        super().__init__(api_key, model)
+        self.client = httpx.AsyncClient(
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=300.0,
+        )
+
+    async def generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ) -> LLMResponse:
+        """
+        Generate response using Modal Z.ai
+
+        Args:
+            messages: Chat messages
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+
+        Returns:
+            LLMResponse with content and token info
+        """
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [
+                    {"role": msg.role, "content": msg.content} for msg in messages
+                ],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+            }
+
+            logger.debug(f"Calling Modal API with {len(messages)} messages")
+
+            response = await self.client.post(self.API_ENDPOINT, json=payload)
+            response.raise_for_status()
+
+            data = response.json()
+            content = data["choices"][0]["message"]["content"]
+            tokens_used = data.get("usage", {}).get("total_tokens", 0)
+
+            logger.info(f"Modal API response: {tokens_used} tokens used")
+
+            return LLMResponse(
+                content=content,
+                tokens_used=tokens_used,
+                model=self.model,
+                provider="Modal",
+            )
+
+        except httpx.HTTPError as e:
+            logger.error(f"Modal API error: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Error generating with Modal: {e}")
+            raise
+
+    async def plan(self, issue_description: str) -> str:
+        """
+        Generate implementation plan from issue
+
+        Args:
+            issue_description: GitHub issue text
+
+        Returns:
+            Implementation plan
+        """
+        system_message = Message(
+            role="system",
+            content="""You are an expert software architect analyzing GitHub issues.
+Your task is to create a detailed implementation plan for fixing the issue.
+
+Include:
+1. Problem analysis
+2. Root cause identification
+3. Solution approach
+4. Files to modify
+5. Testing strategy
+
+Be concise but thorough.""",
+        )
+
+        user_message = Message(
+            role="user", content=f"GitHub Issue:\n{issue_description}"
+        )
+
+        response = await self.generate(
+            [system_message, user_message], max_tokens=2000, temperature=0.7
+        )
+
+        return response.content
+
+    async def generate_patch(
+        self,
+        issue_description: str,
+        context_files: Dict[str, str],
+        previous_errors: Optional[str] = None,
+    ) -> str:
+        """
+        Generate code patch
+
+        Args:
+            issue_description: Issue description
+            context_files: Dict of filename -> file content
+            previous_errors: Errors from previous attempt
+
+        Returns:
+            Unified diff format patch
+        """
+        system_message = Message(
+            role="system",
+            content="""You are an expert code generator.
+Generate a unified diff format patch to fix the issue.
+
+Format:
+--- a/path/to/file
++++ b/path/to/file
+@@ -line,count +line,count @@
+ unchanged line
+-removed line
++added line
+
+Generate complete, working patches.""",
+        )
+
+        context = f"Issue:\n{issue_description}\n\n"
+        context += "Current Code:\n"
+        for filename, content in context_files.items():
+            context += f"\n--- {filename} ---\n{content}\n"
+
+        if previous_errors:
+            context += f"\nPrevious Errors:\n{previous_errors}"
+
+        user_message = Message(role="user", content=context)
+
+        response = await self.generate(
+            [system_message, user_message], max_tokens=3000, temperature=0.5
+        )
+
+        return response.content
+
+    async def analyze_test_failure(
+        self, test_output: str, code_context: str
+    ) -> Dict[str, Any]:
+        """
+        Analyze test failure and suggest fix
+
+        Args:
+            test_output: Test output/error logs
+            code_context: Relevant code snippet
+
+        Returns:
+            Analysis dict with suggestions
+        """
+        system_message = Message(
+            role="system",
+            content="""Analyze the test failure and provide:
+1. Root cause
+2. Why the fix didn't work
+3. Suggested improvements
+4. Next approach
+
+Be technical and specific.""",
+        )
+
+        user_message = Message(
+            role="user",
+            content=f"""Test Output:
+{test_output}
+
+Code Context:
+{code_context}""",
+        )
+
+        response = await self.generate(
+            [system_message, user_message], max_tokens=1500, temperature=0.7
+        )
+
+        return {
+            "analysis": response.content,
+            "provider": "Modal",
+            "tokens_used": response.tokens_used,
+        }
+
+    async def close(self):
+        """Close HTTP client"""
+        await self.client.aclose()
+
+    def __del__(self):
+        """Cleanup on deletion"""
+        try:
+            # Don't try to run async cleanup in __del__ as it may cause issues
+            # The context manager or explicit close() should handle cleanup
+            return
+        except:
+            pass