Cómo trabaja un agente de código

import pathlib, re, shlex, subprocess
import anthropic

MODEL = "claude-sonnet-5-5"
client = anthropic.Anthropic()
RAIZ = pathlib.Path(".").resolve()
PERMITIDOS = ("pytest", "ruff", "python -m pytest")

def ruta_segura(ruta: str) -> pathlib.Path:
    p = (RAIZ / ruta).resolve()
    if not p.is_relative_to(RAIZ):
        raise ValueError(f"{ruta} está fuera del repositorio")
    return p

def leer_archivo(ruta: str, desde: int = 1, hasta: int = 400) -> str:
    lineas = ruta_segura(ruta).read_text(encoding="utf-8").splitlines()
    return "\n".join(f"{i:>5}  {l}" for i, l in enumerate(lineas, 1) if desde <= i <= hasta)

def buscar(patron: str, max_resultados: int = 50) -> str:
    rx, hallazgos = re.compile(patron), []
    for f in RAIZ.rglob("*.py"):
        for i, linea in enumerate(f.read_text(encoding="utf-8", errors="ignore").splitlines(), 1):
            if rx.search(linea):
                hallazgos.append(f"{f.relative_to(RAIZ)}:{i}: {linea.strip()}")
                if len(hallazgos) >= max_resultados:
                    return "\n".join(hallazgos) + "\n[resultados recortados]"
    return "\n".join(hallazgos) or "Sin resultados."

def editar_archivo(ruta: str, actual: str, nuevo: str) -> str:
    p = ruta_segura(ruta)
    texto = p.read_text(encoding="utf-8")
    n = texto.count(actual)
    if n != 1:
        raise ValueError(f"el fragmento aparece {n} veces; debe aparecer exactamente una")
    p.write_text(texto.replace(actual, nuevo), encoding="utf-8")
    return f"Editado {ruta}."

def ejecutar(comando: str) -> str:
    if not comando.startswith(PERMITIDOS):
        raise ValueError(f"comando no permitido; usa uno de {PERMITIDOS}")
    r = subprocess.run(shlex.split(comando), cwd=RAIZ, capture_output=True, text=True, timeout=300)
    return f"código de salida {r.returncode}\n{(r.stdout + r.stderr)[-8000:]}"

HANDLERS = {"leer_archivo": leer_archivo, "buscar": buscar,
            "editar_archivo": editar_archivo, "ejecutar": ejecutar}

def esquema(props: dict, requeridos: list) -> dict:
    return {"type": "object", "properties": props, "required": requeridos}

S = {"type": "string"}
TOOLS = [
    {"name": "leer_archivo", "description": "Lee un archivo del repositorio con números de línea. Usa desde/hasta para archivos largos.",
     "input_schema": esquema({"ruta": S, "desde": {"type": "integer"}, "hasta": {"type": "integer"}}, ["ruta"])},
    {"name": "buscar", "description": "Busca una expresión regular en los .py del repositorio. Devuelve archivo:línea.",
     "input_schema": esquema({"patron": S}, ["patron"])},
    {"name": "editar_archivo", "description": "Sustituye un fragmento exacto, que debe aparecer una sola vez, por otro. Lee el archivo antes.",
     "input_schema": esquema({"ruta": S, "actual": S, "nuevo": S}, ["ruta", "actual", "nuevo"])},
    {"name": "ejecutar", "description": f"Ejecuta tests o el linter. Comandos permitidos: {', '.join(PERMITIDOS)}.",
     "input_schema": esquema({"comando": S}, ["comando"])},
]

SYSTEM = ("Eres un agente de código. Lee antes de editar. Haz cambios pequeños. "
          "Ejecuta los tests tras cada cambio y no termines si fallan. "
          "Al acabar, resume qué cambiaste y cómo lo verificaste.")

def agente(tarea: str, max_pasos: int = 40) -> str:
    messages = [{"role": "user", "content": tarea}]
    for _ in range(max_pasos):
        resp = client.messages.create(model=MODEL, max_tokens=4096, system=SYSTEM,
                                      tools=TOOLS, messages=messages)
        messages.append({"role": "assistant", "content": resp.content})
        if resp.stop_reason == "end_turn":
            return "".join(b.text for b in resp.content if b.type == "text")
        if resp.stop_reason == "pause_turn":
            continue
        if resp.stop_reason != "tool_use":
            raise RuntimeError(f"stop_reason inesperado: {resp.stop_reason}")
        resultados = []
        for b in resp.content:
            if b.type != "tool_use":
                continue
            try:
                salida, error = HANDLERS[b.name](**b.input), False
            except Exception as e:
                salida, error = f"Error: {e}", True
            resultados.append({"type": "tool_result", "tool_use_id": b.id,
                               "content": salida, "is_error": error})
        messages.append({"role": "user", "content": resultados})
    raise RuntimeError("Se alcanzó el límite de pasos sin terminar.")

if __name__ == "__main__":
    print(agente("La función slugify falla con tildes. Arréglala y añade un test."))

import Anthropic from "@anthropic-ai/sdk";

const MODEL = "claude-sonnet-5-5";
const client = new Anthropic();

// TOOLS, SYSTEM y las funciones de cada herramienta son equivalentes a la versión en Python.
declare const TOOLS: Anthropic.Tool[];
declare const SYSTEM: string;
declare const HANDLERS: Record<string, (input: any) => Promise<string>>;

export async function agente(tarea: string, maxPasos = 40): Promise<string> {
  const messages: Anthropic.MessageParam[] = [{ role: "user", content: tarea }];
  for (let paso = 0; paso < maxPasos; paso++) {
    const resp = await client.messages.create({
      model: MODEL, max_tokens: 4096, system: SYSTEM, tools: TOOLS, messages,
    });
    messages.push({ role: "assistant", content: resp.content });
    if (resp.stop_reason === "end_turn") {
      return resp.content.flatMap((b) => (b.type === "text" ? [b.text] : [])).join("");
    }
    if (resp.stop_reason === "pause_turn") continue;
    if (resp.stop_reason !== "tool_use") throw new Error(`stop_reason inesperado: ${resp.stop_reason}`);
    const resultados: Anthropic.ToolResultBlockParam[] = [];
    for (const b of resp.content) {
      if (b.type !== "tool_use") continue;
      try {
        resultados.push({ type: "tool_result", tool_use_id: b.id, content: await HANDLERS[b.name](b.input) });
      } catch (e) {
        resultados.push({ type: "tool_result", tool_use_id: b.id, content: `Error: ${e}`, is_error: true });
      }
    }
    messages.push({ role: "user", content: resultados });
  }
  throw new Error("Se alcanzó el límite de pasos sin terminar.");
}