Projet final : Mini Claude Code complet

Tu as construit chaque brique separement. Il est temps de tout assembler. C'est l'exercice final du projet Mini Claude Code : creer la classe MiniClaudeCode qui orchestre tous les composants.

C'est exactement ce qu'on fait en production quand on construit un logiciel : des modules independants, bien testes separement, qu'on branche ensemble. La classe principale est le chef d'orchestre qui delegue a chaque composant.

Ecris une classe MiniClaudeCode qui rassemble tous les outils. Elle ne reimplemente rien : elle utilise les fonctions et classes que tu as deja construites.

La classe prend a la construction un system_prompt et une config optionnelle (dictionnaire).

Attributs et methodes :

config : un dictionnaire avec model, max_iterations, et confirmer_ecriture.
fichiers : le systeme de fichiers simule (un dictionnaire, vide par defaut).
historique : la liste des messages de conversation.
journal : la liste des actions effectuees.

executer_instruction(instruction) : recoit une instruction utilisateur et renvoie le resultat. C'est le point d'entree principal.

enregistrer_outil(nom, fonction, description) : ajoute un outil disponible.

lister_outils() : renvoie les noms et descriptions des outils.

obtenir_rapport() : renvoie un rapport complet de la session (nombre d'instructions traitees, outils utilises, fichiers modifies, tokens consommes).

reinitialiser() : remet tout a zero (historique, journal) sans toucher aux outils enregistres.

L'execution d'une instruction fonctionne ainsi :
1. Analyser l'instruction (commande speciale ou prompt ?)
2. Si c'est /quit, /clear, /stats, traiter la commande
3. Si c'est un prompt, simuler un echange avec le LLM (pour les tests, on simule)
4. Enregistrer dans l'historique et le journal
5. Retourner le resultat

Format de retour de executer_instruction :

{"type": "reponse", "contenu": "...", "outils_utilises": [], "tokens": 42}
{"type": "commande", "action": "quitter"}
{"type": "commande", "action": "effacer"}
{"type": "stats", "donnees": {...}}
{"type": "erreur", "message": "Commande vide"}

Pour le rapport :

{
"instructions_traitees": 5,
"outils_disponibles": ["lire_fichier", "lister_fichiers"],
"fichiers_modifies": [],
"tokens_total": 234,
"messages_historique": 10
}

Exemple :

agent = MiniClaudeCode("Tu es un assistant Python.")
agent.enregistrer_outil("addition", lambda a, b: a + b, "Additionner deux nombres")

agent.executer_instruction("/stats")
renvoie {"type": "stats", "donnees": {"instructions_traitees": 0, ...}}

agent.executer_instruction("Bonjour")
renvoie {"type": "reponse", "contenu": "...", "outils_utilises": [], "tokens": ...}

rapport = agent.obtenir_rapport()
# {"instructions_traitees": 2, ...}

Tests (4/5)

Commandes speciales fonctionnent

agent = MiniClaudeCode("Tu es un assistant.")
r1 = agent.executer_instruction("/quit")
assert r1["type"] == "commande" and r1["action"] == "quitter"

r2 = agent.executer_instruction("/clear")
assert r2["type"] == "commande" and r2["action"] == "effacer"

r3 = agent.executer_instruction("")
assert r3["type"] == "erreur"

Envoyer un prompt

agent = MiniClaudeCode("Tu es un assistant.")
r = agent.executer_instruction("Bonjour le monde")
assert r["type"] == "reponse"
assert isinstance(r["contenu"], str) and len(r["contenu"]) > 0
assert isinstance(r["tokens"], int) and r["tokens"] > 0
assert isinstance(r["outils_utilises"], list)

Enregistrer et lister des outils

agent = MiniClaudeCode("Sys")
agent.enregistrer_outil("lire", lambda path: path, "Lire un fichier")
agent.enregistrer_outil("ecrire", lambda path, contenu: True, "Ecrire un fichier")
outils = agent.lister_outils()
assert len(outils) == 2
noms = [o["nom"] for o in outils]
assert "lire" in noms and "ecrire" in noms

Rapport de session

agent = MiniClaudeCode("Sys")
agent.enregistrer_outil("test_outil", lambda: 1, "Un outil de test")
agent.executer_instruction("Question 1")
agent.executer_instruction("Question 2")
rapport = agent.obtenir_rapport()
assert rapport["instructions_traitees"] >= 2, f"Attendu au moins 2 instructions, obtenu {rapport['instructions_traitees']}"
assert rapport["tokens_total"] > 0
assert "test_outil" in rapport["outils_disponibles"]
assert rapport["messages_historique"] == 4, f"Attendu 4 messages (2 questions + 2 reponses), obtenu {rapport['messages_historique']}"

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

class MiniClaudeCode:
    def __init__(self, system_prompt, config=None):
        self.system_prompt = system_prompt
        self.config = config or {
            "model": "gpt-4o-mini",
            "max_iterations": 10,
            "confirmer_ecriture": True,
        }
        self.fichiers = {}
        self.historique = []
        self.journal = []
        self.outils = {}
        self.compteur_instructions = 0
        self.tokens_total = 0
        self.fichiers_modifies = []

    def enregistrer_outil(self, nom, fonction, description):
        self.outils[nom] = {"fonction": fonction, "description": description}

    def lister_outils(self):
        return [{"nom": nom, "description": info["description"]}
                for nom, info in self.outils.items()]

    def executer_instruction(self, instruction):
        texte = instruction.strip()
        self.compteur_instructions += 1

        if not texte:
            return {"type": "erreur", "message": "Commande vide"}

        if texte in ("/quit", "/exit"):
            return {"type": "commande", "action": "quitter"}

        if texte == "/clear":
            self.historique = []
            return {"type": "commande", "action": "effacer"}

        if texte == "/stats":
            return {"type": "stats", "donnees": self.obtenir_rapport()}

        # Simuler un echange LLM
        self.historique.append({"role": "user", "content": texte})
        tokens_question = len(texte) // 4
        reponse_simulee = f"[Reponse simulee pour : {texte[:50]}]"
        tokens_reponse = len(reponse_simulee) // 4
        self.historique.append({"role": "assistant", "content": reponse_simulee})
        self.tokens_total += tokens_question + tokens_reponse
        self.journal.append({"action": "prompt", "instruction": texte[:100]})

        return {
            "type": "reponse",
            "contenu": reponse_simulee,
            "outils_utilises": [],
            "tokens": tokens_question + tokens_reponse,
        }

    def obtenir_rapport(self):
        return {
            "instructions_traitees": self.compteur_instructions,
            "outils_disponibles": list(self.outils.keys()),
            "fichiers_modifies": list(self.fichiers_modifies),
            "tokens_total": self.tokens_total,
            "messages_historique": len(self.historique),
        }

    def reinitialiser(self):
        self.historique = []
        self.journal = []
        self.compteur_instructions = 0
        self.tokens_total = 0
        self.fichiers_modifies = []

← Configuration et personnalisation

solution.py

Bravo!

Projet final : Mini Claude Code complet

Tests (4/5)

Indices (3 disponibles)

Solution officielle