Module 1: Build Your First Coding Agent

# === Repository Analyzer ===
# Contract-name: xpander_run_action
# Purpose: Analyze repository structure and provide insights

import os
import subprocess
import json
from pathlib import Path

def xpander_run_action(repo_url: str, analysis_type: str = "structure"):
    """
    Analyze a repository for structure, dependencies, or code quality
    
    Args:
        repo_url: URL of the repository to analyze
        analysis_type: Type of analysis ("structure", "dependencies", "quality")
    
    Returns:
        dict: Analysis results with repository insights
    """
    
    try:
        # Extract repo name from URL
        repo_name = repo_url.split('/')[-1].replace('.git', '')
        temp_dir = f"/tmp/{repo_name}"
        
        # Clone repository if it doesn't exist
        if not os.path.exists(temp_dir):
            result = subprocess.run(
                ['git', 'clone', '--depth', '1', repo_url, temp_dir],
                capture_output=True,
                text=True,
                timeout=60
            )
            if result.returncode != 0:
                return {"error": f"Failed to clone repository: {result.stderr}"}
        
        # Perform analysis based on type
        if analysis_type == "structure":
            return analyze_structure(temp_dir)
        elif analysis_type == "dependencies":
            return analyze_dependencies(temp_dir)
        elif analysis_type == "quality":
            return analyze_quality(temp_dir)
        else:
            return {"error": f"Unknown analysis type: {analysis_type}"}
            
    except Exception as e:
        return {"error": f"Analysis failed: {str(e)}"}

def analyze_structure(repo_path):
    """Analyze repository structure"""
    structure = {"directories": [], "files_by_type": {}, "total_files": 0}
    
    for root, dirs, files in os.walk(repo_path):
        # Skip hidden directories and common build/cache directories
        dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ['node_modules', '__pycache__', 'dist', 'build']]
        
        rel_root = os.path.relpath(root, repo_path)
        if rel_root != '.':
            structure["directories"].append(rel_root)
        
        for file in files:
            if not file.startswith('.'):
                ext = Path(file).suffix.lower()
                if ext:
                    structure["files_by_type"][ext] = structure["files_by_type"].get(ext, 0) + 1
                structure["total_files"] += 1
    
    # Identify primary language
    if structure["files_by_type"]:
        primary_lang = max(structure["files_by_type"], key=structure["files_by_type"].get)
        structure["primary_language"] = primary_lang
    
    return structure

def analyze_dependencies(repo_path):
    """Analyze project dependencies"""
    dependencies = {"package_files": [], "dependencies": {}}
    
    # Common dependency files
    dep_files = {
        "package.json": "npm",
        "requirements.txt": "pip", 
        "Pipfile": "pipenv",
        "pom.xml": "maven",
        "build.gradle": "gradle",
        "Cargo.toml": "cargo"
    }
    
    for file_name, manager in dep_files.items():
        file_path = os.path.join(repo_path, file_name)
        if os.path.exists(file_path):
            dependencies["package_files"].append({"file": file_name, "manager": manager})
            
            # Parse specific file types
            if file_name == "package.json":
                try:
                    with open(file_path, 'r') as f:
                        package_data = json.load(f)
                        deps = package_data.get("dependencies", {})
                        dev_deps = package_data.get("devDependencies", {})
                        dependencies["dependencies"][manager] = {
                            "dependencies": deps,
                            "devDependencies": dev_deps
                        }
                except json.JSONDecodeError:
                    dependencies["dependencies"][manager] = {"error": "Invalid JSON"}
            
            elif file_name == "requirements.txt":
                try:
                    with open(file_path, 'r') as f:
                        reqs = [line.strip() for line in f if line.strip() and not line.startswith('#')]
                        dependencies["dependencies"][manager] = {"requirements": reqs}
                except Exception:
                    dependencies["dependencies"][manager] = {"error": "Failed to parse requirements"}
    
    return dependencies

def analyze_quality(repo_path):
    """Basic code quality analysis"""
    quality = {"metrics": {}, "issues": []}
    
    # Count lines of code
    total_lines = 0
    code_files = 0
    
    code_extensions = {'.py', '.js', '.ts', '.java', '.cpp', '.c', '.go', '.rs', '.rb'}
    
    for root, dirs, files in os.walk(repo_path):
        dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ['node_modules', '__pycache__']]
        
        for file in files:
            if Path(file).suffix.lower() in code_extensions:
                file_path = os.path.join(root, file)
                try:
                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                        lines = len(f.readlines())
                        total_lines += lines
                        code_files += 1
                except Exception:
                    continue
    
    quality["metrics"]["total_lines"] = total_lines
    quality["metrics"]["code_files"] = code_files
    quality["metrics"]["avg_lines_per_file"] = total_lines // max(code_files, 1)
    
    # Check for common quality indicators
    readme_exists = any(os.path.exists(os.path.join(repo_path, f)) for f in ['README.md', 'README.rst', 'README.txt'])
    quality["metrics"]["has_readme"] = readme_exists
    
    tests_exist = any('test' in d.lower() for d in os.listdir(repo_path) if os.path.isdir(os.path.join(repo_path, d)))
    quality["metrics"]["has_tests"] = tests_exist
    
    if not readme_exists:
        quality["issues"].append("No README file found")
    if not tests_exist:
        quality["issues"].append("No test directory found")
    
    return quality

# === Code Generator ===
# Contract-name: xpander_run_action
# Purpose: Generate code files based on specifications

import os
import tempfile
from pathlib import Path

def xpander_run_action(file_path: str, code_content: str, language: str = "python"):
    """
    Generate and validate code files
    
    Args:
        file_path: Target file path for the generated code
        code_content: The code content to write
        language: Programming language for syntax validation
        
    Returns:
        dict: Generation results with validation info
    """
    
    try:
        # Create directory if it doesn't exist
        os.makedirs(os.path.dirname(file_path), exist_ok=True)
        
        # Write code to file
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(code_content)
        
        # Basic validation
        validation_result = validate_code(code_content, language)
        
        # Get file info
        file_info = {
            "path": file_path,
            "size": len(code_content),
            "lines": len(code_content.split('\n')),
            "language": language
        }
        
        return {
            "success": True,
            "file_info": file_info,
            "validation": validation_result,
            "message": f"Code generated successfully at {file_path}"
        }
        
    except Exception as e:
        return {
            "success": False,
            "error": str(e),
            "message": "Code generation failed"
        }

def validate_code(code_content: str, language: str):
    """Basic code validation"""
    validation = {"syntax_ok": True, "issues": [], "score": 100}
    
    # Basic checks for different languages
    if language.lower() == "python":
        # Check for basic Python syntax
        try:
            compile(code_content, '<string>', 'exec')
        except SyntaxError as e:
            validation["syntax_ok"] = False
            validation["issues"].append(f"Syntax error: {e}")
            validation["score"] -= 50
        
        # Check for basic quality indicators
        if 'def ' not in code_content and 'class ' not in code_content:
            validation["issues"].append("No functions or classes defined")
            validation["score"] -= 20
            
        if '"""' not in code_content and "'''" not in code_content:
            validation["issues"].append("No docstrings found")
            validation["score"] -= 10
    
    elif language.lower() in ["javascript", "typescript"]:
        # Basic JavaScript/TypeScript checks
        if 'function' not in code_content and '=>' not in code_content:
            validation["issues"].append("No functions defined")
            validation["score"] -= 20
            
        if code_content.count('{') != code_content.count('}'):
            validation["issues"].append("Mismatched braces")
            validation["score"] -= 30
    
    # General quality checks
    lines = code_content.split('\n')
    empty_lines = sum(1 for line in lines if not line.strip())
    if len(lines) > 10 and empty_lines / len(lines) < 0.1:
        validation["issues"].append("Code could benefit from more whitespace")
        validation["score"] -= 5
    
    return validation

def xpander_run_action(repo_url: str, analysis_type: str = "structure"):
    """Repository analyzer with enhanced error handling"""
    
    # Input validation
    if not repo_url or not repo_url.startswith(('http://', 'https://')):
        return {"error": "Invalid repository URL provided"}
    
    if analysis_type not in ["structure", "dependencies", "quality"]:
        return {"error": f"Invalid analysis type: {analysis_type}. Must be one of: structure, dependencies, quality"}
    
    try:
        # Implementation with proper error handling
        # ... existing code ...
        
    except subprocess.TimeoutExpired:
        return {"error": "Repository clone timeout - repository may be too large"}
    except subprocess.CalledProcessError as e:
        return {"error": f"Git operation failed: {e.stderr}"}
    except PermissionError:
        return {"error": "Permission denied accessing repository"}
    except Exception as e:
        return {"error": f"Unexpected error: {str(e)}"}