┌──────────────────┬─────────────────────────────────────────────────┐
│    Capacidade    │                   Descrição                    │
├──────────────────┼─────────────────────────────────────────────────┤
│ Ler Ficheiros    │ Ler código existente para entender contexto     │
│ Escrever Fich.   │ Criar novos ficheiros ou modificar existentes   │
│ Executar Código  │ Correr scripts, testes, build                   │
│ Pesquisar Web    │ Encontrar soluções e documentação               │
│ Memória          │ Lembrar decisões e contexto do projeto         │
│ Planeamento      │ Decompor tarefas complexas em subtarefas      │
│ Debugging        │ Identificar e corrigir erros                  │
│ Versionamento    │ Git operations (commit, branch, merge)        │
└──────────────────┴─────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    AGENTE PROGRAMADOR WEB                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐         │
│  │   LLM Core  │◄──►│  Memória   │◄──►│  Planeador  │         │
│  │  (Ollama)   │    │ (Contexto) │    │ (Tarefas)   │         │
│  └─────────────┘    └─────────────┘    └─────────────┘         │
│         │                  │                   │                │
│         ▼                  ▼                   ▼                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    GESTOR DE FERRAMENTAS                 │   │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐       │   │
│  │  │FileSystem│ │ Terminal │ │   Web   │ │   Git   │       │   │
│  │  │ Tool    │ │  Tool   │ │ Search  │ │  Tool   │       │   │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                              │                                  │
│                              ▼                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                     SISTEMA DE FICHEIROS                  │   │
│  │           (Projeto que está a ser desenvolvido)          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

import os
from pathlib import Path
from typing import Optional

class FileSystemTool:
    """Ferramenta para operações no sistema de ficheiros."""

    def __init__(self, base_path: str = "."):
        self.base_path = Path(base_path).resolve()

    def _resolve_path(self, path: str) -> Path:
        """Resolve e valida o caminho."""
        full_path = (self.base_path / path).resolve()
        # Segurança: não permitir sair do diretório base
        if not str(full_path).startswith(str(self.base_path)):
            raise ValueError("Caminho não permitido")
        return full_path

    def read_file(self, path: str) -> str:
        """Lê o conteúdo de um ficheiro."""
        full_path = self._resolve_path(path)
        if not full_path.exists():
            return f"Erro: Ficheiro '{path}' não existe"
        return full_path.read_text(encoding='utf-8')

    def write_file(self, path: str, content: str) -> str:
        """Escreve conteúdo num ficheiro."""
        full_path = self._resolve_path(path)
        full_path.parent.mkdir(parents=True, exist_ok=True)
        full_path.write_text(content, encoding='utf-8')
        return f"Ficheiro '{path}' criado/modificado com sucesso"

    def list_files(self, path: str = ".") -> str:
        """Lista ficheiros num diretório."""
        full_path = self._resolve_path(path)
        if not full_path.is_dir():
            return f"Erro: '{path}' não é um diretório"

        files = []
        for item in full_path.iterdir():
            prefix = "📁" if item.is_dir() else "📄"
            files.append(f"{prefix} {item.name}")

        return "\n".join(files) if files else "Diretório vazio"

    def delete_file(self, path: str) -> str:
        """Elimina um ficheiro."""
        full_path = self._resolve_path(path)
        if not full_path.exists():
            return f"Erro: Ficheiro '{path}' não existe"
        full_path.unlink()
        return f"Ficheiro '{path}' eliminado com sucesso"

    def create_directory(self, path: str) -> str:
        """Cria um diretório."""
        full_path = self._resolve_path(path)
        full_path.mkdir(parents=True, exist_ok=True)
        return f"Diretório '{path}' criado com sucesso"

# Uso
fs = FileSystemTool("/projetos/meu-projeto")
print(fs.list_files("src"))

import subprocess
from typing import Tuple

class TerminalTool:
    """Ferramenta para executar comandos no terminal."""

    # Comandos permitidos (whitelist para segurança)
    ALLOWED_COMMANDS = {
        'npm', 'yarn', 'node', 'npx',
        'python', 'pip', 'poetry',
        'git', 'ls', 'cat', 'echo',
        'pytest', 'jest', 'mocha',
        'tsc', 'eslint', 'prettier',
        'docker', 'docker-compose'
    }

    def __init__(self, working_dir: str = "."):
        self.working_dir = working_dir

    def _is_allowed(self, command: str) -> bool:
        """Verifica se o comando é permitido."""
        cmd_name = command.split()[0] if command else ""
        return cmd_name in self.ALLOWED_COMMANDS

    def execute(self, command: str, timeout: int = 60) -> Tuple[str, bool]:
        """
        Executa um comando no terminal.

        Retorna: (output, success)
        """
        if not self._is_allowed(command):
            return f"Comando '{command}' não é permitido por segurança", False

        try:
            result = subprocess.run(
                command,
                shell=True,
                capture_output=True,
                text=True,
                timeout=timeout,
                cwd=self.working_dir
            )

            output = result.stdout + result.stderr
            success = result.returncode == 0

            return output.strip(), success

        except subprocess.TimeoutExpired:
            return f"Comando excedeu o tempo limite de {timeout}s", False
        except Exception as e:
            return f"Erro ao executar: {str(e)}", False

    def run_tests(self, test_framework: str = "pytest") -> Tuple[str, bool]:
        """Executa testes."""
        commands = {
            "pytest": "python -m pytest -v",
            "jest": "npm test",
            "mocha": "npm run test"
        }
        command = commands.get(test_framework, test_framework)
        return self.execute(command)

    def install_dependencies(self, package_manager: str = "npm") -> Tuple[str, bool]:
        """Instala dependências."""
        commands = {
            "npm": "npm install",
            "yarn": "yarn install",
            "pip": "pip install -r requirements.txt"
        }
        command = commands.get(package_manager, package_manager)
        return self.execute(command, timeout=300)  # 5 min timeout

# Uso
terminal = TerminalTool("/projetos/meu-projeto")
output, success = terminal.execute("npm run build")

from langchain_community.llms import Ollama
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool
from typing import List, Dict

class WebProgrammerAgent:
    """Agente programador web completo."""

    def __init__(self, project_path: str, model: str = "llama3.1:8b"):
        self.project_path = project_path
        self.llm = Ollama(model=model)
        self.fs_tool = FileSystemTool(project_path)
        self.terminal_tool = TerminalTool(project_path)
        self.memory: List[Dict] = []

        # Criar ferramentas LangChain
        self.tools = self._create_tools()

        # Inicializar agente
        self.agent = initialize_agent(
            self.tools,
            self.llm,
            agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
            verbose=True,
            max_iterations=10,
            early_stopping_method="generate"
        )

    def _create_tools(self) -> List[Tool]:
        """Cria as ferramentas disponíveis para o agente."""
        return [
            Tool(
                name="read_file",
                description="Lê o conteúdo de um ficheiro. Input: caminho do ficheiro.",
                func=self.fs_tool.read_file
            ),
            Tool(
                name="write_file",
                description="Escreve conteúdo num ficheiro. Input JSON: {path, content}.",
                func=lambda x: self._handle_write(x)
            ),
            Tool(
                name="list_files",
                description="Lista ficheiros num diretório. Input: caminho do diretório.",
                func=self.fs_tool.list_files
            ),
            Tool(
                name="execute_command",
                description="Executa um comando no terminal. Input: comando.",
                func=lambda x: self.terminal_tool.execute(x)[0]
            ),
            Tool(
                name="run_tests",
                description="Executa os testes do projeto. Input: framework (pytest/jest).",
                func=lambda x: self.terminal_tool.run_tests(x)[0]
            )
        ]

    def _handle_write(self, input_str: str) -> str:
        """Processa input para write_file."""
        import json
        try:
            data = json.loads(input_str)
            return self.fs_tool.write_file(data["path"], data["content"])
        except:
            return "Input inválido. Use JSON: {path: '...', content: '...'}"

    def develop(self, requirement: str) -> str:
        """
        Desenvolve uma funcionalidade baseada num requisito.

        Args:
            requirement: Descrição da funcionalidade em linguagem natural

        Returns:
            Resultado da implementação
        """
        # Adicionar contexto à memória
        self.memory.append({"role": "user", "content": requirement})

        # Prompt do sistema
        system_prompt = f"""
        És um programador web experiente. O teu objetivo é implementar
        funcionalidades baseadas nos requisitos do utilizador.

        Estás a trabalhar no projeto em: {self.project_path}

        Usa as ferramentas disponíveis para:
        1. Ler ficheiros existentes para entender o contexto
        2. Criar/modificar ficheiros conforme necessário
        3. Executar comandos para instalar dependências
        4. Correr testes para validar a implementação

        Segue as melhores práticas de desenvolvimento web.
        Documenta o código quando apropriado.
        Mantém o código limpo e organizado.
        """

        # Executar o agente
        result = self.agent.run(
            f"{system_prompt}\n\nRequisito: {requirement}"
        )

        return result

    def fix_bug(self, error_message: str) -> str:
        """
        Corrige um bug baseado na mensagem de erro.

        Args:
            error_message: Mensagem de erro ou descrição do bug

        Returns:
            Resultado da correção
        """
        return self.develop(f"Corrige o seguinte bug: {error_message}")

# Uso
agent = WebProgrammerAgent("/projetos/meu-site")

# Implementar uma funcionalidade
result = agent.develop("""
Cria uma página de login com:
- Formulário com email e password
- Validação de campos
- Botão de submit
- Estilos CSS modernos
- Lógica JavaScript para submissão
""")

print(result)

import pytest
from web_programmer_agent import WebProgrammerAgent, FileSystemTool, TerminalTool
import tempfile
import os

class TestFileSystemTool:
    """Testes para a ferramenta de sistema de ficheiros."""

    def setup_method(self):
        self.temp_dir = tempfile.mkdtemp()
        self.fs = FileSystemTool(self.temp_dir)

    def test_write_and_read_file(self):
        """Testa escrita e leitura de ficheiros."""
        result = self.fs.write_file("test.txt", "Olá mundo!")
        assert "sucesso" in result.lower()

        content = self.fs.read_file("test.txt")
        assert content == "Olá mundo!"

    def test_list_files(self):
        """Testa listagem de ficheiros."""
        self.fs.write_file("a.txt", "conteúdo a")
        self.fs.write_file("b.txt", "conteúdo b")

        listing = self.fs.list_files(".")
        assert "a.txt" in listing
        assert "b.txt" in listing

    def test_delete_file(self):
        """Testa eliminação de ficheiros."""
        self.fs.write_file("delete_me.txt", "para eliminar")
        result = self.fs.delete_file("delete_me.txt")
        assert "sucesso" in result.lower()

        content = self.fs.read_file("delete_me.txt")
        assert "não existe" in content.lower()

class TestWebProgrammerAgent:
    """Testes para o agente programador."""

    def setup_method(self):
        self.temp_dir = tempfile.mkdtemp()
        # Usar um mock do LLM para testes
        self.agent = WebProgrammerAgent(self.temp_dir)

    def test_agent_initialization(self):
        """Testa inicialização do agente."""
        assert self.agent.llm is not None
        assert len(self.agent.tools) > 0

    def test_develop_simple_feature(self):
        """Testa desenvolvimento de uma feature simples."""
        result = self.agent.develop("Cria um ficheiro index.html com 'Olá Mundo'")
        # Verificar que o ficheiro foi criado
        content = self.fs.read_file("index.html")
        assert "Olá Mundo" in content

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn

app = FastAPI(title="Web Programmer Agent API")

class DevelopRequest(BaseModel):
    requirement: str
    project_path: str = "/app/projects"

class DevelopResponse(BaseModel):
    result: str
    files_created: list
    success: bool

@app.post("/develop", response_model=DevelopResponse)
async def develop_feature(request: DevelopRequest):
    """
    Endpoint para desenvolver uma funcionalidade.
    """
    try:
        agent = WebProgrammerAgent(request.project_path)
        result = agent.develop(request.requirement)

        # Listar ficheiros criados/modificados
        fs = FileSystemTool(request.project_path)
        files = fs.list_files(".")

        return DevelopResponse(
            result=result,
            files_created=files.split("\n"),
            success=True
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health_check():
    """Verifica se a API está a funcionar."""
    return {"status": "healthy"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)