ErrorFixingMixin

Source Code: hub/agents/python/code/gaia_agent_code/tools/error_fixing.py

Component: ErrorFixingMixin Module: gaia_agent_code.tools.error_fixing Import: from gaia_agent_code.tools.error_fixing import ErrorFixingMixin

Overview

ErrorFixingMixin provides automatic error detection and fixing capabilities using LLM-driven analysis. It handles syntax errors, linting issues, runtime errors, and includes workflow planning tools for complex projects. Key Features:

Automatic syntax error detection and fixing
LLM-based code correction
Pylint error fixing with iteration
Runtime error fixing
Architectural plan generation
Project structure creation
Workflow planning
GAIA.md initialization from codebase

Tool Specifications

1. auto_fix_syntax_errors

Scan project for syntax errors and fix them automatically. Parameters:

project_path (str, required): Path to project directory

Returns:

{
    "status": "success",
    "files_fixed": int,
    "errors_remaining": int,
    "fixed_files": [
        {"file": str, "errors_fixed": List[str]}
    ],
    "errors_found": [
        {"file": str, "errors": List[str]}
    ],
    "message": str
}

2. fix_code

Fix Python code using LLM analysis. Parameters:

file_path (str, required): Path to file to fix
error_description (str, optional): Error description

Returns:

{
    "status": "success",
    "file_modified": bool,
    "original_lines": int,
    "fixed_lines": int,
    "diff": str,
    "message": str
}

3. fix_linting_errors

Fix pylint issues iteratively. Parameters:

file_path (str, required): Path to file
lint_issues (List[Dict], required): Pylint issues

Returns:

{
    "status": "success",
    "fixes_applied": List[str],
    "file_modified": bool,
    "total_fixes": int,
    "iterations": int,
    "remaining_issues": int,
    "backup_created": str  # If create_backup=True
}

4. fix_python_errors

Fix runtime errors automatically. Parameters:

file_path (str, required): Path to file
error_message (str, required): Runtime error message

Returns:

{
    "status": "success",
    "fixes_applied": List[str],
    "file_modified": bool
}

Handled Errors:

NameError (add missing imports)
IndentationError (fix spacing)
TypeError (add type checking)

5. create_architectural_plan

Generate architectural plan for a project. Parameters:

query (str, required): Project requirements
project_type (str, optional): “application”, “library”, “game”, “api”

Returns:

{
    "status": "success",
    "plan_created": bool,
    "plan_file": str,
    "project_name": str,
    "num_files": int,
    "num_classes": int,
    "message": str
}

Generated Plan Structure:

{
    "project_name": str,
    "project_type": str,
    "description": str,
    "created": str,  # ISO timestamp
    "architecture": {
        "overview": str,
        "components": List,
        "folder_structure": Dict,
        "files": List,
        "classes": List,
        "functions": List,
        "dependencies": List
    },
    "implementation_order": List[str],
    "execution_steps": [
        {
            "step": int,
            "action": str,
            "description": str,
            "completed": bool
        }
    ]
}

6. create_project_structure

Create folder structure from architectural plan. Parameters: None (uses self.plan) Returns:

{
    "status": "success",
    "project_root": str,
    "dirs_created": int,
    "files_created": int,
    "created_dirs": List[str],
    "created_files": List[str],
    "message": str
}

7. implement_from_plan

Implement components from architectural plan. Parameters:

component (str, optional): Specific component to implement
auto_implement_all (bool, optional): Implement all (default: False)

Returns:

{
    "status": "success",
    "implemented": List[Dict],
    "errors": List[Dict],
    "total_implemented": int,
    "total_errors": int,
    "message": str
}

8. init_gaia_md

Initialize GAIA.md from codebase analysis. Parameters:

project_root (str, optional): Root directory (default: ”.”)

Returns:

{
    "status": "success",
    "file_path": str,
    "project_name": str,
    "project_type": str,
    "python_files": int,
    "classes_found": int,
    "functions_found": int,
    "message": str
}

9. create_workflow_plan

Plan a complex multi-step workflow. The code agent uses this when a user request can’t be satisfied by a single tool call — it decomposes the request into an ordered plan of tool invocations the agent then executes. Parameters:

query (str, required): Natural-language description of the workflow to plan

Returns:

{
    "status": "success",
    "plan": [
        {"step": int, "tool": str, "tool_args": dict, "description": str},
        ...
    ],
    "rationale": str,
}

Usage Examples

Example 1: Auto-Fix Syntax Errors

from gaia_agent_code import CodeAgent

agent = CodeAgent()

result = agent.auto_fix_syntax_errors("/path/to/project")

print(f"Fixed {result['files_fixed']} files")
print(f"Remaining errors: {result['errors_remaining']}")

for fixed in result["fixed_files"]:
    print(f"\n✓ {fixed['file']}")
    for error in fixed["errors_fixed"]:
        print(f"  - {error}")

Example 2: Fix Code with LLM

result = agent.fix_code(
    file_path="src/calculator.py",
    error_description="Line 42: SyntaxError: invalid syntax"
)

if result["file_modified"]:
    print("Changes made:")
    print(result["diff"])

Example 3: Fix Linting Errors

# Get pylint issues
lint_result = agent.analyze_with_pylint(file_path="src/app.py")

if not lint_result["clean"]:
    # Fix issues
    fix_result = agent.fix_linting_errors(
        file_path="src/app.py",
        lint_issues=lint_result["issues"]
    )

    print(f"Applied {fix_result['total_fixes']} fixes")
    print(f"Iterations: {fix_result['iterations']}")
    print(f"Remaining issues: {fix_result['remaining_issues']}")

Example 4: Create Architectural Plan

result = agent.create_architectural_plan(
    query="Create a snake game with pygame",
    project_type="game"
)

print(f"Plan created: {result['plan_file']}")
print(f"Project: {result['project_name']}")
print(f"Files to create: {result['num_files']}")

# Create structure
structure_result = agent.create_project_structure()
print(f"Created {structure_result['dirs_created']} dirs")

# Implement all
impl_result = agent.implement_from_plan(auto_implement_all=True)
print(f"Implemented {impl_result['total_implemented']} components")

Example 5: Initialize GAIA.md

result = agent.init_gaia_md(project_root="/path/to/project")

print(f"Analyzed {result['python_files']} Python files")
print(f"Found {result['classes_found']} classes")
print(f"Found {result['functions_found']} functions")
print(f"Created: {result['file_path']}")

LLM-Based Fixing

Fix Code Prompt Template

prompt = f"""Fix the following {lang_label} code error:

File path: {file_path}
Error: {error_msg}

Code:
```{lang}
{code}

Return ONLY the corrected code, no explanations."""

### Iterative Linting Fix

```python
iteration = 0
while remaining_issues and iteration < max_iterations:
    iteration += 1

    # Format issues for LLM
    issues_text = "\n".join([
        f"Line {issue['line']}: [{issue['symbol']}] {issue['message']}"
        for issue in remaining_issues[:10]
    ])

    # Get fixed code from LLM
    response = self.chat.send(prompt)
    fixed_code = extract_code(response.text)

    # Validate
    validation = self.syntax_validator.validate_dict(fixed_code)
    if not validation["is_valid"]:
        break

    # Write and re-check
    path.write_text(fixed_code)
    remaining_issues = run_pylint(path)

Project Templates

Game Project Structure

{
    "main.py": "Entry point and main loop",
    "core/": {
        "__init__.py": "Core package initialization",
        "game.py": "Main game logic",
        "entities.py": "Game entities and objects",
        "physics.py": "Physics and collision detection"
    },
    "ui/": {
        "__init__.py": "UI package initialization",
        "renderer.py": "Rendering and display",
        "menu.py": "Menu screens"
    }
}

API Project Structure

{
    "main.py": "Application entry point",
    "api/": {
        "__init__.py": "API package initialization",
        "routes.py": "API route definitions",
        "models.py": "Data models",
        "handlers.py": "Request handlers"
    },
    "core/": {
        "services.py": "Business logic services",
        "database.py": "Database connections"
    }
}

Testing Requirements

File: tests/agents/code/test_error_fixing.py

def test_auto_fix_syntax_errors(tmp_path):
    """Test automatic syntax error fixing."""
    # Create file with syntax error
    file_path = tmp_path / "test.py"
    file_path.write_text("def hello(\npass")

    result = auto_fix_syntax_errors(str(tmp_path))

    assert result["files_fixed"] > 0
    assert result["errors_remaining"] == 0

def test_fix_linting_errors():
    """Test iterative linting fix."""
    lint_issues = [
        {
            "line": 1,
            "symbol": "missing-docstring",
            "message": "Missing module docstring"
        }
    ]

    result = fix_linting_errors(file_path, lint_issues)

    assert result["file_modified"]
    assert result["iterations"] > 0

def test_create_architectural_plan():
    """Test plan generation."""
    result = create_architectural_plan(
        query="Create a calculator app",
        project_type="application"
    )

    assert result["plan_created"]
    assert "calculator" in result["project_name"].lower()

Dependencies

import ast
import logging
import os
from datetime import datetime
from pathlib import Path
from typing import Any, Dict, List

logger = logging.getLogger(__name__)

ErrorFixingMixin Technical Specification

Core Framework

SDKs

Infrastructure

Code Infrastructure

Tool Mixins

Packaging

Agents & Apps

Overview

Tool Specifications

1. auto_fix_syntax_errors

2. fix_code

3. fix_linting_errors

4. fix_python_errors

5. create_architectural_plan

6. create_project_structure

7. implement_from_plan

8. init_gaia_md

9. create_workflow_plan

Usage Examples

Example 1: Auto-Fix Syntax Errors

Example 2: Fix Code with LLM

Example 3: Fix Linting Errors

Example 4: Create Architectural Plan

Example 5: Initialize GAIA.md

LLM-Based Fixing

Fix Code Prompt Template

Project Templates

Game Project Structure

API Project Structure

Testing Requirements

Dependencies

​Overview

​Tool Specifications

​1. auto_fix_syntax_errors

​2. fix_code

​3. fix_linting_errors

​4. fix_python_errors

​5. create_architectural_plan

​6. create_project_structure

​7. implement_from_plan

​8. init_gaia_md

​9. create_workflow_plan

​Usage Examples

​Example 1: Auto-Fix Syntax Errors

​Example 2: Fix Code with LLM

​Example 3: Fix Linting Errors

​Example 4: Create Architectural Plan

​Example 5: Initialize GAIA.md

​LLM-Based Fixing

​Fix Code Prompt Template

​Project Templates

​Game Project Structure

​API Project Structure

​Testing Requirements

​Dependencies

Overview

Tool Specifications

1. auto_fix_syntax_errors

2. fix_code

3. fix_linting_errors

4. fix_python_errors

5. create_architectural_plan

6. create_project_structure

7. implement_from_plan

8. init_gaia_md

9. create_workflow_plan

Usage Examples

Example 1: Auto-Fix Syntax Errors

Example 2: Fix Code with LLM

Example 3: Fix Linting Errors

Example 4: Create Architectural Plan

Example 5: Initialize GAIA.md

LLM-Based Fixing

Fix Code Prompt Template

Project Templates

Game Project Structure

API Project Structure

Testing Requirements

Dependencies