cognify-code 0.2.0__py3-none-any.whl

ai_code_assistant/reviewer/analyzer.py

@@ -0,0 +1,278 @@
+"""Code analyzer for reviewing code files."""
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from ai_code_assistant.config import Config, get_language_by_extension
+from ai_code_assistant.llm import LLMManager
+from ai_code_assistant.reviewer.prompts import REVIEW_PROMPTS
+
+
+# Retry prompt for when JSON parsing fails
+RETRY_JSON_PROMPT = """Your previous response was not valid JSON. Please provide ONLY valid JSON output.
+
+Here is the code to review again:
+```{language}
+{code}
+```
+
+Return ONLY a JSON object with this structure:
+{{
+  "summary": "Brief summary",
+  "issues": [
+    {{
+      "line_start": 1,
+      "line_end": 1,
+      "category": "bugs|security|performance|style|best_practices",
+      "severity": "critical|warning|suggestion",
+      "title": "Short title",
+      "description": "What's wrong",
+      "suggestion": "How to fix it",
+      "confidence": 0.8
+    }}
+  ],
+  "overall_quality": "good|acceptable|needs_improvement|poor"
+}}
+
+Return ONLY the JSON, no other text."""
+
+
+@dataclass
+class ReviewIssue:
+    """Represents a single code review issue."""
+    line_start: int
+    line_end: int
+    category: str
+    severity: str
+    title: str
+    description: str
+    suggestion: str
+    code_snippet: str = ""
+    fixed_code: str = ""
+    confidence: float = 0.0
+
+
+@dataclass
+class ReviewResult:
+    """Complete review result for a file."""
+    filename: str
+    language: str
+    summary: str
+    issues: List[ReviewIssue] = field(default_factory=list)
+    metrics: Dict = field(default_factory=dict)
+    overall_quality: str = "unknown"
+    raw_response: str = ""
+    error: Optional[str] = None
+
+    @property
+    def critical_issues(self) -> List[ReviewIssue]:
+        return [i for i in self.issues if i.severity == "critical"]
+
+    @property
+    def warnings(self) -> List[ReviewIssue]:
+        return [i for i in self.issues if i.severity == "warning"]
+
+    @property
+    def suggestions(self) -> List[ReviewIssue]:
+        return [i for i in self.issues if i.severity == "suggestion"]
+
+
+class CodeAnalyzer:
+    """Analyzes code files for issues and improvements."""
+
+    def __init__(self, config: Config, llm_manager: LLMManager):
+        self.config = config
+        self.llm = llm_manager
+
+    def review_file(
+        self,
+        file_path: Path,
+        review_type: str = "full",
+        categories: Optional[List[str]] = None,
+    ) -> ReviewResult:
+        """Review a single code file."""
+        if not file_path.exists():
+            return ReviewResult(
+                filename=str(file_path),
+                language="unknown",
+                summary="",
+                error=f"File not found: {file_path}"
+            )
+
+        # Check file size
+        file_size_kb = file_path.stat().st_size / 1024
+        if file_size_kb > self.config.review.max_file_size_kb:
+            return ReviewResult(
+                filename=str(file_path),
+                language="unknown",
+                summary="",
+                error=f"File too large: {file_size_kb:.1f}KB (max: {self.config.review.max_file_size_kb}KB)"
+            )
+
+        # Detect language
+        language = get_language_by_extension(self.config, file_path)
+        if not language:
+            language = "unknown"
+
+        # Read code
+        code = file_path.read_text()
+        
+        # Use configured categories if not specified
+        if categories is None:
+            categories = self.config.review.categories
+
+        return self._analyze_code(
+            code=code,
+            filename=str(file_path),
+            language=language,
+            review_type=review_type,
+            categories=categories,
+        )
+
+    def review_code(
+        self,
+        code: str,
+        language: str = "python",
+        filename: str = "code_snippet",
+        review_type: str = "full",
+        categories: Optional[List[str]] = None,
+    ) -> ReviewResult:
+        """Review a code string directly."""
+        if categories is None:
+            categories = self.config.review.categories
+
+        return self._analyze_code(
+            code=code,
+            filename=filename,
+            language=language,
+            review_type=review_type,
+            categories=categories,
+        )
+
+    def _analyze_code(
+        self,
+        code: str,
+        filename: str,
+        language: str,
+        review_type: str,
+        categories: List[str],
+        max_retries: int = 2,
+    ) -> ReviewResult:
+        """Internal method to analyze code using LLM with retry logic."""
+        prompt_template = REVIEW_PROMPTS.get(review_type, REVIEW_PROMPTS["full"])
+
+        try:
+            response = self.llm.invoke_with_template(
+                prompt_template,
+                code=code,
+                language=language,
+                filename=filename,
+                categories=", ".join(categories),
+            )
+            result = self._parse_review_response(response, filename, language)
+
+            # Retry if parsing failed
+            retries = 0
+            while result.error and "Parse error" in result.error and retries < max_retries:
+                retries += 1
+                retry_prompt = RETRY_JSON_PROMPT.format(language=language, code=code)
+                response = self.llm.invoke(retry_prompt)
+                result = self._parse_review_response(response, filename, language)
+
+            return result
+        except Exception as e:
+            return ReviewResult(
+                filename=filename,
+                language=language,
+                summary="",
+                error=f"Analysis failed: {str(e)}",
+                raw_response=""
+            )
+
+    def _extract_json(self, response: str) -> str:
+        """Extract JSON from LLM response, handling various formats."""
+        # Try to find JSON in code blocks
+        if "```json" in response:
+            match = re.search(r'```json\s*(.*?)\s*```', response, re.DOTALL)
+            if match:
+                return match.group(1)
+
+        if "```" in response:
+            match = re.search(r'```\s*(.*?)\s*```', response, re.DOTALL)
+            if match:
+                return match.group(1)
+
+        # Try to find JSON object directly
+        match = re.search(r'\{.*\}', response, re.DOTALL)
+        if match:
+            return match.group(0)
+
+        return response
+
+    def _repair_json(self, json_str: str) -> str:
+        """Attempt to repair common JSON issues."""
+        # Remove trailing commas before } or ]
+        json_str = re.sub(r',\s*([}\]])', r'\1', json_str)
+
+        # Fix unquoted keys (simple cases)
+        json_str = re.sub(r'(\{|\,)\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:', r'\1"\2":', json_str)
+
+        # Fix single quotes to double quotes
+        json_str = json_str.replace("'", '"')
+
+        # Remove comments
+        json_str = re.sub(r'//.*$', '', json_str, flags=re.MULTILINE)
+
+        return json_str
+
+    def _parse_review_response(
+        self, response: str, filename: str, language: str
+    ) -> ReviewResult:
+        """Parse LLM response into ReviewResult."""
+        try:
+            json_str = self._extract_json(response)
+
+            try:
+                data = json.loads(json_str.strip())
+            except json.JSONDecodeError:
+                # Try to repair JSON
+                repaired = self._repair_json(json_str)
+                data = json.loads(repaired.strip())
+
+            issues = [
+                ReviewIssue(
+                    line_start=i.get("line_start", i.get("line", 0)),
+                    line_end=i.get("line_end", i.get("line", 0)),
+                    category=i.get("category", "unknown"),
+                    severity=i.get("severity", "suggestion"),
+                    title=i.get("title", "Issue"),
+                    description=i.get("description", ""),
+                    suggestion=i.get("suggestion", i.get("fix", "")),
+                    code_snippet=i.get("code_snippet", ""),
+                    fixed_code=i.get("fixed_code", ""),
+                    confidence=float(i.get("confidence", 0.5)),
+                )
+                for i in data.get("issues", data.get("critical_issues", []))
+            ]
+
+            return ReviewResult(
+                filename=filename,
+                language=language,
+                summary=data.get("summary", "Review complete"),
+                issues=issues,
+                metrics=data.get("metrics", {}),
+                overall_quality=data.get("overall_quality", "unknown"),
+                raw_response=response,
+            )
+        except (json.JSONDecodeError, KeyError) as e:
+            return ReviewResult(
+                filename=filename,
+                language=language,
+                summary="Failed to parse review response",
+                raw_response=response,
+                error=f"Parse error: {str(e)}"
+            )
+

ai_code_assistant/reviewer/prompts.py

@@ -0,0 +1,113 @@
+"""Prompt templates for code review."""
+
+from langchain_core.prompts import ChatPromptTemplate
+
+# System prompt for code review
+REVIEW_SYSTEM_PROMPT = """You are an expert code reviewer with deep knowledge of software engineering best practices, security vulnerabilities, and performance optimization.
+
+Your task is to analyze code and provide detailed, actionable feedback. For each issue found:
+1. Identify the specific line number(s)
+2. Categorize the issue (bugs, security, performance, style, best_practices)
+3. Assign a severity level (critical, warning, suggestion)
+4. Explain the problem clearly
+5. Provide a specific fix or improvement
+6. Give a confidence score (0.0-1.0)
+
+Be thorough but practical. Focus on real issues, not pedantic nitpicks.
+Format your response as structured JSON."""
+
+# Main review prompt template
+REVIEW_PROMPT = ChatPromptTemplate.from_messages([
+    ("system", REVIEW_SYSTEM_PROMPT),
+    ("human", """Review the following {language} code:
+
+```{language}
+{code}
+```
+
+File: {filename}
+
+Analyze for the following categories: {categories}
+
+Respond with a JSON object in this exact format:
+{{
+    "summary": "Brief overall assessment",
+    "issues": [
+        {{
+            "line_start": 10,
+            "line_end": 12,
+            "category": "security",
+            "severity": "critical",
+            "title": "SQL Injection Vulnerability",
+            "description": "User input is directly concatenated into SQL query",
+            "suggestion": "Use parameterized queries instead",
+            "code_snippet": "the problematic code",
+            "fixed_code": "the corrected code",
+            "confidence": 0.95
+        }}
+    ],
+    "metrics": {{
+        "total_lines": 100,
+        "issues_count": 5,
+        "critical_count": 1,
+        "warning_count": 2,
+        "suggestion_count": 2
+    }},
+    "overall_quality": "good|acceptable|needs_improvement|poor"
+}}""")
+])
+
+# Quick review prompt (faster, less detailed)
+QUICK_REVIEW_PROMPT = ChatPromptTemplate.from_messages([
+    ("system", "You are a code reviewer. Provide a brief review focusing on critical issues only."),
+    ("human", """Quickly review this {language} code for critical bugs and security issues:
+
+```{language}
+{code}
+```
+
+List only critical issues in this JSON format:
+{{
+    "critical_issues": [
+        {{"line": 10, "issue": "description", "fix": "suggested fix"}}
+    ],
+    "safe_to_use": true/false
+}}""")
+])
+
+# Security-focused review prompt
+SECURITY_REVIEW_PROMPT = ChatPromptTemplate.from_messages([
+    ("system", """You are a security expert reviewing code for vulnerabilities.
+Focus on: SQL injection, XSS, CSRF, authentication issues, sensitive data exposure,
+insecure dependencies, improper error handling, and other OWASP Top 10 risks."""),
+    ("human", """Perform a security audit on this {language} code:
+
+```{language}
+{code}
+```
+
+Return JSON with security findings:
+{{
+    "vulnerabilities": [
+        {{
+            "line": 10,
+            "cwe_id": "CWE-89",
+            "severity": "critical|high|medium|low",
+            "title": "SQL Injection",
+            "description": "detailed description",
+            "remediation": "how to fix",
+            "confidence": 0.9
+        }}
+    ],
+    "security_score": 0-100,
+    "recommendations": ["list of general security improvements"]
+}}""")
+])
+
+# Collect all prompts
+REVIEW_PROMPTS = {
+    "full": REVIEW_PROMPT,
+    "quick": QUICK_REVIEW_PROMPT,
+    "security": SECURITY_REVIEW_PROMPT,
+}
+

ai_code_assistant/utils/__init__.py

@@ -0,0 +1,18 @@
+"""Utilities module for AI Code Assistant."""
+
+from ai_code_assistant.utils.file_handler import FileHandler
+from ai_code_assistant.utils.formatters import (
+    ConsoleFormatter,
+    MarkdownFormatter,
+    JsonFormatter,
+    get_formatter,
+)
+
+__all__ = [
+    "FileHandler",
+    "ConsoleFormatter",
+    "MarkdownFormatter",
+    "JsonFormatter",
+    "get_formatter",
+]
+

ai_code_assistant/utils/file_handler.py

@@ -0,0 +1,155 @@
+"""File handling utilities for AI Code Assistant."""
+
+import fnmatch
+from pathlib import Path
+from typing import Dict, Iterator, List, Optional, Tuple
+
+from ai_code_assistant.config import Config, get_language_by_extension
+
+
+class FileHandler:
+    """Handles file system operations for code files."""
+
+    # Common patterns to ignore
+    DEFAULT_IGNORE_PATTERNS = [
+        "*.pyc", "__pycache__", ".git", ".venv", "venv",
+        "node_modules", ".idea", ".vscode", "*.egg-info",
+        "dist", "build", ".pytest_cache", ".mypy_cache",
+        "*.min.js", "*.min.css", "*.map", ".env",
+    ]
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.ignore_patterns = self.DEFAULT_IGNORE_PATTERNS.copy()
+
+    def add_ignore_pattern(self, pattern: str) -> None:
+        """Add a pattern to ignore list."""
+        self.ignore_patterns.append(pattern)
+
+    def is_supported_file(self, file_path: Path) -> bool:
+        """Check if file is a supported code file."""
+        return get_language_by_extension(self.config, file_path) is not None
+
+    def should_ignore(self, path: Path) -> bool:
+        """Check if path should be ignored."""
+        path_str = str(path)
+        name = path.name
+        
+        for pattern in self.ignore_patterns:
+            if fnmatch.fnmatch(name, pattern) or fnmatch.fnmatch(path_str, f"*/{pattern}/*"):
+                return True
+        return False
+
+    def find_code_files(
+        self,
+        directory: Path,
+        recursive: bool = True,
+        extensions: Optional[List[str]] = None,
+    ) -> Iterator[Path]:
+        """Find all code files in a directory."""
+        if not directory.is_dir():
+            return
+
+        pattern = "**/*" if recursive else "*"
+        
+        for file_path in directory.glob(pattern):
+            if not file_path.is_file():
+                continue
+            
+            if self.should_ignore(file_path):
+                continue
+            
+            if extensions:
+                if file_path.suffix.lower() not in extensions:
+                    continue
+            elif not self.is_supported_file(file_path):
+                continue
+            
+            yield file_path
+
+    def read_file(self, file_path: Path) -> Tuple[str, Optional[str]]:
+        """Read file content. Returns (content, error)."""
+        try:
+            if not file_path.exists():
+                return "", f"File not found: {file_path}"
+            
+            if not file_path.is_file():
+                return "", f"Not a file: {file_path}"
+            
+            # Check file size
+            file_size_kb = file_path.stat().st_size / 1024
+            max_size = self.config.review.max_file_size_kb
+            if file_size_kb > max_size:
+                return "", f"File too large: {file_size_kb:.1f}KB (max: {max_size}KB)"
+            
+            content = file_path.read_text(encoding="utf-8")
+            return content, None
+            
+        except UnicodeDecodeError:
+            return "", f"Cannot read file (binary or encoding issue): {file_path}"
+        except Exception as e:
+            return "", f"Error reading file: {e}"
+
+    def write_file(
+        self,
+        file_path: Path,
+        content: str,
+        create_dirs: bool = True,
+        backup: bool = False,
+    ) -> Optional[str]:
+        """Write content to file. Returns error message or None on success."""
+        try:
+            if create_dirs:
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            if backup and file_path.exists():
+                backup_path = file_path.with_suffix(file_path.suffix + ".bak")
+                backup_path.write_text(file_path.read_text())
+            
+            file_path.write_text(content, encoding="utf-8")
+            return None
+            
+        except Exception as e:
+            return f"Error writing file: {e}"
+
+    def get_file_info(self, file_path: Path) -> dict:
+        """Get information about a file."""
+        if not file_path.exists():
+            return {"exists": False}
+        
+        stat = file_path.stat()
+        return {
+            "exists": True,
+            "size_bytes": stat.st_size,
+            "size_kb": stat.st_size / 1024,
+            "language": get_language_by_extension(self.config, file_path),
+            "extension": file_path.suffix,
+            "name": file_path.name,
+            "path": str(file_path.absolute()),
+        }
+
+    def batch_read(
+        self,
+        file_paths: List[Path],
+    ) -> Dict[Path, Tuple[str, Optional[str]]]:
+        """Read multiple files. Returns dict of path -> (content, error)."""
+        results = {}
+        for path in file_paths:
+            results[path] = self.read_file(path)
+        return results
+
+    def get_output_path(
+        self,
+        original_path: Path,
+        suffix: str = "",
+        output_dir: Optional[Path] = None,
+    ) -> Path:
+        """Generate output path for a file."""
+        if output_dir is None:
+            output_dir = Path(self.config.output.output_dir)
+        
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        new_name = original_path.stem + suffix + original_path.suffix
+        return output_dir / new_name
+