cognify-code 0.2.0__py3-none-any.whl

ai_code_assistant/git/manager.py

@@ -0,0 +1,203 @@
+"""Git repository manager."""
+
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+
+@dataclass
+class GitStatus:
+    """Represents the current git status."""
+    staged: List[str] = field(default_factory=list)
+    modified: List[str] = field(default_factory=list)
+    untracked: List[str] = field(default_factory=list)
+    deleted: List[str] = field(default_factory=list)
+    branch: str = ""
+    remote: str = ""
+    ahead: int = 0
+    behind: int = 0
+    
+    @property
+    def has_changes(self) -> bool:
+        return bool(self.staged or self.modified or self.untracked or self.deleted)
+    
+    @property
+    def has_staged(self) -> bool:
+        return bool(self.staged)
+    
+    @property
+    def total_changes(self) -> int:
+        return len(self.staged) + len(self.modified) + len(self.untracked) + len(self.deleted)
+
+
+@dataclass
+class GitDiff:
+    """Represents a git diff."""
+    files_changed: int = 0
+    insertions: int = 0
+    deletions: int = 0
+    diff_text: str = ""
+    file_diffs: List[dict] = field(default_factory=list)
+
+
+class GitManager:
+    """Manages git operations."""
+    
+    def __init__(self, repo_path: Optional[Path] = None):
+        self.repo_path = repo_path or Path.cwd()
+        self._validate_repo()
+    
+    def _validate_repo(self) -> None:
+        """Validate that we're in a git repository."""
+        if not (self.repo_path / ".git").exists():
+            raise ValueError(f"Not a git repository: {self.repo_path}")
+    
+    def _run_git(self, *args: str, check: bool = True) -> subprocess.CompletedProcess:
+        """Run a git command."""
+        result = subprocess.run(
+            ["git", *args],
+            cwd=self.repo_path,
+            capture_output=True,
+            text=True,
+        )
+        if check and result.returncode != 0:
+            raise RuntimeError(f"Git command failed: {result.stderr}")
+        return result
+    
+    def get_status(self) -> GitStatus:
+        """Get current git status."""
+        status = GitStatus()
+        
+        # Get branch name
+        result = self._run_git("branch", "--show-current", check=False)
+        status.branch = result.stdout.strip()
+        
+        # Get remote
+        result = self._run_git("remote", check=False)
+        status.remote = result.stdout.strip().split("\n")[0] if result.stdout else "origin"
+        
+        # Get ahead/behind
+        result = self._run_git("rev-list", "--left-right", "--count", f"{status.remote}/{status.branch}...HEAD", check=False)
+        if result.returncode == 0 and result.stdout.strip():
+            parts = result.stdout.strip().split()
+            if len(parts) == 2:
+                status.behind, status.ahead = int(parts[0]), int(parts[1])
+        
+        # Get file status
+        result = self._run_git("status", "--porcelain", check=False)
+        for line in result.stdout.strip().split("\n"):
+            if not line:
+                continue
+            status_code = line[:2]
+            file_path = line[3:]
+            
+            if status_code[0] in "MADRC":
+                status.staged.append(file_path)
+            if status_code[1] == "M":
+                status.modified.append(file_path)
+            elif status_code[1] == "D":
+                status.deleted.append(file_path)
+            elif status_code == "??":
+                status.untracked.append(file_path)
+        
+        return status
+    
+    def get_diff(self, staged: bool = True) -> GitDiff:
+        """Get diff of changes."""
+        diff = GitDiff()
+        
+        # Get diff text
+        if staged:
+            result = self._run_git("diff", "--cached", check=False)
+        else:
+            result = self._run_git("diff", check=False)
+        
+        diff.diff_text = result.stdout
+        
+        # Get stats
+        if staged:
+            result = self._run_git("diff", "--cached", "--stat", check=False)
+        else:
+            result = self._run_git("diff", "--stat", check=False)
+        
+        # Parse stats from last line
+        lines = result.stdout.strip().split("\n")
+        if lines and lines[-1]:
+            last_line = lines[-1]
+            # Parse "X files changed, Y insertions(+), Z deletions(-)"
+            import re
+            match = re.search(r"(\d+) files? changed", last_line)
+            if match:
+                diff.files_changed = int(match.group(1))
+            match = re.search(r"(\d+) insertions?", last_line)
+            if match:
+                diff.insertions = int(match.group(1))
+            match = re.search(r"(\d+) deletions?", last_line)
+            if match:
+                diff.deletions = int(match.group(1))
+        
+        return diff
+    
+    def stage_all(self) -> None:
+        """Stage all changes."""
+        self._run_git("add", "-A")
+    
+    def stage_files(self, files: List[str]) -> None:
+        """Stage specific files."""
+        self._run_git("add", *files)
+    
+    def commit(self, message: str) -> str:
+        """Create a commit with the given message."""
+        result = self._run_git("commit", "-m", message)
+        # Extract commit hash from output
+        import re
+        match = re.search(r"\[[\w-]+ ([a-f0-9]+)\]", result.stdout)
+        return match.group(1) if match else ""
+    
+    def push(self, remote: str = "origin", branch: Optional[str] = None, 
+             set_upstream: bool = False) -> Tuple[bool, str]:
+        """Push to remote."""
+        status = self.get_status()
+        branch = branch or status.branch
+        
+        args = ["push"]
+        if set_upstream:
+            args.extend(["-u", remote, branch])
+        else:
+            args.extend([remote, branch])
+        
+        result = self._run_git(*args, check=False)
+        success = result.returncode == 0
+        output = result.stdout + result.stderr
+        
+        return success, output
+    
+    def get_recent_commits(self, count: int = 5) -> List[dict]:
+        """Get recent commits."""
+        result = self._run_git(
+            "log", f"-{count}", 
+            "--pretty=format:%H|%h|%s|%an|%ar",
+            check=False
+        )
+        
+        commits = []
+        for line in result.stdout.strip().split("\n"):
+            if not line:
+                continue
+            parts = line.split("|")
+            if len(parts) >= 5:
+                commits.append({
+                    "hash": parts[0],
+                    "short_hash": parts[1],
+                    "message": parts[2],
+                    "author": parts[3],
+                    "time": parts[4],
+                })
+        
+        return commits
+    
+    def get_remote_url(self) -> str:
+        """Get the remote URL."""
+        result = self._run_git("remote", "get-url", "origin", check=False)
+        return result.stdout.strip()

ai_code_assistant/llm.py

@@ -0,0 +1,111 @@
+"""LLM Manager for multi-provider LLM integration via LangChain."""
+
+from typing import Iterator, Optional
+
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate
+
+from ai_code_assistant.config import Config
+from ai_code_assistant.providers.base import BaseProvider, ProviderConfig, ProviderType
+from ai_code_assistant.providers.factory import get_provider, get_available_providers
+
+
+class LLMManager:
+    """Manages LLM interactions using LangChain with multiple provider support."""
+
+    def __init__(self, config: Config):
+        """Initialize LLM manager with configuration."""
+        self.config = config
+        self._provider: Optional[BaseProvider] = None
+
+    @property
+    def provider(self) -> BaseProvider:
+        """Get or create the provider instance."""
+        if self._provider is None:
+            provider_config = ProviderConfig(
+                provider=ProviderType(self.config.llm.provider),
+                model=self.config.llm.model,
+                api_key=self.config.llm.api_key,
+                base_url=self.config.llm.base_url,
+                temperature=self.config.llm.temperature,
+                max_tokens=self.config.llm.max_tokens,
+                timeout=self.config.llm.timeout,
+            )
+            self._provider = get_provider(provider_config)
+        return self._provider
+
+    @property
+    def llm(self) -> BaseChatModel:
+        """Get the underlying LLM instance for backward compatibility."""
+        return self.provider.llm
+
+    def invoke(self, prompt: str, system_prompt: Optional[str] = None) -> str:
+        """Invoke the LLM with a prompt and optional system message."""
+        return self.provider.invoke(prompt, system_prompt)
+
+    def invoke_with_template(
+        self,
+        template: ChatPromptTemplate,
+        **kwargs,
+    ) -> str:
+        """Invoke the LLM using a prompt template."""
+        chain = template | self.llm
+        response = chain.invoke(kwargs)
+        return str(response.content)
+
+    def stream(self, prompt: str, system_prompt: Optional[str] = None) -> Iterator[str]:
+        """Stream LLM response for real-time output."""
+        return self.provider.stream(prompt, system_prompt)
+
+    def check_connection(self) -> bool:
+        """Check if the LLM provider is accessible."""
+        return self.provider.check_connection()
+
+    def get_model_info(self) -> dict:
+        """Get information about the current model configuration."""
+        return self.provider.get_model_info()
+
+    def validate_config(self) -> tuple[bool, str]:
+        """Validate the current provider configuration."""
+        return self.provider.validate_config()
+
+    @staticmethod
+    def list_providers() -> dict:
+        """List all available providers and their models."""
+        return get_available_providers()
+
+    def switch_provider(
+        self,
+        provider: str,
+        model: Optional[str] = None,
+        api_key: Optional[str] = None,
+    ) -> None:
+        """
+        Switch to a different provider at runtime.
+
+        Args:
+            provider: Provider name (ollama, google, groq, cerebras, openrouter, openai)
+            model: Optional model name (uses provider default if not specified)
+            api_key: Optional API key (uses environment variable if not specified)
+        """
+        provider_type = ProviderType(provider)
+        
+        # Get default model for provider if not specified
+        if model is None:
+            from ai_code_assistant.providers.factory import PROVIDER_REGISTRY
+            provider_class = PROVIDER_REGISTRY.get(provider_type)
+            if provider_class:
+                model = provider_class.default_model
+            else:
+                raise ValueError(f"Unknown provider: {provider}")
+
+        provider_config = ProviderConfig(
+            provider=provider_type,
+            model=model,
+            api_key=api_key,
+            temperature=self.config.llm.temperature,
+            max_tokens=self.config.llm.max_tokens,
+            timeout=self.config.llm.timeout,
+        )
+        self._provider = get_provider(provider_config)

ai_code_assistant/providers/__init__.py

@@ -0,0 +1,23 @@
+"""LLM Provider implementations for Cognify AI."""
+
+from ai_code_assistant.providers.base import BaseProvider, ProviderType
+from ai_code_assistant.providers.ollama import OllamaProvider
+from ai_code_assistant.providers.google import GoogleProvider
+from ai_code_assistant.providers.groq import GroqProvider
+from ai_code_assistant.providers.cerebras import CerebrasProvider
+from ai_code_assistant.providers.openrouter import OpenRouterProvider
+from ai_code_assistant.providers.openai import OpenAIProvider
+from ai_code_assistant.providers.factory import get_provider, get_available_providers
+
+__all__ = [
+    "BaseProvider",
+    "ProviderType",
+    "OllamaProvider",
+    "GoogleProvider",
+    "GroqProvider",
+    "CerebrasProvider",
+    "OpenRouterProvider",
+    "OpenAIProvider",
+    "get_provider",
+    "get_available_providers",
+]

ai_code_assistant/providers/base.py

@@ -0,0 +1,124 @@
+"""Base provider class for LLM integrations."""
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Any, Dict, Iterator, List, Optional
+
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+from pydantic import BaseModel
+
+
+class ProviderType(str, Enum):
+    """Supported LLM provider types."""
+    OLLAMA = "ollama"
+    GOOGLE = "google"
+    GROQ = "groq"
+    CEREBRAS = "cerebras"
+    OPENROUTER = "openrouter"
+    OPENAI = "openai"
+
+
+class ProviderConfig(BaseModel):
+    """Configuration for an LLM provider."""
+    provider: ProviderType = ProviderType.OLLAMA
+    model: str = "deepseek-coder:6.7b"
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+    temperature: float = 0.1
+    max_tokens: int = 4096
+    timeout: int = 120
+
+
+class ModelInfo(BaseModel):
+    """Information about a model."""
+    name: str
+    provider: ProviderType
+    description: str = ""
+    context_window: int = 4096
+    is_free: bool = True
+
+
+class BaseProvider(ABC):
+    """Abstract base class for LLM providers."""
+
+    # Provider metadata
+    provider_type: ProviderType
+    display_name: str
+    requires_api_key: bool = True
+    default_model: str
+    free_tier: bool = True
+
+    # Available models for this provider
+    available_models: List[ModelInfo] = []
+
+    def __init__(self, config: ProviderConfig):
+        """Initialize the provider with configuration."""
+        self.config = config
+        self._llm: Optional[BaseChatModel] = None
+
+    @property
+    def llm(self) -> BaseChatModel:
+        """Get or create the LLM instance."""
+        if self._llm is None:
+            self._llm = self._create_llm()
+        return self._llm
+
+    @abstractmethod
+    def _create_llm(self) -> BaseChatModel:
+        """Create the LangChain LLM instance. Must be implemented by subclasses."""
+        pass
+
+    @abstractmethod
+    def validate_config(self) -> tuple[bool, str]:
+        """Validate the provider configuration. Returns (is_valid, error_message)."""
+        pass
+
+    def invoke(self, prompt: str, system_prompt: Optional[str] = None) -> str:
+        """Invoke the LLM with a prompt and optional system message."""
+        messages: List[BaseMessage] = []
+        if system_prompt:
+            messages.append(SystemMessage(content=system_prompt))
+        messages.append(HumanMessage(content=prompt))
+
+        response = self.llm.invoke(messages)
+        return str(response.content)
+
+    def stream(self, prompt: str, system_prompt: Optional[str] = None) -> Iterator[str]:
+        """Stream LLM response for real-time output."""
+        messages: List[BaseMessage] = []
+        if system_prompt:
+            messages.append(SystemMessage(content=system_prompt))
+        messages.append(HumanMessage(content=prompt))
+
+        for chunk in self.llm.stream(messages):
+            yield str(chunk.content)
+
+    def check_connection(self) -> bool:
+        """Check if the provider is accessible."""
+        try:
+            self.invoke("Say 'ok' and nothing else.")
+            return True
+        except Exception:
+            return False
+
+    def get_model_info(self) -> Dict[str, Any]:
+        """Get information about the current model configuration."""
+        return {
+            "provider": self.provider_type.value,
+            "model": self.config.model,
+            "temperature": self.config.temperature,
+            "max_tokens": self.config.max_tokens,
+            "base_url": self.config.base_url,
+            "free_tier": self.free_tier,
+        }
+
+    @classmethod
+    def get_available_models(cls) -> List[ModelInfo]:
+        """Get list of available models for this provider."""
+        return cls.available_models
+
+    @classmethod
+    def get_setup_instructions(cls) -> str:
+        """Get setup instructions for this provider."""
+        return f"Configure {cls.display_name} in your config.yaml or set environment variables."

ai_code_assistant/providers/cerebras.py

@@ -0,0 +1,97 @@
+"""Cerebras provider for fast LLM inference."""
+
+import os
+from langchain_core.language_models import BaseChatModel
+
+from ai_code_assistant.providers.base import (
+    BaseProvider,
+    ModelInfo,
+    ProviderConfig,
+    ProviderType,
+)
+
+
+class CerebrasProvider(BaseProvider):
+    """Provider for Cerebras - fast inference with large models."""
+
+    provider_type = ProviderType.CEREBRAS
+    display_name = "Cerebras (Fast Inference)"
+    requires_api_key = True
+    default_model = "llama3.1-8b"
+    free_tier = True
+
+    available_models = [
+        ModelInfo(
+            name="llama3.1-8b",
+            provider=ProviderType.CEREBRAS,
+            description="Llama 3.1 8B - Fast and efficient",
+            context_window=8192,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="llama3.1-70b",
+            provider=ProviderType.CEREBRAS,
+            description="Llama 3.1 70B - More capable",
+            context_window=8192,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="llama-3.3-70b",
+            provider=ProviderType.CEREBRAS,
+            description="Llama 3.3 70B - Latest Llama model",
+            context_window=8192,
+            is_free=True,
+        ),
+    ]
+
+    def _create_llm(self) -> BaseChatModel:
+        """Create Cerebras LLM instance using OpenAI-compatible API."""
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError:
+            raise ImportError(
+                "langchain-openai is required for Cerebras provider. "
+                "Install with: pip install langchain-openai"
+            )
+
+        api_key = self.config.api_key or os.getenv("CEREBRAS_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "Cerebras API key is required. Set CEREBRAS_API_KEY environment variable "
+                "or provide api_key in config. Get your key at: https://cloud.cerebras.ai/"
+            )
+
+        return ChatOpenAI(
+            model=self.config.model,
+            api_key=api_key,
+            base_url="https://api.cerebras.ai/v1",
+            temperature=self.config.temperature,
+            max_tokens=self.config.max_tokens,
+            timeout=self.config.timeout,
+        )
+
+    def validate_config(self) -> tuple[bool, str]:
+        """Validate Cerebras configuration."""
+        api_key = self.config.api_key or os.getenv("CEREBRAS_API_KEY")
+        if not api_key:
+            return False, "CEREBRAS_API_KEY environment variable or api_key config is required"
+        if not self.config.model:
+            return False, "Model name is required"
+        return True, ""
+
+    @classmethod
+    def get_setup_instructions(cls) -> str:
+        """Get Cerebras setup instructions."""
+        return """
+Cerebras Setup Instructions:
+1. Go to https://cloud.cerebras.ai/
+2. Create a free account and generate an API key
+3. Set environment variable: export CEREBRAS_API_KEY="your-key"
+4. Or add to config.yaml:
+   llm:
+     provider: cerebras
+     api_key: "your-key"
+     model: llama3.1-8b
+
+Free tier: 14,400 requests/day, very fast inference
+"""