J'ai construit mon propre Devin en 200 lignes Python

# mini_devin.py
import os
import subprocess
import json
from pathlib import Path
from anthropic import Anthropic

client = Anthropic()
REPO = Path(".").resolve()
MAX_ITERATIONS = 30

TOOLS = [
    {
        "name": "read_file",
        "description": "Read a file from the repo",
        "input_schema": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"],
        },
    },
    {
        "name": "write_file",
        "description": "Write or overwrite a file",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {"type": "string"},
                "content": {"type": "string"},
            },
            "required": ["path", "content"],
        },
    },
    {
        "name": "run_bash",
        "description": "Run a shell command (must be safe, no rm -rf)",
        "input_schema": {
            "type": "object",
            "properties": {"cmd": {"type": "string"}},
            "required": ["cmd"],
        },
    },
    {
        "name": "grep",
        "description": "Search recursively for a pattern in the repo",
        "input_schema": {
            "type": "object",
            "properties": {"pattern": {"type": "string"}, "glob": {"type": "string"}},
            "required": ["pattern"],
        },
    },
    {
        "name": "finish",
        "description": "Call when the task is complete",
        "input_schema": {
            "type": "object",
            "properties": {"summary": {"type": "string"}},
            "required": ["summary"],
        },
    },
]

DENY_PATTERNS = ["rm -rf", "git reset --hard", "git checkout --", "sudo", "> /dev/"]

def tool_read_file(path: str) -> str:
    p = REPO / path
    if not p.is_file():
        return f"ERROR: {path} not found"
    return p.read_text()[:8000]

def tool_write_file(path: str, content: str) -> str:
    p = REPO / path
    p.parent.mkdir(parents=True, exist_ok=True)
    p.write_text(content)
    return f"Wrote {len(content)} chars to {path}"

def tool_run_bash(cmd: str) -> str:
    if any(d in cmd for d in DENY_PATTERNS):
        return f"REFUSED: denied pattern in cmd"
    try:
        result = subprocess.run(cmd, shell=True, cwd=REPO, capture_output=True, text=True, timeout=60)
        return f"exit={result.returncode}\nstdout:\n{result.stdout[:2000]}\nstderr:\n{result.stderr[:1000]}"
    except subprocess.TimeoutExpired:
        return "ERROR: timeout"

def tool_grep(pattern: str, glob: str = "**/*") -> str:
    cmd = f"grep -rn --include='{glob}' '{pattern}' ."
    result = subprocess.run(cmd, shell=True, cwd=REPO, capture_output=True, text=True)
    return result.stdout[:3000] if result.stdout else "no matches"

TOOL_IMPL = {
    "read_file": tool_read_file,
    "write_file": tool_write_file,
    "run_bash": tool_run_bash,
    "grep": tool_grep,
}

def agent_loop(task: str):
    messages = [{"role": "user", "content": f"Task: {task}\n\nUse the tools to complete it. Call `finish` when done."}]
    system = """You are mini-Devin, a focused coding agent.
- Read files before editing them.
- Run tests after each code change (pytest, jest, cargo test — auto-detect).
- If tests fail, fix and retry (max 3 times per error).
- Call `finish` with a summary when done, or if blocked.
- Never touch .env* or delete files."""

    for iteration in range(MAX_ITERATIONS):
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=4096,
            system=system,
            tools=TOOLS,
            messages=messages,
        )

        if response.stop_reason == "tool_use":
            tool_uses = [c for c in response.content if c.type == "tool_use"]
            messages.append({"role": "assistant", "content": response.content})

            tool_results = []
            for tu in tool_uses:
                if tu.name == "finish":
                    print(f"DONE: {tu.input.get('summary', '')}")
                    return
                impl = TOOL_IMPL.get(tu.name)
                if not impl:
                    result = f"ERROR: unknown tool {tu.name}"
                else:
                    result = impl(**tu.input)
                tool_results.append({"type": "tool_result", "tool_use_id": tu.id, "content": result})
            messages.append({"role": "user", "content": tool_results})
        else:
            print(response.content[0].text if response.content else "(empty)")
            return

    print(f"STOPPED after {MAX_ITERATIONS} iterations (max reached)")

if __name__ == "__main__":
    import sys
    task = " ".join(sys.argv[1:]) or "Fix the failing tests"
    agent_loop(task)