llamagent 0.1.0__py3-none-any.whl

llamagent/__init__.py

@@ -0,0 +1 @@
+"""llamagent : un agent de code minimal autour d'Ollama."""

llamagent/agent.py

@@ -0,0 +1,124 @@
+"""La boucle agentique : le cœur de llamagent.
+
+    tant que le modèle demande des outils :
+        exécuter chaque outil demandé
+        ajouter le résultat à la conversation
+        rappeler le modèle
+    sinon : renvoyer sa réponse finale
+
+La boucle ne connaît aucun outil en particulier : elle passe par le registre
+de tools.py. Elle ne parle pas non plus directement à Ollama : on lui donne
+une fonction `chat`, ce qui permet de la tester avec un faux modèle.
+"""
+
+import json
+import os
+import platform
+from pathlib import Path
+from typing import Callable
+
+from llamagent import ui
+from llamagent.config import MAX_OUTPUT_CHARS, MAX_TOURS
+from llamagent.guards import is_allowed_command, truncate
+from llamagent.tools import TOOLS, ToolContext, execute_tool, tool_schemas
+
+# Une fonction qui reçoit (messages, schémas des outils) et renvoie le message
+# de l'assistant. En vrai : llm.chat. Dans les tests : un faux modèle.
+ChatFunction = Callable[[list[dict], list[dict]], dict]
+
+
+# ─────────────────────────── Prompt système ───────────────────────────
+
+
+def build_system_prompt(template: str, workdir: Path, skills: dict[str, str], project_instructions: str = "") -> str:
+    """Remplit le modèle de prompt (prompts/AGENT.md) avec l'environnement réel.
+
+    Si le projet a un fichier AGENTS.md (étape 9), son contenu est ajouté à la fin.
+    """
+    shell = "cmd.exe" if os.name == "nt" else "/bin/sh"
+    skills_text = "\n".join(f"- {name} : {description}" for name, description in skills.items())
+    # str.replace plutôt que str.format : le Markdown peut contenir des { }.
+    prompt = (
+        template.replace("{os}", platform.system())
+        .replace("{shell}", shell)
+        .replace("{workdir}", str(workdir))
+        .replace("{skills}", skills_text or "(aucune)")
+    )
+    if project_instructions:
+        prompt += f"\n\n## Instructions du projet (AGENTS.md)\n{project_instructions}"
+    return prompt
+
+
+# ─────────────────────────── La boucle ───────────────────────────
+
+
+def describe_harness(name: str, arguments, ctx: ToolContext, repeated: bool) -> str:
+    """Ce que le harness fait de la demande du modèle, en une phrase (étape 17).
+
+    Seulement pour l'affichage : on rend visible le rôle du harness entre
+    le modèle, qui demande, et l'outil, qui exécute.
+    """
+    if repeated:
+        return "appel identique au précédent : pas exécuté, le modèle est prévenu"
+    if name not in TOOLS:
+        return "outil inconnu : l'erreur est renvoyée au modèle"
+    if name == "edit_file":
+        return "vérifie le chemin, montre le diff et demande ta confirmation"
+    if name == "run_command":
+        command = arguments.get("command", "") if isinstance(arguments, dict) else ""
+        if is_allowed_command(command, ctx.allowed_commands):
+            return "commande autorisée : lancée sans confirmation"
+        return "demande ta confirmation avant de lancer la commande"
+    if name == "load_skill":
+        return "vérifie que la skill existe et la charge"
+    return f"vérifie le chemin et exécute {name}"
+
+
+def run_turn(chat: ChatFunction, messages: list[dict], ctx: ToolContext, max_tours: int = MAX_TOURS) -> str:
+    """Traite le dernier message utilisateur et renvoie la réponse finale.
+
+    `messages` est modifiée sur place : on y ajoute les messages de
+    l'assistant et les résultats des outils, pour garder tout l'historique.
+    L'affichage montre chaque tour : le modèle demande, le harness décide,
+    l'outil répond.
+    """
+    previous_call = None
+    for tour in range(1, max_tours + 1):
+        print(ui.tour_header(tour))
+        reply = chat(messages, tool_schemas())
+        # 1) On garde le message de l'assistant TEL QUEL, avec ses tool_calls :
+        #    au prochain appel, le modèle doit voir ce qu'il a demandé.
+        messages.append(reply)
+
+        tool_calls = reply.get("tool_calls") or []
+        if not tool_calls:
+            print(ui.role_line("modèle", "répond sans demander d'outil : fin de la boucle"))
+            print(ui.answer_header(tour))
+            return reply.get("content", "")
+
+        for call in tool_calls:
+            name = call["function"]["name"]
+            arguments = call["function"].get("arguments", {})
+            print(ui.model_asks(name, arguments))
+
+            # Détection de boucle : le même appel deux fois de suite ne
+            # donnera pas un résultat différent, on le signale au modèle.
+            signature = (name, json.dumps(arguments, sort_keys=True, ensure_ascii=False))
+            repeated = signature == previous_call
+            print(ui.role_line("harness", describe_harness(name, arguments, ctx, repeated)))
+            if repeated:
+                result = (
+                    f"Erreur : tu viens déjà d'appeler {name} avec exactement ces arguments. "
+                    "Le résultat sera le même : change d'approche ou donne ta réponse finale."
+                )
+            else:
+                result = execute_tool(name, arguments, ctx)
+            previous_call = signature
+
+            shortened = truncate(result, MAX_OUTPUT_CHARS)
+            print(ui.tool_result(shortened, truncated=len(shortened) < len(result)))
+            # 2) Puis le résultat de l'outil, avec le rôle "tool".
+            messages.append({"role": "tool", "tool_name": name, "content": shortened})
+
+    print(ui.role_line("harness", f"limite de {max_tours} tours atteinte : la boucle s'arrête", ui.RED))
+    return f"Arrêt : limite de {max_tours} tours atteinte sans réponse finale."

llamagent/cli.py

@@ -0,0 +1,119 @@
+"""Point d'entrée de la ligne de commande : `llamagent`.
+
+    llamagent                          # mode conversation dans le dossier courant
+    llamagent "corrige le bug..."      # une seule demande, puis on quitte
+    llamagent -m qwen3.5:9b -t 0.5     # options : voir llamagent --help
+
+C'est ici qu'on assemble le harness : configuration, session (prompt
+système, outils, garde-fous), commandes /..., puis la boucle agentique.
+Tout l'affichage passe par ui.py (étape 17).
+"""
+
+import argparse
+import os
+from importlib.metadata import version
+
+import requests
+
+from llamagent import ui
+from llamagent.commands import execute_command
+from llamagent.config import PROJECT_DIR_NAME, load_config
+from llamagent.context import compact, needs_compaction
+from llamagent.history import find_session, resume_session, save_session
+from llamagent.session import Session, create_session, find_mentions, load_project_instructions
+from llamagent.tools import available_skills
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(prog="llamagent", description="Un agent de code minimal autour d'Ollama.")
+    parser.add_argument("demande", nargs="*", help="demande à traiter avant de quitter (sinon : mode conversation)")
+    parser.add_argument("-m", "--model", help="modèle Ollama, ex. qwen3.5:4b")
+    parser.add_argument("-t", "--temperature", type=float, help="température, ex. 0.2")
+    parser.add_argument("--num-ctx", type=int, help="taille du contexte en tokens, ex. 8192")
+    parser.add_argument("--url", help="adresse du serveur Ollama")
+    parser.add_argument("-c", "--continue", dest="resume", action="store_true", help="reprendre la dernière conversation du projet")
+    parser.add_argument("--version", action="version", version=f"llamagent {version('llamagent')}")
+    return parser.parse_args(argv)
+
+
+def context_status(session: Session) -> str:
+    """La jauge de contexte affichée sous chaque réponse."""
+    c = session.config
+    return ui.context_gauge(c.model, session.context_tokens, c.num_ctx, session.context_estimated)
+
+
+def handle_request(session: Session, text: str) -> None:
+    """Envoie une demande à l'agent et affiche sa réponse."""
+    for path in find_mentions(text):
+        print(ui.info(f"@{path} joint au message"))
+    try:
+        answer = session.ask(text)
+    except requests.RequestException as error:
+        print(ui.error(f"Erreur de communication avec Ollama : {error}"))
+        return
+    print(ui.answer(answer))
+    print("\n" + context_status(session))
+    # Étape 16 : entre deux demandes, on compacte si le contexte est presque plein.
+    if needs_compaction(session):
+        print(ui.warning("Contexte presque plein : compactage automatique de la conversation..."))
+        try:
+            compact(session)
+            print(context_status(session))
+        except requests.RequestException as error:
+            print(ui.error(f"Compactage impossible : {error}"))
+    # Étape 15 : la conversation est sauvegardée après chaque demande.
+    save_session(session)
+
+
+def project_summary(session: Session) -> str:
+    """Une ligne qui résume ce que le projet apporte : AGENTS.md, skills, réglages."""
+    workdir = session.config.workdir
+    has_instructions = bool(load_project_instructions(workdir))
+    parts = ["AGENTS.md"] if has_instructions else []
+    parts.append(f"{len(available_skills(session.ctx.skills_dirs))} skills")
+    if (workdir / PROJECT_DIR_NAME / "config.toml").is_file():
+        parts.append("config.toml")
+    if not has_instructions:
+        parts.append("/init pour préparer le projet")
+    return ui.symbol(" · ", " - ").join(parts)
+
+
+def main() -> None:
+    if os.name == "nt":
+        os.system("")  # active les codes ANSI (couleurs) dans les consoles Windows
+
+    args = parse_args()
+    config = load_config({"model": args.model, "temperature": args.temperature, "num_ctx": args.num_ctx, "url": args.url})
+    session = create_session(config, confirm=ui.confirm)
+    session.waiting = ui.thinking  # animation pendant l'attente du modèle
+
+    rows = [("modèle", config.model), ("serveur", config.ollama_url), ("dossier", str(config.workdir)), ("projet", project_summary(session))]
+    if args.resume:
+        data = find_session(config.workdir, "1")
+        if data is None:
+            rows.append(("reprise", "aucune conversation sauvegardée : nouvelle conversation"))
+        else:
+            resume_session(session, data)
+            rows.append(("reprise", f"{data.get('title', '')} ({len(data['messages'])} messages)"))
+    print(ui.banner(rows))
+
+    try:
+        # Mode « une seule demande » : la demande est passée en argument.
+        if args.demande:
+            handle_request(session, " ".join(args.demande))
+            return
+
+        while True:
+            text = input(ui.prompt()).strip()
+            if text in ("/quit", "/exit"):
+                break
+            if text.startswith("/"):
+                print(ui.indent(execute_command(session, text)))
+            elif text:
+                handle_request(session, text)
+    except (KeyboardInterrupt, EOFError):
+        print("\n" + ui.style("  Au revoir.", ui.GREY))
+
+
+if __name__ == "__main__":
+    main()

llamagent/commands.py

@@ -0,0 +1,250 @@
+"""Les commandes /... tapées par l'utilisateur (et non par le modèle).
+
+Même principe que le registre d'outils : un dictionnaire
+nom -> (fonction, aide). Ajouter une commande ne touche ni à la boucle
+ni à cli.py. Chaque fonction reçoit la session et le texte tapé après la
+commande, et renvoie le texte à afficher.
+"""
+
+from typing import Callable
+
+import requests
+
+from llamagent import llm
+from llamagent.context import compact, context_report
+from llamagent.config import PROJECT_DIR_NAME, PROJECT_INSTRUCTIONS
+from llamagent.guards import SHELL_OPERATORS, GuardError
+from llamagent.history import delete_session, find_session, list_sessions, resume_session, save_session
+from llamagent.session import Session
+from llamagent.tools import available_skills, load_skill
+
+
+def cmd_help(session: Session, arg: str) -> str:
+    lines = [f"{name:<9} {description}" for name, (_, description) in COMMANDS.items()]
+    return "\n".join(lines + [f"{'/quit':<9} quitter", "", "@chemin dans une demande : joint le contenu du fichier."])
+
+
+# Fichiers créés par /init dans le projet : chemin relatif -> contenu.
+INIT_FILES = {
+    PROJECT_INSTRUCTIONS: """# Instructions du projet
+
+- But du projet : ...
+- Lancer le projet : ...
+- Lancer les tests : python -m pytest -q
+- Conventions de code : ...
+- Fichiers ou dossiers à ne jamais modifier : ...
+""",
+    f"{PROJECT_DIR_NAME}/config.toml": """# Réglages de llamagent pour ce projet (ils remplacent ~/.llamagent/config.toml).
+# Retire le # devant une ligne pour l'activer.
+# model = "qwen3.5:4b"
+# temperature = 0.2
+# num_ctx = 8192
+# allowed_commands = ["python -m pytest", "git status", "git diff"]
+""",
+    # Les conversations sauvegardées contiennent le contenu des fichiers lus :
+    # elles ne doivent pas finir dans le dépôt git du projet.
+    f"{PROJECT_DIR_NAME}/.gitignore": "sessions/\n",
+    f"{PROJECT_DIR_NAME}/skills/LISEZMOI.txt": """Skills de ce projet : un fichier .md par skill, par exemple deployer.md.
+
+Format :
+
+---
+description: Une ligne qui dit quand utiliser cette skill.
+---
+# Titre
+
+1. Première étape de la méthode.
+2. ...
+
+Le prompt système ne contient que le nom et la description de chaque skill.
+Le modèle charge le contenu avec load_skill quand la demande correspond.
+Une skill de ce dossier remplace une skill globale du même nom.
+Ce fichier .txt n'est pas une skill : il est ignoré.
+""",
+}
+
+
+def cmd_init(session: Session, arg: str) -> str:
+    workdir = session.config.workdir
+    # On ne remplace jamais un fichier existant : seuls les manquants sont créés.
+    missing = [rel for rel in INIT_FILES if not (workdir / rel).exists()]
+    if not missing:
+        return "Ce projet est déjà initialisé : rien à créer."
+    listing = "\n".join(f"  {rel}" for rel in missing)
+    if not session.ctx.confirm(f"Fichiers à créer :\n{listing}\nLes créer dans {workdir} ?"):
+        return "Rien n'a été créé."
+    for rel in missing:
+        path = workdir / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(INIT_FILES[rel], encoding="utf-8")
+    # Le prompt système est reconstruit pour tenir compte d'AGENTS.md,
+    # sans effacer la conversation en cours.
+    session.messages[0] = {"role": "system", "content": session.system_prompt()}
+    return f"Créé :\n{listing}\nComplète AGENTS.md, puis ajoute tes skills dans {PROJECT_DIR_NAME}/skills/."
+
+
+def cmd_config(session: Session, arg: str) -> str:
+    c = session.config
+    return (
+        f"modèle         : {c.model}\n"
+        f"serveur        : {c.ollama_url}\n"
+        f"température    : {c.temperature}\n"
+        f"contexte       : {c.num_ctx} tokens\n"
+        f"dossier        : {c.workdir}\n"
+        f"sans confirmer : {', '.join(session.ctx.allowed_commands) or 'aucune commande'}"
+    )
+
+
+def cmd_models(session: Session, arg: str) -> str:
+    models = llm.list_models(session.config)
+    return "\n".join(("* " if name == session.config.model else "  ") + name for name in models) or "(aucun modèle)"
+
+
+def cmd_model(session: Session, arg: str) -> str:
+    if not arg:
+        return f"Modèle actuel : {session.config.model}"
+    models = llm.list_models(session.config)
+    # « qwen3.5 » désigne « qwen3.5:latest » pour Ollama.
+    name = arg if arg in models else f"{arg}:latest"
+    if name not in models:
+        return f"Modèle inconnu : {arg}. Tape /models pour voir les modèles installés."
+    session.update(model=name)
+    return f"Modèle : {name} (la conversation continue avec ce modèle)"
+
+
+def cmd_temp(session: Session, arg: str) -> str:
+    if not arg:
+        return f"Température actuelle : {session.config.temperature}"
+    try:
+        value = float(arg)
+    except ValueError:
+        return "Usage : /temp 0.2"
+    if not 0 <= value <= 2:
+        return "La température doit être comprise entre 0 et 2."
+    session.update(temperature=value)
+    return f"Température : {value}"
+
+
+def cmd_ctx(session: Session, arg: str) -> str:
+    if not arg:
+        return f"Contexte : {session.config.num_ctx} tokens"
+    try:
+        value = int(arg)
+    except ValueError:
+        return "Usage : /ctx 8192"
+    if not 2048 <= value <= 131072:
+        return "Le contexte doit être compris entre 2048 et 131072 tokens."
+    session.update(num_ctx=value)
+    return f"Contexte : {value} tokens (plus de contexte = plus de VRAM utilisée)"
+
+
+def cmd_skills(session: Session, arg: str) -> str:
+    skills = available_skills(session.ctx.skills_dirs)
+    return "\n".join(f"{name} : {description}" for name, description in skills.items()) or "(aucune skill)"
+
+
+def cmd_skill(session: Session, arg: str) -> str:
+    if not arg:
+        return "Usage : /skill nom (voir /skills)"
+    try:
+        content = load_skill(session.ctx, arg)
+    except GuardError as error:
+        return str(error)
+    # Ajoutée à la conversation : le modèle la verra dès la prochaine demande.
+    session.messages.append({"role": "user", "content": f"Pour la suite, suis les instructions de la skill « {arg} » :\n\n{content}"})
+    return f"Skill {arg} chargée dans la conversation."
+
+
+def cmd_clear(session: Session, arg: str) -> str:
+    session.reset()
+    return "Conversation effacée. Prompt système, skills et AGENTS.md relus."
+
+
+def cmd_sessions(session: Session, arg: str) -> str:
+    sessions = list_sessions(session.config.workdir)
+    if not sessions:
+        return "Aucune conversation sauvegardée dans ce projet."
+    lines = []
+    for number, data in enumerate(sessions, start=1):
+        current = "*" if data["id"] == session.session_id else " "
+        date = data.get("updated", "?").replace("T", " ")[:16]
+        lines.append(f"{current}{number:>3}. {date}  {len(data.get('messages', [])):>3} messages  {data.get('title', '')}")
+    return "\n".join(lines + ["", "/resume <numéro> pour reprendre, /delete <numéro> pour supprimer."])
+
+
+def cmd_resume(session: Session, arg: str) -> str:
+    # Sans argument : la conversation la plus récente.
+    data = find_session(session.config.workdir, arg or "1")
+    if data is None:
+        return f"Conversation introuvable : {arg}. Tape /sessions pour la liste."
+    resume_session(session, data)
+    return f"Conversation reprise : {data.get('title', '')} ({len(data['messages'])} messages)."
+
+
+def cmd_delete(session: Session, arg: str) -> str:
+    if not arg:
+        return "Usage : /delete <numéro> (voir /sessions)"
+    data = find_session(session.config.workdir, arg)
+    if data is None:
+        return f"Conversation introuvable : {arg}. Tape /sessions pour la liste."
+    if not session.ctx.confirm(f"Supprimer la conversation « {data.get('title', '')} » ?"):
+        return "Rien n'a été supprimé."
+    delete_session(data)
+    if data["id"] == session.session_id:
+        session.session_id = None  # la conversation en cours sera sauvegardée dans un nouveau fichier
+    return f"Conversation supprimée : {data.get('title', '')}"
+
+
+def cmd_context(session: Session, arg: str) -> str:
+    return context_report(session)
+
+
+def cmd_compact(session: Session, arg: str) -> str:
+    if len(session.messages) <= 1:
+        return "Rien à compacter : la conversation est vide."
+    summary = compact(session)
+    save_session(session)  # le fichier sauvegardé contient désormais le résumé
+    return f"Conversation compactée. Le modèle repart de ce résumé :\n\n{summary}"
+
+
+def cmd_allow(session: Session, arg: str) -> str:
+    allowed = session.ctx.allowed_commands
+    if not arg:
+        return "Commandes lancées sans confirmation : " + (", ".join(allowed) or "aucune")
+    if any(operator in arg for operator in SHELL_OPERATORS):
+        return "Refusé : une commande autorisée ne doit contenir aucun opérateur shell (& | ; > < ...)."
+    allowed.append(arg)
+    return f"« {arg} » sera lancée sans confirmation jusqu'à la fin de la session."
+
+
+# nom de la commande -> (fonction, aide affichée par /help)
+COMMANDS: dict[str, tuple[Callable[[Session, str], str], str]] = {
+    "/help": (cmd_help, "liste des commandes"),
+    "/init": (cmd_init, "préparer le projet : AGENTS.md et dossier .llamagent/"),
+    "/config": (cmd_config, "réglages actuels"),
+    "/models": (cmd_models, "modèles installés sur le serveur Ollama"),
+    "/model": (cmd_model, "changer de modèle : /model qwen3.5:4b"),
+    "/temp": (cmd_temp, "changer la température : /temp 0.5"),
+    "/ctx": (cmd_ctx, "changer la taille du contexte : /ctx 16384"),
+    "/skills": (cmd_skills, "skills disponibles"),
+    "/skill": (cmd_skill, "charger une skill : /skill corriger-un-bug"),
+    "/clear": (cmd_clear, "effacer la conversation"),
+    "/context": (cmd_context, "ce qui occupe le contexte"),
+    "/compact": (cmd_compact, "résumer la conversation pour libérer du contexte"),
+    "/sessions": (cmd_sessions, "conversations sauvegardées dans ce projet"),
+    "/resume": (cmd_resume, "reprendre une conversation : /resume 2 (sans numéro : la dernière)"),
+    "/delete": (cmd_delete, "supprimer une conversation : /delete 2"),
+    "/allow": (cmd_allow, "lancer une commande sans confirmation : /allow python -m pytest"),
+}
+
+
+def execute_command(session: Session, line: str) -> str:
+    """Exécute une ligne comme « /temp 0.5 » et renvoie le texte à afficher."""
+    name, _, arg = line.strip().partition(" ")
+    if name not in COMMANDS:
+        return f"Commande inconnue : {name}. Tape /help."
+    function, _ = COMMANDS[name]
+    try:
+        return function(session, arg.strip())
+    except requests.RequestException as error:
+        return f"Erreur de communication avec Ollama : {error}"

llamagent/config.py

@@ -0,0 +1,123 @@
+"""Configuration de llamagent.
+
+Les réglages viennent de plusieurs sources. Chacune remplace la précédente :
+    1. les valeurs par défaut ci-dessous ;
+    2. le fichier global   ~/.llamagent/config.toml ;
+    3. le fichier du projet .llamagent/config.toml (dans le dossier de travail) ;
+    4. les variables d'environnement OLLAMA_URL et OLLAMA_MODEL ;
+    5. les options de la ligne de commande (--model, --temperature...).
+Les limites des garde-fous, elles, sont fixées ici.
+"""
+
+import os
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+# Valeurs par défaut : Ollama sur la machine elle-même (son adresse standard),
+# et un modèle 4B qui tient dans 6 Go de VRAM. Un Ollama installé ailleurs
+# (sur un NAS par exemple) se règle dans ~/.llamagent/config.toml.
+DEFAULT_OLLAMA_URL = "http://localhost:11434"
+DEFAULT_OLLAMA_MODEL = "qwen3.5:4b"
+
+# Température basse : on veut un agent prévisible, pas créatif.
+TEMPERATURE = 0.2
+# Taille de la fenêtre de contexte (en tokens) demandée à Ollama.
+# 8192 est un bon compromis pour un modèle 4B sur une carte de 6 Go.
+NUM_CTX = 8192
+# Délai maximal d'une requête à Ollama, en secondes. Le premier appel est
+# lent car Ollama doit charger le modèle en VRAM.
+REQUEST_TIMEOUT = 120
+
+# Garde-fous (étape 6).
+MAX_TOURS = 15  # nombre maximal d'appels au LLM pour une même demande
+COMMAND_TIMEOUT = 30  # durée maximale d'une commande lancée par run_command (s)
+MAX_OUTPUT_CHARS = 4000  # taille maximale d'un résultat d'outil (~1000 tokens)
+# Compactage automatique quand le contexte est rempli à 80 % (étape 16).
+COMPACT_THRESHOLD = 0.8
+
+# prompts/ et skills/ font partie du paquet (étape 18) : ils sont à côté de
+# ce fichier, dans src/llamagent/, et donc installés avec le code, que
+# llamagent vienne du dépôt ou de PyPI.
+PACKAGE_DIR = Path(__file__).resolve().parent
+PROMPTS_DIR = PACKAGE_DIR / "prompts"
+SKILLS_DIR = PACKAGE_DIR / "skills"
+
+# Réglages propres à chaque projet (étape 9) : un dossier .llamagent/ dans
+# le dossier de travail, et un fichier AGENTS.md à sa racine.
+PROJECT_DIR_NAME = ".llamagent"
+PROJECT_INSTRUCTIONS = "AGENTS.md"
+# Fichier de réglages global de l'utilisateur (étape 12).
+USER_CONFIG = Path.home() / PROJECT_DIR_NAME / "config.toml"
+# Les seules clés acceptées dans un fichier config.toml.
+SETTINGS_KEYS = {"url", "model", "temperature", "num_ctx", "allowed_commands"}
+
+
+@dataclass(frozen=True)
+class Config:
+    """Réglages de la session. Pour en changer un : dataclasses.replace()."""
+
+    ollama_url: str
+    model: str
+    workdir: Path  # le seul dossier où l'agent a le droit de lire et d'écrire
+    temperature: float = TEMPERATURE
+    num_ctx: int = NUM_CTX
+    # Commandes que run_command lance sans demander confirmation (étape 14).
+    allowed_commands: tuple[str, ...] = ()
+
+    @property
+    def chat_url(self) -> str:
+        """URL de l'API native d'Ollama (et non la couche /v1 compatible OpenAI)."""
+        return f"{self.ollama_url}/api/chat"
+
+    def options(self) -> dict:
+        """Bloc `options` envoyé à Ollama à chaque appel."""
+        return {"temperature": self.temperature, "num_ctx": self.num_ctx}
+
+
+def read_toml(path: Path) -> dict:
+    """Lit un fichier de réglages TOML. Renvoie {} s'il n'existe pas."""
+    if not path.is_file():
+        return {}
+    try:
+        settings = tomllib.loads(path.read_text(encoding="utf-8"))
+    except tomllib.TOMLDecodeError as error:
+        raise SystemExit(f"Fichier de réglages invalide : {path}\n{error}")
+    # Une faute de frappe (« temperatur ») serait sinon ignorée sans prévenir.
+    unknown = set(settings) - SETTINGS_KEYS
+    if unknown:
+        raise SystemExit(f"Réglage inconnu dans {path} : {', '.join(sorted(unknown))}")
+    return settings
+
+
+def load_config(cli_options: dict | None = None) -> Config:
+    """Construit la configuration à partir de toutes les sources, dans l'ordre."""
+    # Par défaut, l'agent travaille dans le dossier où on le lance.
+    workdir = Path(os.environ.get("LLAMAGENT_WORKDIR", Path.cwd())).resolve()
+    # Un dossier de travail absent ferait échouer tous les outils plus tard,
+    # avec des erreurs obscures (WinError 267 sous Windows) : on s'arrête net.
+    if not workdir.is_dir():
+        raise SystemExit(f"Dossier de travail introuvable : {workdir} (vérifie LLAMAGENT_WORKDIR).")
+
+    settings = {"url": DEFAULT_OLLAMA_URL, "model": DEFAULT_OLLAMA_MODEL, "temperature": TEMPERATURE, "num_ctx": NUM_CTX}
+    settings.update(read_toml(USER_CONFIG))
+    settings.update(read_toml(workdir / PROJECT_DIR_NAME / "config.toml"))
+    if "OLLAMA_URL" in os.environ:
+        settings["url"] = os.environ["OLLAMA_URL"]
+    if "OLLAMA_MODEL" in os.environ:
+        settings["model"] = os.environ["OLLAMA_MODEL"]
+    # Options de la ligne de commande : seulement celles qui ont été données.
+    settings.update({key: value for key, value in (cli_options or {}).items() if value is not None})
+
+    try:
+        return Config(
+            # On retire un éventuel "/" final pour pouvoir écrire f"{url}/api/chat".
+            ollama_url=str(settings["url"]).rstrip("/"),
+            model=str(settings["model"]),
+            workdir=workdir,
+            temperature=float(settings["temperature"]),
+            num_ctx=int(settings["num_ctx"]),
+            allowed_commands=tuple(str(command) for command in settings.get("allowed_commands", ())),
+        )
+    except (TypeError, ValueError) as error:  # ex. temperature = "chaud"
+        raise SystemExit(f"Réglage invalide : {error}")