Create troviku_helpers.py

troviku_helpers.py

@@ -0,0 +1,851 @@
+"""
+Troviku Helper Utilities
+=========================
+
+A collection of useful helper functions and utilities that make working
+with Troviku easier and more convenient. These helpers handle common tasks
+like code parsing, template management, snippet generation, and more.
+
+Author: OpenTrouter Research Team
+License: Apache 2.0
+Version: 1.1.0
+"""
+
+import re
+import json
+import hashlib
+from typing import List, Dict, Any, Optional, Tuple, Set
+from dataclasses import dataclass
+from pathlib import Path
+
+
+# ============================================================================
+# CODE PARSING AND ANALYSIS
+# ============================================================================
+
+class CodeParser:
+    """Parse and analyze code structure."""
+    
+    @staticmethod
+    def extract_functions(code: str, language: str = "python") -> List[Dict[str, Any]]:
+        """
+        Extract function definitions from code.
+        
+        Args:
+            code: Source code
+            language: Programming language
+            
+        Returns:
+            List of function information dictionaries
+        """
+        functions = []
+        
+        if language == "python":
+            pattern = r'def\s+(\w+)\s*\((.*?)\):'
+            matches = re.finditer(pattern, code)
+            
+            for match in matches:
+                name = match.group(1)
+                params = match.group(2)
+                start_pos = match.start()
+                
+                # Extract docstring if present
+                docstring = CodeParser._extract_python_docstring(code, start_pos)
+                
+                functions.append({
+                    "name": name,
+                    "parameters": [p.strip() for p in params.split(',') if p.strip()],
+                    "docstring": docstring,
+                    "line": code[:start_pos].count('\n') + 1
+                })
+        
+        elif language in ["javascript", "typescript"]:
+            # Match function declarations and arrow functions
+            patterns = [
+                r'function\s+(\w+)\s*\((.*?)\)',
+                r'const\s+(\w+)\s*=\s*\((.*?)\)\s*=>',
+                r'(\w+)\s*:\s*function\s*\((.*?)\)'
+            ]
+            
+            for pattern in patterns:
+                matches = re.finditer(pattern, code)
+                for match in matches:
+                    functions.append({
+                        "name": match.group(1),
+                        "parameters": [p.strip() for p in match.group(2).split(',') if p.strip()],
+                        "line": code[:match.start()].count('\n') + 1
+                    })
+        
+        return functions
+    
+    @staticmethod
+    def extract_classes(code: str, language: str = "python") -> List[Dict[str, Any]]:
+        """
+        Extract class definitions from code.
+        
+        Args:
+            code: Source code
+            language: Programming language
+            
+        Returns:
+            List of class information dictionaries
+        """
+        classes = []
+        
+        if language == "python":
+            pattern = r'class\s+(\w+)(?:\((.*?)\))?:'
+            matches = re.finditer(pattern, code)
+            
+            for match in matches:
+                name = match.group(1)
+                bases = match.group(2) or ""
+                start_pos = match.start()
+                
+                classes.append({
+                    "name": name,
+                    "bases": [b.strip() for b in bases.split(',') if b.strip()],
+                    "line": code[:start_pos].count('\n') + 1
+                })
+        
+        elif language == "java":
+            pattern = r'class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?'
+            matches = re.finditer(pattern, code)
+            
+            for match in matches:
+                classes.append({
+                    "name": match.group(1),
+                    "extends": match.group(2),
+                    "implements": match.group(3),
+                    "line": code[:match.start()].count('\n') + 1
+                })
+        
+        return classes
+    
+    @staticmethod
+    def extract_imports(code: str, language: str = "python") -> List[str]:
+        """
+        Extract import statements.
+        
+        Args:
+            code: Source code
+            language: Programming language
+            
+        Returns:
+            List of imported modules/packages
+        """
+        imports = []
+        
+        if language == "python":
+            # Match "import x" and "from x import y"
+            patterns = [
+                r'import\s+([\w.]+)',
+                r'from\s+([\w.]+)\s+import'
+            ]
+            
+            for pattern in patterns:
+                matches = re.finditer(pattern, code)
+                imports.extend(match.group(1) for match in matches)
+        
+        elif language in ["javascript", "typescript"]:
+            # Match ES6 imports
+            patterns = [
+                r'import\s+.*?\s+from\s+["\'](.+?)["\']',
+                r'require\(["\'](.+?)["\']\)'
+            ]
+            
+            for pattern in patterns:
+                matches = re.finditer(pattern, code)
+                imports.extend(match.group(1) for match in matches)
+        
+        return list(set(imports))  # Remove duplicates
+    
+    @staticmethod
+    def _extract_python_docstring(code: str, func_start: int) -> Optional[str]:
+        """Extract Python docstring after function definition."""
+        # Find the first triple-quote after function definition
+        rest = code[func_start:]
+        match = re.search(r'"""(.*?)"""|\'\'\'(.*?)\'\'\'', rest, re.DOTALL)
+        if match:
+            return (match.group(1) or match.group(2)).strip()
+        return None
+    
+    @staticmethod
+    def count_complexity(code: str, language: str = "python") -> int:
+        """
+        Calculate cyclomatic complexity (simplified).
+        
+        Args:
+            code: Source code
+            language: Programming language
+            
+        Returns:
+            Complexity score
+        """
+        complexity = 1  # Base complexity
+        
+        # Keywords that increase complexity
+        keywords = {
+            "python": [r'\bif\b', r'\belif\b', r'\bfor\b', r'\bwhile\b', r'\band\b', r'\bor\b', r'\bexcept\b'],
+            "javascript": [r'\bif\b', r'\belse if\b', r'\bfor\b', r'\bwhile\b', r'\b&&\b', r'\b\|\|\b', r'\bcatch\b'],
+            "java": [r'\bif\b', r'\belse if\b', r'\bfor\b', r'\bwhile\b', r'\b&&\b', r'\b\|\|\b', r'\bcatch\b']
+        }
+        
+        patterns = keywords.get(language, keywords["python"])
+        
+        for pattern in patterns:
+            complexity += len(re.findall(pattern, code))
+        
+        return complexity
+
+
+# ============================================================================
+# TEMPLATE MANAGEMENT
+# ============================================================================
+
+class TemplateManager:
+    """Manage code templates for common patterns."""
+    
+    TEMPLATES = {
+        "python": {
+            "function": """def {name}({params}):
+    \"\"\"
+    {description}
+    
+    Args:
+        {args_doc}
+    
+    Returns:
+        {return_doc}
+    \"\"\"
+    {body}
+""",
+            "class": """class {name}:
+    \"\"\"
+    {description}
+    \"\"\"
+    
+    def __init__(self{init_params}):
+        \"\"\"Initialize {name}.\"\"\"
+        {init_body}
+    
+    {methods}
+""",
+            "test": """import pytest
+
+def test_{name}():
+    \"\"\"Test {description}.\"\"\"
+    # Arrange
+    {arrange}
+    
+    # Act
+    {act}
+    
+    # Assert
+    {assert_}
+""",
+            "api_endpoint": """@app.route('/{path}', methods=['{method}'])
+def {name}():
+    \"\"\"
+    {description}
+    \"\"\"
+    try:
+        {body}
+        return jsonify({{
+            'success': True,
+            'data': result
+        }}), 200
+    except Exception as e:
+        return jsonify({{
+            'success': False,
+            'error': str(e)
+        }}), 400
+"""
+        },
+        "javascript": {
+            "function": """/**
+ * {description}
+ * @param {{{param_types}}} {params}
+ * @returns {{{return_type}}}
+ */
+function {name}({params}) {{
+    {body}
+}}
+""",
+            "class": """/**
+ * {description}
+ */
+class {name} {{
+    constructor({params}) {{
+        {constructor_body}
+    }}
+    
+    {methods}
+}}
+""",
+            "react_component": """import React from 'react';
+
+/**
+ * {description}
+ */
+const {name} = ({{ {props} }}) => {{
+    {body}
+    
+    return (
+        {jsx}
+    );
+}};
+
+export default {name};
+"""
+        }
+    }
+    
+    @staticmethod
+    def get_template(language: str, template_type: str) -> Optional[str]:
+        """
+        Get a code template.
+        
+        Args:
+            language: Programming language
+            template_type: Type of template
+            
+        Returns:
+            Template string or None
+        """
+        return TemplateManager.TEMPLATES.get(language, {}).get(template_type)
+    
+    @staticmethod
+    def fill_template(template: str, **kwargs) -> str:
+        """
+        Fill template with values.
+        
+        Args:
+            template: Template string
+            **kwargs: Values to fill
+            
+        Returns:
+            Filled template
+        """
+        try:
+            return template.format(**kwargs)
+        except KeyError as e:
+            raise ValueError(f"Missing template parameter: {e}")
+    
+    @staticmethod
+    def create_from_template(
+        language: str,
+        template_type: str,
+        **kwargs
+    ) -> str:
+        """
+        Create code from template.
+        
+        Args:
+            language: Programming language
+            template_type: Type of template
+            **kwargs: Template parameters
+            
+        Returns:
+            Generated code
+        """
+        template = TemplateManager.get_template(language, template_type)
+        if not template:
+            raise ValueError(f"Template not found: {language}/{template_type}")
+        
+        return TemplateManager.fill_template(template, **kwargs)
+
+
+# ============================================================================
+# SNIPPET LIBRARY
+# ============================================================================
+
+class SnippetLibrary:
+    """Library of common code snippets."""
+    
+    SNIPPETS = {
+        "python": {
+            "read_file": """with open('{filename}', 'r') as f:
+    content = f.read()""",
+            
+            "write_file": """with open('{filename}', 'w') as f:
+    f.write(content)""",
+            
+            "http_get": """import requests
+response = requests.get('{url}')
+data = response.json()""",
+            
+            "parse_json": """import json
+data = json.loads(json_string)""",
+            
+            "list_comprehension": """result = [{expression} for {item} in {iterable} if {condition}]""",
+            
+            "error_handling": """try:
+    {code}
+except {exception} as e:
+    {handler}""",
+            
+            "class_property": """@property
+def {name}(self):
+    return self._{name}
+
+@{name}.setter
+def {name}(self, value):
+    self._{name} = value""",
+            
+            "context_manager": """class {name}:
+    def __enter__(self):
+        {enter_code}
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        {exit_code}""",
+            
+            "decorator": """def {name}(func):
+    def wrapper(*args, **kwargs):
+        {before}
+        result = func(*args, **kwargs)
+        {after}
+        return result
+    return wrapper""",
+        },
+        "javascript": {
+            "fetch_api": """fetch('{url}')
+    .then(response => response.json())
+    .then(data => console.log(data))
+    .catch(error => console.error('Error:', error));""",
+            
+            "async_function": """async function {name}({params}) {{
+    try {{
+        const result = await {async_call};
+        return result;
+    }} catch (error) {{
+        console.error('Error:', error);
+    }}
+}}""",
+            
+            "array_methods": """// Map
+const mapped = array.map(item => item * 2);
+
+// Filter
+const filtered = array.filter(item => item > 0);
+
+// Reduce
+const sum = array.reduce((acc, item) => acc + item, 0);""",
+            
+            "promise": """const {name} = new Promise((resolve, reject) => {{
+    {code}
+    if (success) {{
+        resolve(result);
+    }} else {{
+        reject(error);
+    }}
+}});""",
+        }
+    }
+    
+    @staticmethod
+    def get_snippet(language: str, snippet_name: str, **kwargs) -> str:
+        """
+        Get and optionally fill a code snippet.
+        
+        Args:
+            language: Programming language
+            snippet_name: Name of snippet
+            **kwargs: Values to fill in snippet
+            
+        Returns:
+            Code snippet
+        """
+        snippet = SnippetLibrary.SNIPPETS.get(language, {}).get(snippet_name)
+        if not snippet:
+            raise ValueError(f"Snippet not found: {language}/{snippet_name}")
+        
+        if kwargs:
+            try:
+                return snippet.format(**kwargs)
+            except KeyError:
+                return snippet
+        
+        return snippet
+    
+    @staticmethod
+    def list_snippets(language: str) -> List[str]:
+        """List available snippets for a language."""
+        return list(SnippetLibrary.SNIPPETS.get(language, {}).keys())
+
+
+# ============================================================================
+# CODE QUALITY ANALYZER
+# ============================================================================
+
+class QualityAnalyzer:
+    """Analyze code quality and provide suggestions."""
+    
+    @staticmethod
+    def analyze(code: str, language: str = "python") -> Dict[str, Any]:
+        """
+        Analyze code quality.
+        
+        Args:
+            code: Source code
+            language: Programming language
+            
+        Returns:
+            Analysis results dictionary
+        """
+        results = {
+            "language": language,
+            "metrics": QualityAnalyzer._calculate_metrics(code),
+            "issues": QualityAnalyzer._find_issues(code, language),
+            "suggestions": QualityAnalyzer._generate_suggestions(code, language),
+            "score": 0
+        }
+        
+        # Calculate overall quality score (0-100)
+        results["score"] = QualityAnalyzer._calculate_score(results)
+        
+        return results
+    
+    @staticmethod
+    def _calculate_metrics(code: str) -> Dict[str, Any]:
+        """Calculate code metrics."""
+        lines = code.split('\n')
+        non_empty = [l for l in lines if l.strip()]
+        
+        return {
+            "total_lines": len(lines),
+            "code_lines": len(non_empty),
+            "blank_lines": len(lines) - len(non_empty),
+            "average_line_length": sum(len(l) for l in lines) / len(lines) if lines else 0,
+            "max_line_length": max(len(l) for l in lines) if lines else 0,
+            "comment_ratio": QualityAnalyzer._calculate_comment_ratio(code)
+        }
+    
+    @staticmethod
+    def _calculate_comment_ratio(code: str) -> float:
+        """Calculate ratio of comment lines to code lines."""
+        lines = code.split('\n')
+        comment_lines = sum(1 for l in lines if l.strip().startswith('#') or l.strip().startswith('//'))
+        code_lines = sum(1 for l in lines if l.strip() and not l.strip().startswith('#'))
+        
+        return comment_lines / code_lines if code_lines > 0 else 0
+    
+    @staticmethod
+    def _find_issues(code: str, language: str) -> List[Dict[str, str]]:
+        """Find potential issues in code."""
+        issues = []
+        lines = code.split('\n')
+        
+        for i, line in enumerate(lines, 1):
+            # Long lines
+            if len(line) > 120:
+                issues.append({
+                    "line": i,
+                    "type": "style",
+                    "message": f"Line too long ({len(line)} characters)"
+                })
+            
+            # Multiple statements on one line (Python)
+            if language == "python" and ';' in line and not line.strip().startswith('#'):
+                issues.append({
+                    "line": i,
+                    "type": "style",
+                    "message": "Multiple statements on one line"
+                })
+            
+            # TODO/FIXME comments
+            if 'TODO' in line or 'FIXME' in line:
+                issues.append({
+                    "line": i,
+                    "type": "todo",
+                    "message": "TODO or FIXME comment found"
+                })
+        
+        return issues
+    
+    @staticmethod
+    def _generate_suggestions(code: str, language: str) -> List[str]:
+        """Generate improvement suggestions."""
+        suggestions = []
+        
+        metrics = QualityAnalyzer._calculate_metrics(code)
+        
+        # Comment ratio
+        if metrics["comment_ratio"] < 0.1:
+            suggestions.append("Consider adding more comments to explain complex logic")
+        
+        # Line length
+        if metrics["max_line_length"] > 120:
+            suggestions.append("Break long lines into multiple lines for better readability")
+        
+        # Code complexity
+        complexity = CodeParser.count_complexity(code, language)
+        if complexity > 10:
+            suggestions.append("High complexity detected. Consider refactoring into smaller functions")
+        
+        # Function extraction
+        if metrics["code_lines"] > 50:
+            suggestions.append("Consider breaking code into smaller, reusable functions")
+        
+        return suggestions
+    
+    @staticmethod
+    def _calculate_score(results: Dict[str, Any]) -> int:
+        """Calculate overall quality score."""
+        score = 100
+        
+        # Deduct points for issues
+        score -= len(results["issues"]) * 5
+        
+        # Deduct for poor metrics
+        if results["metrics"]["comment_ratio"] < 0.1:
+            score -= 10
+        if results["metrics"]["max_line_length"] > 120:
+            score -= 10
+        
+        return max(0, min(100, score))
+
+
+# ============================================================================
+# DEPENDENCY ANALYZER
+# ============================================================================
+
+class DependencyAnalyzer:
+    """Analyze code dependencies."""
+    
+    @staticmethod
+    def analyze_imports(code: str, language: str = "python") -> Dict[str, Any]:
+        """
+        Analyze import dependencies.
+        
+        Args:
+            code: Source code
+            language: Programming language
+            
+        Returns:
+            Dependency analysis
+        """
+        imports = CodeParser.extract_imports(code, language)
+        
+        return {
+            "total_imports": len(imports),
+            "imports": imports,
+            "stdlib": DependencyAnalyzer._classify_stdlib(imports, language),
+            "third_party": DependencyAnalyzer._classify_third_party(imports, language),
+            "circular": []  # Would need full codebase to detect
+        }
+    
+    @staticmethod
+    def _classify_stdlib(imports: List[str], language: str) -> List[str]:
+        """Classify standard library imports."""
+        stdlib = {
+            "python": {
+                "os", "sys", "re", "json", "time", "datetime", "math", "random",
+                "collections", "itertools", "functools", "pathlib", "typing",
+                "logging", "unittest", "argparse", "threading", "subprocess"
+            },
+            "javascript": {
+                "fs", "path", "http", "https", "url", "crypto", "util",
+                "events", "stream", "buffer", "process"
+            }
+        }
+        
+        std_modules = stdlib.get(language, set())
+        return [imp for imp in imports if imp.split('.')[0] in std_modules]
+    
+    @staticmethod
+    def _classify_third_party(imports: List[str], language: str) -> List[str]:
+        """Classify third-party imports."""
+        stdlib = DependencyAnalyzer._classify_stdlib(imports, language)
+        return [imp for imp in imports if imp not in stdlib]
+
+
+# ============================================================================
+# DOCUMENTATION GENERATOR
+# ============================================================================
+
+class DocGenerator:
+    """Generate documentation from code."""
+    
+    @staticmethod
+    def generate_function_doc(func_info: Dict[str, Any], language: str = "python") -> str:
+        """Generate documentation for a function."""
+        if language == "python":
+            params_doc = "\n    ".join(
+                f"{param}: Description of {param}"
+                for param in func_info.get("parameters", [])
+            )
+            
+            return f"""\"\"\"
+{func_info['name']} - Brief description.
+
+Args:
+    {params_doc}
+
+Returns:
+    Description of return value.
+
+Raises:
+    Exception: Description of when exception is raised.
+\"\"\""""
+        
+        elif language in ["javascript", "typescript"]:
+            params_doc = "\n * ".join(
+                f"@param {{{}}}} {param} - Description of {param}"
+                for param in func_info.get("parameters", [])
+            )
+            
+            return f"""/**
+ * {func_info['name']} - Brief description.
+ *
+ * {params_doc}
+ * @returns {{}} Description of return value.
+ */"""
+        
+        return ""
+    
+    @staticmethod
+    def generate_readme(
+        project_name: str,
+        description: str,
+        functions: List[Dict[str, Any]]
+    ) -> str:
+        """Generate README.md content."""
+        func_list = "\n".join(
+            f"- `{func['name']}({', '.join(func.get('parameters', []))})`: {func.get('docstring', 'No description')}"
+            for func in functions
+        )
+        
+        return f"""# {project_name}
+
+{description}
+
+## Functions
+
+{func_list}
+
+## Installation
+
+```bash
+pip install {project_name.lower().replace(' ', '-')}
+```
+
+## Usage
+
+```python
+from {project_name.lower().replace(' ', '_')} import *
+
+# Example usage here
+```
+
+## License
+
+MIT License
+"""
+
+
+# ============================================================================
+# UTILITY FUNCTIONS
+# ============================================================================
+
+def generate_file_hash(content: str) -> str:
+    """Generate hash for file content."""
+    return hashlib.sha256(content.encode()).hexdigest()
+
+
+def find_similar_code(code: str, code_library: List[str], threshold: float = 0.8) -> List[int]:
+    """
+    Find similar code snippets.
+    
+    Args:
+        code: Code to compare
+        code_library: List of code snippets
+        threshold: Similarity threshold (0-1)
+        
+    Returns:
+        List of indices of similar code
+    """
+    similar = []
+    code_hash = set(code.split())
+    
+    for i, snippet in enumerate(code_library):
+        snippet_hash = set(snippet.split())
+        
+        # Jaccard similarity
+        intersection = len(code_hash & snippet_hash)
+        union = len(code_hash | snippet_hash)
+        similarity = intersection / union if union > 0 else 0
+        
+        if similarity >= threshold:
+            similar.append(i)
+    
+    return similar
+
+
+def estimate_execution_time(code: str, language: str = "python") -> str:
+    """
+    Estimate code execution time complexity.
+    
+    Args:
+        code: Source code
+        language: Programming language
+        
+    Returns:
+        Time complexity estimate (e.g., "O(n)", "O(n^2)")
+    """
+    # Simple heuristic based on nested loops
+    loops = len(re.findall(r'\bfor\b|\bwhile\b', code))
+    
+    if loops == 0:
+        return "O(1)"
+    elif loops == 1:
+        return "O(n)"
+    elif loops == 2:
+        return "O(n²)"
+    else:
+        return f"O(n^{loops})"
+
+
+def beautify_output(response_dict: Dict[str, Any]) -> str:
+    """
+    Create beautiful formatted output.
+    
+    Args:
+        response_dict: Response dictionary
+        
+    Returns:
+        Formatted string
+    """
+    output = []
+    output.append("=" * 70)
+    output.append("TROVIKU CODE GENERATION RESULT")
+    output.append("=" * 70)
+    output.append(f"Language: {response_dict.get('language', 'unknown')}")
+    output.append(f"Task: {response_dict.get('task_type', 'unknown')}")
+    output.append(f"Tokens: {response_dict.get('tokens_used', 0)}")
+    output.append(f"Time: {response_dict.get('execution_time', 0):.2f}s")
+    output.append("-" * 70)
+    output.append("CODE:")
+    output.append("-" * 70)
+    output.append(response_dict.get('code', ''))
+    output.append("=" * 70)
+    
+    return "\n".join(output)
+
+
+# ============================================================================
+# EXPORT
+# ============================================================================
+
+__all__ = [
+    "CodeParser",
+    "TemplateManager",
+    "SnippetLibrary",
+    "QualityAnalyzer",
+    "DependencyAnalyzer",
+    "DocGenerator",
+    "generate_file_hash",
+    "find_similar_code",
+    "estimate_execution_time",
+    "beautify_output",
+]