Code Development

from gaia.agents.base.agent import Agent
from gaia_agent_code.tools.cli_tools import CLIToolsMixin

class MyDevAgent(Agent, CLIToolsMixin):
    """Agent with CLI capabilities."""

    def _register_tools(self):
        # CLIToolsMixin provides:
        # - run_command(command: str) -> dict
        # - kill_process(pid: int) -> dict
        # - list_processes() -> dict
        pass

# Usage
agent = MyDevAgent()
result = agent.process_query("Run npm install and start the dev server")
# Agent executes: npm install && npm run dev

from gaia.agents.base.agent import Agent
from gaia_agent_code.tools.code_tools import CodeToolsMixin

class MyCodeAgent(Agent, CodeToolsMixin):
    """Agent with code generation."""

    def _register_tools(self):
        # CodeToolsMixin provides:
        # - generate_file(path: str, content: str) -> dict
        # - create_component(name: str, type: str) -> dict
        # - scaffold_project(template: str) -> dict
        pass

from gaia.agents.base.agent import Agent
from gaia.agents.tools.file_io_tools import FileIOToolsMixin

class MyAgent(Agent, FileIOToolsMixin):
    """Agent with file I/O."""

    def _register_tools(self):
        # FileIOToolsMixin provides:
        # - read_file(path: str) -> dict
        # - write_file(path: str, content: str) -> dict
        # - delete_file(path: str) -> dict
        # - list_directory(path: str) -> dict
        # - create_directory(path: str) -> dict
        # All with security validation!
        pass

from gaia.agents.base.agent import Agent
from gaia_agent_code.tools.validation_tools import ValidationToolsMixin

class MyAgent(Agent, ValidationToolsMixin):
    """Agent with validation."""

    def _register_tools(self):
        # ValidationToolsMixin provides:
        # - validate_syntax(file: str, language: str) -> dict
        # - lint_code(file: str) -> dict
        # - check_types(file: str) -> dict
        pass

from gaia.agents.base.agent import Agent
from gaia_agent_code.tools.error_fixing import ErrorFixingMixin

class MyAgent(Agent, ErrorFixingMixin):
    """Agent with error fixing."""

    def _register_tools(self):
        # ErrorFixingMixin provides:
        # - detect_errors(file: str) -> dict
        # - fix_error(file: str, error: str) -> dict
        # - suggest_fix(error_message: str) -> dict
        pass

# Usage
agent = MyAgent()
result = agent.process_query(
    "Fix the TypeError in app.py and make sure tests pass"
)

from gaia.agents.base.agent import Agent
from gaia_agent_code.tools.testing import TestingMixin

class MyAgent(Agent, TestingMixin):
    """Agent with testing."""

    def _register_tools(self):
        # TestingMixin provides:
        # - run_tests(path: str, framework: str) -> dict
        # - generate_tests(file: str) -> dict
        # - check_coverage() -> dict
        pass

from gaia.agents.base.agent import Agent
from gaia_agent_code.tools.prisma_tools import PrismaToolsMixin

class MyAgent(Agent, PrismaToolsMixin):
    """Agent with Prisma support."""

    def _register_tools(self):
        # PrismaToolsMixin provides:
        # - init_prisma(database: str) -> dict
        # - generate_schema(models: list) -> dict
        # - run_migration(name: str) -> dict
        pass

from gaia.agents.base.agent import Agent
from gaia_agent_code.tools.typescript_tools import TypeScriptToolsMixin

class MyAgent(Agent, TypeScriptToolsMixin):
    """Agent with TypeScript support."""

    def _register_tools(self):
        # TypeScriptToolsMixin provides:
        # - init_typescript(project: str) -> dict
        # - compile_typescript(file: str) -> dict
        # - check_types(file: str) -> dict
        pass

from gaia.agents.base.agent import Agent
from gaia_agent_code.tools.web_dev_tools import WebToolsMixin

class MyAgent(Agent, WebToolsMixin):
    """Agent with web dev tools."""

    def _register_tools(self):
        # WebToolsMixin provides:
        # - create_react_app(name: str) -> dict
        # - generate_component(name: str, framework: str) -> dict
        # - setup_tailwind() -> dict
        # - create_api_route(path: str) -> dict
        pass

# Usage
agent = MyAgent()
result = agent.process_query(
    "Create a React app with TypeScript, Tailwind, and a login component"
)