gitview 0.1.0__py3-none-any.whl

gitview/__init__.py

@@ -0,0 +1,3 @@
+"""GitView - Git history analyzer with LLM-powered narrative generation."""
+
+__version__ = "0.1.0"

gitview/backends/__init__.py

@@ -0,0 +1,18 @@
+"""LLM backends for GitView."""
+
+from .base import BaseLLMBackend, LLMMessage, LLMResponse
+from .anthropic_backend import AnthropicBackend
+from .ollama_backend import OllamaBackend
+from .openai_backend import OpenAIBackend
+from .router import LLMRouter, LLMBackend
+
+__all__ = [
+    'BaseLLMBackend',
+    'LLMMessage',
+    'LLMResponse',
+    'AnthropicBackend',
+    'OllamaBackend',
+    'OpenAIBackend',
+    'LLMRouter',
+    'LLMBackend',
+]

gitview/backends/anthropic_backend.py

@@ -0,0 +1,66 @@
+"""Anthropic Claude backend."""
+
+from typing import List, Optional
+
+from anthropic import Anthropic
+
+from .base import BaseLLMBackend, LLMMessage, LLMResponse
+
+
+class AnthropicBackend(BaseLLMBackend):
+    """Anthropic Claude backend."""
+
+    def __init__(self, model: str, api_key: str, temperature: float = 0.7, **kwargs):
+        """
+        Initialize Anthropic backend.
+
+        Args:
+            model: Claude model identifier
+            api_key: Anthropic API key
+            temperature: Temperature for generation
+            **kwargs: Additional parameters
+        """
+        super().__init__(model, temperature, **kwargs)
+        self.client = Anthropic(api_key=api_key)
+
+    def generate(self, messages: List[LLMMessage], max_tokens: int = 2000,
+                **kwargs) -> LLMResponse:
+        """
+        Generate completion using Claude.
+
+        Args:
+            messages: List of messages
+            max_tokens: Maximum tokens to generate
+            **kwargs: Additional generation parameters
+
+        Returns:
+            LLMResponse object
+        """
+        # Convert messages to Anthropic format
+        anthropic_messages = [
+            {"role": msg.role, "content": msg.content}
+            for msg in messages
+        ]
+
+        # Call Anthropic API
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=max_tokens,
+            temperature=kwargs.get('temperature', self.temperature),
+            messages=anthropic_messages
+        )
+
+        # Extract usage info
+        usage = {
+            'prompt_tokens': response.usage.input_tokens,
+            'completion_tokens': response.usage.output_tokens,
+            'total_tokens': response.usage.input_tokens + response.usage.output_tokens
+        }
+
+        # Return standardized response
+        return LLMResponse(
+            content=response.content[0].text,
+            model=response.model,
+            usage=usage,
+            metadata={'stop_reason': response.stop_reason}
+        )

gitview/backends/base.py

@@ -0,0 +1,60 @@
+"""Base LLM backend interface."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class LLMMessage:
+    """Standard message format for LLM APIs."""
+
+    role: str  # "user", "assistant", "system"
+    content: str
+
+
+@dataclass
+class LLMResponse:
+    """Standard response format from LLM APIs."""
+
+    content: str
+    model: str
+    usage: Optional[Dict[str, int]] = None  # Token usage stats
+    metadata: Optional[Dict[str, Any]] = None  # Additional metadata
+
+
+class BaseLLMBackend(ABC):
+    """Base class for LLM backends."""
+
+    def __init__(self, model: str, temperature: float = 0.7, **kwargs):
+        """
+        Initialize backend.
+
+        Args:
+            model: Model identifier
+            temperature: Temperature for generation (0.0 - 1.0)
+            **kwargs: Additional backend-specific parameters
+        """
+        self.model = model
+        self.temperature = temperature
+        self.kwargs = kwargs
+
+    @abstractmethod
+    def generate(self, messages: List[LLMMessage], max_tokens: int = 2000,
+                **kwargs) -> LLMResponse:
+        """
+        Generate completion from messages.
+
+        Args:
+            messages: List of messages
+            max_tokens: Maximum tokens to generate
+            **kwargs: Additional generation parameters
+
+        Returns:
+            LLMResponse object
+        """
+        pass
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}(model={self.model}, temperature={self.temperature})"

gitview/backends/ollama_backend.py

@@ -0,0 +1,96 @@
+"""Ollama backend for local LLM inference."""
+
+import json
+from typing import List, Optional
+
+import requests
+
+from .base import BaseLLMBackend, LLMMessage, LLMResponse
+
+
+class OllamaBackend(BaseLLMBackend):
+    """Ollama local LLM backend."""
+
+    def __init__(self, model: str, api_url: str = "http://localhost:11434",
+                 temperature: float = 0.7, **kwargs):
+        """
+        Initialize Ollama backend.
+
+        Args:
+            model: Ollama model identifier (e.g., "llama3", "mistral")
+            api_url: Ollama API URL
+            temperature: Temperature for generation
+            **kwargs: Additional parameters
+        """
+        super().__init__(model, temperature, **kwargs)
+        self.api_url = api_url.rstrip('/')
+
+    def generate(self, messages: List[LLMMessage], max_tokens: int = 2000,
+                **kwargs) -> LLMResponse:
+        """
+        Generate completion using Ollama.
+
+        Args:
+            messages: List of messages
+            max_tokens: Maximum tokens to generate
+            **kwargs: Additional generation parameters
+
+        Returns:
+            LLMResponse object
+        """
+        # Convert messages to Ollama format
+        ollama_messages = [
+            {"role": msg.role, "content": msg.content}
+            for msg in messages
+        ]
+
+        # Prepare request
+        payload = {
+            "model": self.model,
+            "messages": ollama_messages,
+            "stream": False,
+            "options": {
+                "temperature": kwargs.get('temperature', self.temperature),
+                "num_predict": max_tokens,
+            }
+        }
+
+        # Call Ollama API
+        try:
+            response = requests.post(
+                f"{self.api_url}/api/chat",
+                json=payload,
+                timeout=120  # 2 minute timeout for local inference
+            )
+            response.raise_for_status()
+            data = response.json()
+
+            # Extract content
+            content = data.get('message', {}).get('content', '')
+
+            # Extract usage if available
+            usage = None
+            if 'prompt_eval_count' in data and 'eval_count' in data:
+                usage = {
+                    'prompt_tokens': data.get('prompt_eval_count', 0),
+                    'completion_tokens': data.get('eval_count', 0),
+                    'total_tokens': data.get('prompt_eval_count', 0) + data.get('eval_count', 0)
+                }
+
+            # Return standardized response
+            return LLMResponse(
+                content=content,
+                model=data.get('model', self.model),
+                usage=usage,
+                metadata={
+                    'done': data.get('done', False),
+                    'total_duration': data.get('total_duration'),
+                }
+            )
+
+        except requests.exceptions.RequestException as e:
+            raise RuntimeError(
+                f"Ollama API error: {e}\n"
+                f"Make sure Ollama is running at {self.api_url}\n"
+                f"Start it with: ollama serve"
+            ) from e

gitview/backends/openai_backend.py

@@ -0,0 +1,71 @@
+"""OpenAI backend."""
+
+from typing import List, Optional
+
+from openai import OpenAI
+
+from .base import BaseLLMBackend, LLMMessage, LLMResponse
+
+
+class OpenAIBackend(BaseLLMBackend):
+    """OpenAI GPT backend."""
+
+    def __init__(self, model: str, api_key: str, temperature: float = 0.7, **kwargs):
+        """
+        Initialize OpenAI backend.
+
+        Args:
+            model: OpenAI model identifier (e.g., "gpt-4", "gpt-3.5-turbo")
+            api_key: OpenAI API key
+            temperature: Temperature for generation
+            **kwargs: Additional parameters
+        """
+        super().__init__(model, temperature, **kwargs)
+        self.client = OpenAI(api_key=api_key)
+
+    def generate(self, messages: List[LLMMessage], max_tokens: int = 2000,
+                **kwargs) -> LLMResponse:
+        """
+        Generate completion using OpenAI.
+
+        Args:
+            messages: List of messages
+            max_tokens: Maximum tokens to generate
+            **kwargs: Additional generation parameters
+
+        Returns:
+            LLMResponse object
+        """
+        # Convert messages to OpenAI format
+        openai_messages = [
+            {"role": msg.role, "content": msg.content}
+            for msg in messages
+        ]
+
+        # Call OpenAI API
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=openai_messages,
+            max_tokens=max_tokens,
+            temperature=kwargs.get('temperature', self.temperature)
+        )
+
+        # Extract usage info
+        usage = None
+        if response.usage:
+            usage = {
+                'prompt_tokens': response.usage.prompt_tokens,
+                'completion_tokens': response.usage.completion_tokens,
+                'total_tokens': response.usage.total_tokens
+            }
+
+        # Return standardized response
+        return LLMResponse(
+            content=response.choices[0].message.content,
+            model=response.model,
+            usage=usage,
+            metadata={
+                'finish_reason': response.choices[0].finish_reason,
+                'created': response.created
+            }
+        )

gitview/backends/router.py

@@ -0,0 +1,164 @@
+"""Simplified LLM router for GitView."""
+
+import os
+from enum import Enum
+from typing import Optional, List
+
+from .base import BaseLLMBackend, LLMMessage
+from .anthropic_backend import AnthropicBackend
+from .ollama_backend import OllamaBackend
+from .openai_backend import OpenAIBackend
+
+
+class LLMBackend(str, Enum):
+    """Supported LLM backends."""
+
+    ANTHROPIC = "anthropic"
+    OPENAI = "openai"
+    OLLAMA = "ollama"
+
+
+class LLMRouter:
+    """Routes LLM requests to appropriate backend."""
+
+    # Default models for each backend
+    DEFAULT_MODELS = {
+        LLMBackend.ANTHROPIC: "claude-sonnet-4-5-20250929",
+        LLMBackend.OPENAI: "gpt-4",
+        LLMBackend.OLLAMA: "llama3",
+    }
+
+    def __init__(self, backend: Optional[str] = None, model: Optional[str] = None,
+                 api_key: Optional[str] = None, **kwargs):
+        """
+        Initialize LLM router.
+
+        Args:
+            backend: Backend to use ('anthropic', 'openai', 'ollama')
+            model: Model identifier (uses defaults if not specified)
+            api_key: API key for the backend (if required)
+            **kwargs: Additional backend-specific parameters
+        """
+        # Determine backend
+        if backend:
+            self.backend_type = LLMBackend(backend.lower())
+        else:
+            # Auto-detect from environment
+            if os.environ.get('ANTHROPIC_API_KEY'):
+                self.backend_type = LLMBackend.ANTHROPIC
+            elif os.environ.get('OPENAI_API_KEY'):
+                self.backend_type = LLMBackend.OPENAI
+            else:
+                self.backend_type = LLMBackend.OLLAMA
+
+        # Determine model
+        self.model = model or self.DEFAULT_MODELS[self.backend_type]
+
+        # Determine API key
+        if api_key:
+            self.api_key = api_key
+        else:
+            # Try to get from environment
+            if self.backend_type == LLMBackend.ANTHROPIC:
+                self.api_key = os.environ.get('ANTHROPIC_API_KEY')
+            elif self.backend_type == LLMBackend.OPENAI:
+                self.api_key = os.environ.get('OPENAI_API_KEY')
+            else:
+                self.api_key = None  # Not needed for Ollama
+
+        # Additional parameters
+        self.kwargs = kwargs
+
+        # Create backend
+        self._backend: Optional[BaseLLMBackend] = None
+
+    def _get_backend(self) -> BaseLLMBackend:
+        """Get or create backend instance."""
+        if self._backend is None:
+            temperature = self.kwargs.get('temperature', 0.7)
+
+            if self.backend_type == LLMBackend.ANTHROPIC:
+                if not self.api_key:
+                    raise ValueError(
+                        "Anthropic API key required. Set ANTHROPIC_API_KEY environment variable "
+                        "or pass api_key parameter."
+                    )
+                self._backend = AnthropicBackend(
+                    model=self.model,
+                    api_key=self.api_key,
+                    temperature=temperature
+                )
+
+            elif self.backend_type == LLMBackend.OPENAI:
+                if not self.api_key:
+                    raise ValueError(
+                        "OpenAI API key required. Set OPENAI_API_KEY environment variable "
+                        "or pass api_key parameter."
+                    )
+                self._backend = OpenAIBackend(
+                    model=self.model,
+                    api_key=self.api_key,
+                    temperature=temperature
+                )
+
+            elif self.backend_type == LLMBackend.OLLAMA:
+                ollama_url = self.kwargs.get('ollama_url', 'http://localhost:11434')
+                self._backend = OllamaBackend(
+                    model=self.model,
+                    api_url=ollama_url,
+                    temperature=temperature
+                )
+
+        return self._backend
+
+    def generate(self, messages: List[LLMMessage], max_tokens: int = 2000, **kwargs):
+        """
+        Generate completion.
+
+        Args:
+            messages: List of messages
+            max_tokens: Maximum tokens to generate
+            **kwargs: Additional generation parameters
+
+        Returns:
+            LLMResponse object
+        """
+        backend = self._get_backend()
+        return backend.generate(messages, max_tokens, **kwargs)
+
+    def generate_text(self, prompt: str, max_tokens: int = 2000, **kwargs) -> str:
+        """
+        Generate completion from a simple text prompt.
+
+        Args:
+            prompt: Text prompt
+            max_tokens: Maximum tokens to generate
+            **kwargs: Additional generation parameters
+
+        Returns:
+            Generated text
+        """
+        messages = [LLMMessage(role="user", content=prompt)]
+        response = self.generate(messages, max_tokens, **kwargs)
+        return response.content
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"LLMRouter(backend={self.backend_type.value}, model={self.model})"
+
+
+def create_router(backend: Optional[str] = None, model: Optional[str] = None,
+                 api_key: Optional[str] = None, **kwargs) -> LLMRouter:
+    """
+    Create an LLM router.
+
+    Args:
+        backend: Backend to use ('anthropic', 'openai', 'ollama')
+        model: Model identifier
+        api_key: API key for the backend
+        **kwargs: Additional backend parameters
+
+    Returns:
+        LLMRouter instance
+    """
+    return LLMRouter(backend=backend, model=model, api_key=api_key, **kwargs)