AI Processing Pipeline

user_prompt = (
    "Analyze the following code and determine if the syntax is out of date. "
    "If it is out of date, specify what changes need to be made in the following JSON format:\n\n"
    "{\n"
    '  "path": "relative/file/path",\n'
    '  "code_content": "The entire content of the file, before any changes are made.",\n'
    '  "reason": "A short explanation of why the code is out of date.",\n'
    '  "add": "Whether the code should be updated and has changes."\n'
    "}\n\n"
    f"{file_content}"
)

{
    "role": "system",
    "content": "You are a helpful assistant that analyzes code and returns 
                a JSON object with the path, and raw code content. Your goal 
                is to identify outdated syntax in code and keep track of it."
}

user_prompt = (
    "Analyze the following code and determine if the syntax is out of date. "
    "If it is out of date, specify what changes need to be made in the following JSON format:\n\n"
    "{\n"
    '  "refactored_code": "A rewrite of the file that is more up to date, using '
                         'the native language. The file should be a complete file, '
                         'not just a partial updated code segment.",\n'
    '  "refactored_code_comments": "Comments and explanations for your code changes. '
                                   'Be as descriptive, informative, and technical as possible."\n'
    "}\n\n"
    f"File: {file_path}\n\n"
    f"Code:\n{code_content}"
)

{
    "role": "system",
    "content": "You are a helpful assistant that analyzes code and returns 
                a JSON object with the refactored code and the comments that 
                come with it. Your goal is to identify outdated syntax in code 
                and suggest changes to update it to the latest syntax."
}

client = Groq(api_key=GROQ_API_KEY)
client = instructor.from_groq(client, mode=instructor.Mode.TOOLS)

class CodeChange(BaseModel):
    path: str
    code_content: str
    reason: str
    add: bool  # Whether to include in refactoring

class JobReport(BaseModel):
    refactored_code: str
    refactored_code_comments: str

class SyntaxValidator:
    @staticmethod
    def detect_language(file_path: str) -> str:
        extension_map = {
            '.py': 'python',
            '.js': 'javascript',
            '.jsx': 'javascript',
            '.ts': 'typescript',
            '.tsx': 'typescript',
            '.go': 'go',
            '.rs': 'rust',
            '.java': 'java',
        }
        _, ext = os.path.splitext(file_path)
        return extension_map.get(ext.lower(), 'unknown')

@dataclass
class ValidationResult:
    is_valid: bool
    language: str
    error_message: Optional[str] = None
    line_number: Optional[int] = None

@staticmethod
def calculate_score(
    old_code: str,
    new_code: str,
    validation_result: ValidationResult
) -> ConfidenceScore:
    """
    Scoring formula:
    - Syntax validation: 60 points (pass/fail)
    - Complexity factor: 40 points (based on change size)
    """
    # Base score from syntax validation
    syntax_score = 60 if validation_result.is_valid else 0
    
    # Calculate complexity factor
    complexity_factor = ConfidenceScorer.calculate_complexity(old_code, new_code)
    complexity_score = int(complexity_factor * 40)
    
    # Total score
    total_score = syntax_score + complexity_score
    
    return ConfidenceScore(
        score=total_score,
        syntax_valid=validation_result.is_valid,
        complexity_factor=complexity_factor,
        factors={...}
    )

@staticmethod
def calculate_complexity(old_code: str, new_code: str) -> float:
    """
    Calculate complexity factor based on code changes.
    
    Returns:
        Complexity factor (0.0 to 1.0, where 1.0 is low complexity)
    """
    old_lines = old_code.split('\n')
    new_lines = new_code.split('\n')
    
    lines_changed = abs(len(new_lines) - len(old_lines))
    total_lines = max(len(old_lines), len(new_lines))
    
    if total_lines == 0:
        change_ratio = 0.0
    else:
        change_ratio = lines_changed / total_lines
    
    # Inverse: smaller changes = higher confidence
    complexity_factor = max(0.0, 1.0 - change_ratio)
    
    return complexity_factor

@staticmethod
def generate_pr_description(file_changes: List[FileChange]) -> str:
    """
    Generate detailed PR description similar to GitButler style.
    Shows what changed, why it changed, and the impact.
    """
    pr_desc = []
    pr_desc.append("## 🤖 Automated Code Modernization\n")
    pr_desc.append("This pull request modernizes outdated code patterns...\n")
    
    # Summary
    pr_desc.append("### 📝 Summary\n")
    pr_desc.append(f"Updated **{total_files} files** with modern syntax...\n")
    
    # File-by-file breakdown
    pr_desc.append("### 📁 Changes by File\n")
    for fc in file_changes:
        pr_desc.append(f"#### `{fc.file_path}`\n")
        
        # What changed
        if fc.key_changes:
            pr_desc.append("**What changed:**")
            for change in fc.key_changes:
                pr_desc.append(f"- {change}")
        
        # Why it changed (AI explanation)
        if fc.explanation:
            pr_desc.append("**Why:**")
            pr_desc.append(f"> {fc.explanation}")
    
    return '\n'.join(pr_desc)

@dataclass
class FileChange:
    file_path: str
    old_code: str
    new_code: str
    explanation: str              # AI explanation
    confidence_score: int         # 0-100
    language: str                 # python, javascript, etc.
    lines_added: int              # Git-style diff
    lines_removed: int            # Git-style diff
    key_changes: List[str]        # Bullet points

@staticmethod
def calculate_diff_stats(old_code: str, new_code: str) -> tuple:
    """
    Calculate exact git-style diff statistics.
    """
    import difflib
    
    old_lines = old_code.split('\n') if old_code else []
    new_lines = new_code.split('\n') if new_code else []
    
    matcher = difflib.SequenceMatcher(None, old_lines, new_lines)
    
    added = 0
    removed = 0
    
    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
        if tag == 'replace':
            removed += (i2 - i1)
            added += (j2 - j1)
        elif tag == 'delete':
            removed += (i2 - i1)
        elif tag == 'insert':
            added += (j2 - j1)
    
    return added, removed

try:
    job_report = client.chat.completions.create(
        model="llama-3.3-70b-versatile",
        messages=[...],
        response_model=JobReport,  # Pydantic model
    )
except (ValidationError, json.JSONDecodeError) as parse_error:
    print(f"Error parsing LLM response: {parse_error}")
    return None  # Skip file
except Exception as e:
    print(f"Error analyzing {file_path}: {e}")
    return None

_client = None
_supabase_client = None

def get_client():
    """Get or create Groq client with API key."""
    global _client
    if _client is None:
        api_key = os.getenv("GROQ_API_KEY")
        if not api_key:
            from config import Config
            api_key = Config.GROQ_API_KEY
        
        _client = instructor.from_groq(
            Groq(api_key=api_key),
            mode=instructor.Mode.JSON
        )
    return _client

@app.function(
    timeout=300,
    max_containers=100,
    min_containers=3,  # Keep 3 warm
    secrets=[...]
)

data = {
    "status": "WRITING",
    "message": f"✍️ Updating {filename}",
    "code": job_report.refactored_code
}
supabase_client.table("repo-updates").insert(data).execute()