ai-coding-assistant 0.5.0__py3-none-any.whl

coding_assistant/llm/prompts.py

@@ -0,0 +1,98 @@
+"""Prompt templates for the LLM."""
+from typing import List, Dict
+
+
+class PromptBuilder:
+    """Build prompts for different tasks."""
+
+    @staticmethod
+    def build_system_prompt() -> str:
+        """Build the system prompt for the assistant with FAANG/MAANG senior engineer capabilities."""
+        return """You are an expert AI coding assistant with the capabilities of a FAANG/MAANG Senior Software Engineer (L5/E5/SDE III level).
+
+Your Core Capabilities:
+
+**Architecture & System Design:**
+- Design scalable, performant, and reliable software architectures
+- Make informed trade-offs between different architectural approaches
+- Address scalability, performance, security, and maintainability concerns
+- Design distributed systems and microservices
+- Handle real-world architectural challenges (caching, load balancing, data consistency)
+
+**Code Quality & Best Practices:**
+- Write clean, maintainable, production-quality code
+- Apply SOLID principles and design patterns appropriately
+- Optimize code for performance and efficiency
+- Ensure code follows industry best practices and standards
+- Implement comprehensive error handling and logging
+
+**Code Review & Mentorship:**
+- Conduct thorough code reviews with constructive feedback
+- Identify bugs, security vulnerabilities, and performance issues
+- Suggest improvements and refactoring opportunities
+- Explain complex concepts clearly for knowledge sharing
+- Guide junior developers toward better solutions
+
+**Problem Solving & Algorithms:**
+- Optimize solutions using data structures and algorithms
+- Analyze time and space complexity
+- Solve complex technical challenges systematically
+- Debug issues efficiently using structured approaches
+
+**Technical Expertise:**
+- Deep knowledge of software development tools and processes
+- Experience with modern tech stacks and frameworks
+- Understanding of CI/CD, testing, and deployment pipelines
+- Knowledge of cloud platforms and containerization
+- Familiarity with databases, caching, and message queues
+
+**Communication & Collaboration:**
+- Explain technical decisions and trade-offs clearly
+- Document code and architectural decisions
+- Cite specific files and line numbers when referencing code
+- Provide actionable, step-by-step guidance
+- Ask clarifying questions when requirements are ambiguous
+
+Guidelines:
+- Use the provided codebase context to give accurate, context-aware answers
+- Suggest production-ready solutions, not just quick hacks
+- Consider long-term maintainability and team productivity
+- Point out potential issues before they become problems
+- If uncertain, acknowledge limitations rather than guessing
+- Provide code examples following the project's existing patterns
+- Think like a senior engineer: balance perfectionism with pragmatism"""
+
+    @staticmethod
+    def build_ask_prompt(question: str, file_contents: List[Dict[str, str]]) -> List[Dict[str, str]]:
+        """Build a prompt for the 'ask' command."""
+
+        system_prompt = """You are an expert coding assistant with access to the user's codebase.
+
+Your capabilities:
+- Explain code functionality
+- Answer questions about the codebase
+- Provide insights about code structure and patterns
+
+Guidelines:
+- Use the provided code context to give accurate answers
+- Cite specific files when referencing code
+- If you're not sure, say so rather than guessing
+"""
+
+        # Build context section
+        context = "# Codebase Context:\n\n"
+        if file_contents:
+            for file_info in file_contents:
+                context += f"## File: {file_info['path']}\n"
+                context += f"```{file_info.get('language', 'text')}\n"
+                context += f"{file_info['content']}\n```\n\n"
+        else:
+            context += "No files found in the current directory.\n\n"
+
+        # User question
+        user_message = f"{context}\n# User Question:\n{question}"
+
+        return [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_message}
+        ]

coding_assistant/llm/together_client.py

@@ -0,0 +1,160 @@
+"""Together AI LLM client implementation."""
+
+from typing import List, Dict, Iterator, Optional
+import requests
+import json
+from coding_assistant.llm.client import BaseLLMClient
+from coding_assistant.exceptions.llm import (
+    LLMConnectionError,
+    LLMResponseError,
+    LLMTimeoutError
+)
+
+
+class TogetherClient(BaseLLMClient):
+    """Together AI cloud LLM client (OpenAI-compatible API)."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "Qwen/Qwen2.5-Coder-32B-Instruct",
+        base_url: str = "https://api.together.xyz/v1"
+    ):
+        """
+        Initialize Together AI client.
+
+        Args:
+            api_key: Together AI API key
+            model: Model name (default: Qwen/Qwen2.5-Coder-32B-Instruct)
+            base_url: API base URL
+        """
+        self.api_key = api_key
+        self.model = model
+        self.base_url = base_url
+
+    def generate(self, messages: List[Dict[str, str]], stream: bool = True) -> Iterator[str]:
+        """
+        Generate response from Together AI.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            stream: Whether to stream the response
+
+        Yields:
+            Response chunks
+        """
+        if not self.api_key:
+            raise LLMConnectionError(
+                provider="together",
+                endpoint=self.base_url,
+                reason="API key not set"
+            )
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "stream": stream
+        }
+
+        try:
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=headers,
+                json=payload,
+                stream=stream,
+                timeout=120
+            )
+
+            # Check for errors
+            if response.status_code == 401 or response.status_code == 403:
+                raise LLMResponseError(
+                    message="Authentication failed. Check your API key.",
+                    provider="together",
+                    status_code=response.status_code,
+                    response_text=response.text
+                )
+            elif response.status_code == 429:
+                raise LLMResponseError(
+                    message="Rate limit exceeded. Please wait and try again.",
+                    provider="together",
+                    status_code=429,
+                    response_text=response.text
+                )
+            elif response.status_code >= 400:
+                raise LLMResponseError(
+                    message=f"API error: {response.status_code}",
+                    provider="together",
+                    status_code=response.status_code,
+                    response_text=response.text
+                )
+
+            if stream:
+                # Parse Server-Sent Events (SSE)
+                for line in response.iter_lines():
+                    if line:
+                        line_str = line.decode('utf-8')
+                        # SSE format: "data: {json}"
+                        if line_str.startswith('data: '):
+                            data_str = line_str[6:]  # Remove "data: " prefix
+
+                            # Check for end of stream
+                            if data_str.strip() == '[DONE]':
+                                break
+
+                            try:
+                                chunk = json.loads(data_str)
+                                # Extract content from delta
+                                if 'choices' in chunk and len(chunk['choices']) > 0:
+                                    delta = chunk['choices'][0].get('delta', {})
+                                    content = delta.get('content', '')
+                                    if content:
+                                        yield content
+                            except json.JSONDecodeError:
+                                continue
+            else:
+                # Non-streaming response
+                result = response.json()
+                if 'choices' in result and len(result['choices']) > 0:
+                    content = result['choices'][0]['message']['content']
+                    yield content
+
+        except requests.exceptions.Timeout:
+            raise LLMTimeoutError(
+                provider="together",
+                timeout_seconds=120
+            )
+        except requests.exceptions.ConnectionError as e:
+            raise LLMConnectionError(
+                provider="together",
+                endpoint=self.base_url,
+                reason=str(e)
+            )
+        except (LLMConnectionError, LLMResponseError, LLMTimeoutError):
+            # Re-raise our custom exceptions
+            raise
+        except Exception as e:
+            raise LLMConnectionError(
+                provider="together",
+                endpoint=self.base_url,
+                reason=f"Unexpected error: {str(e)}"
+            )
+
+    def is_available(self) -> bool:
+        """
+        Check if Together AI is available.
+
+        Returns:
+            True if API key is set
+        """
+        # Basic check: API key is set
+        if not self.api_key:
+            return False
+
+        # Could optionally validate with API call here
+        # but keeping it simple for now to avoid unnecessary API calls
+        return True

coding_assistant/operations/__init__.py

@@ -0,0 +1,13 @@
+"""Code operations module for generation, validation, and modification."""
+
+from coding_assistant.operations.generator import CodeGenerator
+from coding_assistant.operations.validator import SyntaxValidator
+from coding_assistant.operations.differ import DiffGenerator
+from coding_assistant.operations.linter import LinterIntegration
+
+__all__ = [
+    'CodeGenerator',
+    'SyntaxValidator',
+    'DiffGenerator',
+    'LinterIntegration',
+]

coding_assistant/operations/differ.py

@@ -0,0 +1,369 @@
+"""Generate and display code diffs."""
+
+import difflib
+from typing import List, Optional, Tuple
+from pathlib import Path
+from rich.console import Console
+from rich.syntax import Syntax
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+
+class DiffGenerator:
+    """Generate and display code differences."""
+
+    def __init__(self):
+        """Initialize the diff generator."""
+        self.console = Console()
+
+    def generate_diff(self, original: str, modified: str,
+                     filepath: Optional[str] = None,
+                     context_lines: int = 3) -> str:
+        """
+        Generate a unified diff between two code versions.
+
+        Args:
+            original: The original code
+            modified: The modified code
+            filepath: Optional file path for diff headers
+            context_lines: Number of context lines to include
+
+        Returns:
+            Unified diff as a string
+        """
+        original_lines = original.splitlines(keepends=True)
+        modified_lines = modified.splitlines(keepends=True)
+
+        filename = filepath or 'file'
+
+        diff = difflib.unified_diff(
+            original_lines,
+            modified_lines,
+            fromfile=f"a/{filename}",
+            tofile=f"b/{filename}",
+            lineterm='',
+            n=context_lines
+        )
+
+        return ''.join(diff)
+
+    def generate_side_by_side_diff(self, original: str, modified: str) -> List[Tuple[str, str, str]]:
+        """
+        Generate a side-by-side diff.
+
+        Args:
+            original: The original code
+            modified: The modified code
+
+        Returns:
+            List of (status, original_line, modified_line) tuples
+            status can be: 'unchanged', 'modified', 'added', 'removed'
+        """
+        original_lines = original.splitlines()
+        modified_lines = modified.splitlines()
+
+        matcher = difflib.SequenceMatcher(None, original_lines, modified_lines)
+        result = []
+
+        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+            if tag == 'equal':
+                for i in range(i1, i2):
+                    result.append(('unchanged', original_lines[i], modified_lines[j1 + (i - i1)]))
+            elif tag == 'replace':
+                # Lines were modified
+                for i in range(i1, i2):
+                    old_line = original_lines[i] if i < len(original_lines) else ''
+                    new_line = modified_lines[j1 + (i - i1)] if (j1 + (i - i1)) < len(modified_lines) else ''
+                    result.append(('modified', old_line, new_line))
+            elif tag == 'delete':
+                for i in range(i1, i2):
+                    result.append(('removed', original_lines[i], ''))
+            elif tag == 'insert':
+                for j in range(j1, j2):
+                    result.append(('added', '', modified_lines[j]))
+
+        return result
+
+    def display_diff(self, diff_text: str, language: str = 'diff',
+                    title: Optional[str] = None):
+        """
+        Display a unified diff in the terminal with syntax highlighting.
+
+        Args:
+            diff_text: The unified diff text
+            language: Language for syntax highlighting (default: diff)
+            title: Optional title for the diff panel
+        """
+        if not diff_text.strip():
+            self.console.print("[yellow]No changes detected[/yellow]")
+            return
+
+        syntax = Syntax(
+            diff_text,
+            'diff',
+            theme='monokai',
+            line_numbers=False,
+            word_wrap=False
+        )
+
+        if title:
+            self.console.print(Panel(syntax, title=title, border_style="blue"))
+        else:
+            self.console.print(syntax)
+
+    def display_side_by_side(self, original: str, modified: str,
+                            title: Optional[str] = None,
+                            language: str = 'python'):
+        """
+        Display a side-by-side diff with color coding.
+
+        Args:
+            original: The original code
+            modified: The modified code
+            title: Optional title
+            language: Programming language for context
+        """
+        diff_lines = self.generate_side_by_side_diff(original, modified)
+
+        table = Table(
+            title=title,
+            show_header=True,
+            header_style="bold magenta",
+            border_style="blue",
+            show_lines=True
+        )
+
+        table.add_column("", width=3)  # Status indicator
+        table.add_column("Line", width=5)
+        table.add_column("Original", style="dim")
+        table.add_column("Modified", style="dim")
+
+        line_num = 1
+        for status, old_line, new_line in diff_lines:
+            if status == 'unchanged':
+                icon = " "
+                style = "dim"
+            elif status == 'modified':
+                icon = "~"
+                style = "yellow"
+            elif status == 'added':
+                icon = "+"
+                style = "green"
+            elif status == 'removed':
+                icon = "-"
+                style = "red"
+
+            table.add_row(
+                f"[{style}]{icon}[/{style}]",
+                str(line_num),
+                old_line[:80],  # Truncate long lines
+                new_line[:80],
+                style=style
+            )
+            line_num += 1
+
+        self.console.print(table)
+
+    def display_summary(self, diff_text: str):
+        """
+        Display a summary of changes.
+
+        Args:
+            diff_text: The unified diff text
+        """
+        lines = diff_text.split('\n')
+
+        added = sum(1 for line in lines if line.startswith('+') and not line.startswith('+++'))
+        removed = sum(1 for line in lines if line.startswith('-') and not line.startswith('---'))
+        modified = min(added, removed)
+        net_added = added - modified
+        net_removed = removed - modified
+
+        summary = Text()
+        summary.append("Changes: ", style="bold")
+
+        if modified > 0:
+            summary.append(f"{modified} modified ", style="yellow")
+        if net_added > 0:
+            summary.append(f"{net_added} added ", style="green")
+        if net_removed > 0:
+            summary.append(f"{net_removed} removed ", style="red")
+
+        if not any([modified, net_added, net_removed]):
+            summary.append("No changes", style="dim")
+
+        self.console.print(summary)
+
+    def generate_patch(self, original: str, modified: str,
+                      filepath: str) -> str:
+        """
+        Generate a patch file that can be applied with `patch` command.
+
+        Args:
+            original: The original code
+            modified: The modified code
+            filepath: The file path for the patch
+
+        Returns:
+            Patch content as string
+        """
+        return self.generate_diff(original, modified, filepath, context_lines=3)
+
+    def apply_patch(self, original: str, patch: str) -> Optional[str]:
+        """
+        Apply a patch to original content.
+
+        Args:
+            original: The original code
+            patch: The unified diff patch
+
+        Returns:
+            Modified content if successful, None otherwise
+        """
+        try:
+            original_lines = original.splitlines(keepends=True)
+            patch_lines = patch.splitlines(keepends=True)
+
+            # Use difflib to apply patch
+            # This is a simple implementation
+            # For production, consider using a proper patch library
+
+            result_lines = original_lines.copy()
+
+            # Parse patch and apply
+            # This is simplified - full patch parsing is complex
+            # For now, just return None to indicate manual application needed
+
+            return None  # TODO: Implement proper patch application
+
+        except Exception:
+            return None
+
+    def compare_files(self, file1_path: str, file2_path: str,
+                     display: bool = True) -> str:
+        """
+        Compare two files and generate a diff.
+
+        Args:
+            file1_path: Path to first file
+            file2_path: Path to second file
+            display: Whether to display the diff
+
+        Returns:
+            Unified diff as string
+        """
+        path1 = Path(file1_path)
+        path2 = Path(file2_path)
+
+        if not path1.exists():
+            raise FileNotFoundError(f"File not found: {file1_path}")
+        if not path2.exists():
+            raise FileNotFoundError(f"File not found: {file2_path}")
+
+        content1 = path1.read_text(encoding='utf-8')
+        content2 = path2.read_text(encoding='utf-8')
+
+        diff = self.generate_diff(content1, content2, file1_path)
+
+        if display:
+            self.display_diff(diff, title=f"{file1_path} vs {file2_path}")
+
+        return diff
+
+    def get_change_stats(self, diff_text: str) -> dict:
+        """
+        Get statistics about changes in a diff.
+
+        Args:
+            diff_text: The unified diff text
+
+        Returns:
+            Dict with stats: lines_added, lines_removed, files_changed, etc.
+        """
+        lines = diff_text.split('\n')
+
+        stats = {
+            'lines_added': 0,
+            'lines_removed': 0,
+            'lines_modified': 0,
+            'files_changed': 0,
+            'hunks': 0
+        }
+
+        for line in lines:
+            if line.startswith('+++'):
+                stats['files_changed'] += 1
+            elif line.startswith('@@'):
+                stats['hunks'] += 1
+            elif line.startswith('+') and not line.startswith('+++'):
+                stats['lines_added'] += 1
+            elif line.startswith('-') and not line.startswith('---'):
+                stats['lines_removed'] += 1
+
+        stats['lines_modified'] = min(stats['lines_added'], stats['lines_removed'])
+        stats['net_change'] = stats['lines_added'] - stats['lines_removed']
+
+        return stats
+
+    def highlight_changes(self, original: str, modified: str,
+                         language: str = 'python') -> Tuple[str, str]:
+        """
+        Highlight specific character-level changes between lines.
+
+        Args:
+            original: Original code line
+            modified: Modified code line
+            language: Programming language
+
+        Returns:
+            Tuple of (highlighted_original, highlighted_modified)
+        """
+        # Use SequenceMatcher for character-level diff
+        matcher = difflib.SequenceMatcher(None, original, modified)
+
+        orig_highlighted = []
+        mod_highlighted = []
+
+        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+            if tag == 'equal':
+                orig_highlighted.append(original[i1:i2])
+                mod_highlighted.append(modified[j1:j2])
+            elif tag == 'replace':
+                orig_highlighted.append(f"[red]{original[i1:i2]}[/red]")
+                mod_highlighted.append(f"[green]{modified[j1:j2]}[/green]")
+            elif tag == 'delete':
+                orig_highlighted.append(f"[red]{original[i1:i2]}[/red]")
+            elif tag == 'insert':
+                mod_highlighted.append(f"[green]{modified[j1:j2]}[/green]")
+
+        return ''.join(orig_highlighted), ''.join(mod_highlighted)
+
+    def format_diff_for_display(self, diff_text: str) -> str:
+        """
+        Format diff text for better terminal display.
+
+        Args:
+            diff_text: Raw unified diff
+
+        Returns:
+            Formatted diff with colors
+        """
+        lines = diff_text.split('\n')
+        formatted = []
+
+        for line in lines:
+            if line.startswith('+++'):
+                formatted.append(f"[blue]{line}[/blue]")
+            elif line.startswith('---'):
+                formatted.append(f"[blue]{line}[/blue]")
+            elif line.startswith('@@'):
+                formatted.append(f"[cyan]{line}[/cyan]")
+            elif line.startswith('+'):
+                formatted.append(f"[green]{line}[/green]")
+            elif line.startswith('-'):
+                formatted.append(f"[red]{line}[/red]")
+            else:
+                formatted.append(line)
+
+        return '\n'.join(formatted)