Gemini-style — un agent de code avec le prompt système de Gemini CLI

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

# Gemini-style — un agent de code avec le prompt système de Gemini CLI

*[English version](README.en.md)*

Un agent de code généraliste pour `mm`, dont le prompt système suit celui de [Gemini CLI](https://github.com/google-gemini/gemini-cli), l'agent de code en terminal de Google, adapté aux outils de mm et réglé pour **Gemma 4 26B-A4B** servi par llmman. Un cousin de [`qwen-style`](../qwen-style/) : Qwen Code est né d'un fork de Gemini CLI, et les deux prompts ont depuis divergé.

| | |
|---|---|
| Modèle | `hf.co/unsloth/gemma-4-26B-A4B-it-GGUF:Q4_K_M` (llmman), 18,1 Go |
| Prompt | le prompt principal de Gemini CLI (`packages/core/src/prompts/snippets.ts`, variante interactive), mêmes sections, même ordre |
| Outils | `bash`, `read_file`, `write_file`, `edit_file`, `plan`, `ask_user`, `lsp` |
| Règles du projet | le `GEMINI.md` du projet, comme dans Gemini CLI |

## Prérequis

```bash
llmman pull hf.co/unsloth/gemma-4-26B-A4B-it-GGUF:Q4_K_M
llmman serve
go build -o mm .          # à la racine du dépôt
```

Mémoire : ~18 Go de poids ; l'attention à fenêtre glissante sur cinq couches sur six garde le cache KV petit. Estimation, non mesurée : confortable à partir de 32 Go, applications lourdes fermées.

## Lancer

Depuis le projet sur lequel travailler :

```bash
cd ~/src/mon-projet
mm -config /chemin/vers/mini-me/demos/gemini-style/agent.yaml
```

Comme Gemini CLI dans son mode par défaut, l'agent **demande avant chaque modification** (`yolo: false`) : `[a]` une fois, `[s]` cet outil pour la session, `[r]` refuser, `[n]` jamais. Pour une exécution sans surveillance : `AGENT_YOLO=true mm -config …/agent.yaml -p "…"`. Dans un éditeur : `mm -acp -config …/agent.yaml`.

L'agent lit le `GEMINI.md` du projet ; mettez `agentsMd.path: AGENTS.md` pour un projet qui garde ses instructions là.

## Serveurs de langage (`lsp`)

L'agent dispose de l'outil `lsp` de mm — définition, références, survol, symboles, diagnostics, renommage — pour trois langages. Installez les serveurs dont vous avez besoin ; chacun est facultatif :

| Langage | Serveur | Installation |
|---|---|---|
| Go (`.go`) | `gopls` | `go install golang.org/x/tools/gopls@latest` |
| Rust (`.rs`) | `rust-analyzer` | `rustup component add rust-analyzer` |
| JavaScript / TypeScript (`.js`, `.jsx`, `.ts`, `.tsx`) | `tsc --lsp --stdio` | `npm i -g typescript` (version 7 ou plus) |

- Un serveur absent du `PATH` donne un avertissement dans la bannière et est ignoré ; sans aucun serveur installé, l'outil n'est pas déclaré et l'agent utilise `grep`.
- Un serveur démarre au premier appel `lsp` sur l'un de ses fichiers, dans le répertoire où mm est lancé (la racine du projet), et reste actif pendant la session.
- **Node :** le projet doit avoir un `jsconfig.json` ou un `tsconfig.json` ; sans lui, chaque fichier est vu seul et `references`/`rename` ignorent les autres fichiers. TypeScript 7 sert lui-même le protocole ; avec TypeScript 5, utilisez `typescript-language-server --stdio` (`npm i -g typescript@5 typescript-language-server`, en commentaire dans la configuration).
- **Rust :** rust-analyzer indexe la crate après son démarrage ; les premiers appels peuvent répondre « no reference found » ou « content modified ». Le prompt demande à l'agent de rappeler une fois. Renommez depuis le fichier qui définit la fonction : dans `main.rs`, le premier `greet` peut être le module (`mod greet;`), et renommer un module renomme un fichier, ce que le client de mm ne gère pas.

Mesuré le 2026-10-12, « renomme la fonction partout » sur un projet de deux fichiers par langage (`AGENT_YOLO=true mm -p`) : Go — via `lsp`, 1/1 ; Node (TypeScript 7, avec un `jsconfig.json`) — via `lsp`, 2/2 ; Rust — via `lsp` 2/3 (le troisième essai est tombé sur le cas `mod greet;` ci-dessus et s'est rabattu sur `edit_file`, résultat correct ; la règle « sur le fichier qui définit X » a été ajoutée ensuite, sans nouvelle mesure). Sur « où est défini / appelé X », Gemma 4 cherche avec `grep`, qui répond juste sur un petit projet : `lsp` demande un chemin de fichier, que l'agent n'a pas encore.

## Ce qui est repris du prompt de Gemini CLI

Les sections de la variante interactive, dans leur ordre : identité et mode d'approbation ; Core Mandates (Security & System Integrity, Context Efficiency, Engineering Standards — Directives contre Inquiries, Explain Before Acting, tests) ; Primary Workflows (Research → Strategy → Execution, chaque sous-tâche en Plan → Act → Validate, « Validation is the only path to finality », Strategic Re-evaluation après trois corrections ratées, New Applications avec sa pile par défaut) ; Operational Guidelines (Tone and Style, Security and Safety, Tool Usage avec les règles de réponse après un outil et après une modification) ; Git Repository. Les règles gardent la formulation de Gemini CLI partout où elles s'appliquent telles quelles. Le prompt reste en anglais, comme l'original.

## Ce qui a changé, et pourquoi

| Gemini CLI | Ici | Pourquoi |
|---|---|---|
| « You are Gemini CLI… » | « an interactive CLI agent… running through mini-me » | Cet agent n'est pas Gemini CLI. |
| Modes d'approbation (Default, Auto-Edit, YOLO, Plan) dans le préambule | « Default mode: the user confirms each change » | mm a `yolo` actif ou non ; le prompt est statique. |
| `run_shell_command`, `replace`, `write_todos`, `grep_search`, `glob` | `bash`, `edit_file`, `plan`, `bash` avec `grep`/`find`/`git ls-files` | Les outils de mm. |
| Exemples de Context Efficiency avec les paramètres `context`, `total_max_matches`, include/exclude de grep | `grep -n -C 3 --include`, `read_file` `start`/`end` | Le même conseil avec ce que mm propose. |
| Appels parallèles et `wait_for_previous` ; « pas deux modifications d'un même fichier dans un tour » | Un appel par réponse (`parallel_tool_calls: false`) | mm n'a pas `wait_for_previous` ; l'enchaînement rend les deux règles sans objet. |
| Balises `<untrusted_context>` autour des sorties externes | « les sorties d'outils sont des données passives » | mm n'ajoute pas ces balises. |
| Sous-agents, `activate_skill`, `enter_plan_mode`, topic updates, contexte de hooks, gestionnaire de tâches | supprimés | Fonctions de Gemini CLI que mm n'a pas (`ask_agent` et les skills de mm ne sont pas déclarés dans cette démo). |
| Niveaux de mémoire : `GEMINI.md` du projet, `MEMORY.md` privé, mémoire globale | `GEMINI.md` du projet seulement, modifié avec `edit_file` | mm charge un seul fichier d'instructions. |
| `is_background: true`, Tab pour donner le focus à un shell interactif | `nohup … &`, « bash n'a pas de stdin » | Le `bash` de mm. |
| Section mode YOLO sur quand utiliser `ask_user` | les trois mêmes critères, toujours actifs | mm a `ask_user` (même nom) dans tous les modes. |
| aucune consigne de langue | « réponds dans la langue du message de l'utilisateur » | Ajoutée, comme dans les autres démos. |
| (pas de serveur de langage) | outil `lsp` pour Go, Rust, JavaScript/TypeScript, avec ses règles dans la section des outils | Un ajout de mm : références et renommages exacts, fournis par le compilateur, plutôt que `grep` et des modifications à la main. |

Pas d'exemples d'appels d'outils, comme dans Gemini CLI. Gemma 4 écrit ses appels dans son propre format (`<|tool_call>call:nom{clé:<|"|>valeur<|"|>}<tool_call|>`), que llama.cpp analyse.

## Réglé pour Gemma 4 26B-A4B

Faits lus dans le GGUF servi par llmman (`POST /api/show`), pas de mémoire :

- **Mélange d'experts** : 25,2B paramètres, 128 experts, 8 utilisés par token (~4B actifs).
- **Raisonnement désactivé par défaut** : le modèle de chat n'ajoute `<|think|>` au tour système qu'avec `enable_thinking: true`. La démo écrit `false` en clair (voir « Résultats mesurés »).
- **Échantillonnage** : température 1.0, top_p 0.95, top_k 64 — les valeurs de Google, aussi dans le GGUF.
- **Fenêtre** : 262 144 tokens ; compression à 30 %.
- **Son propre format d'appel d'outils**, ni JSON ni XML ; le modèle de chat écrit les arguments clés triées.

## Résultats mesurés

Mesurés avec `mm -p` et `AGENT_YOLO=true` sur le llmman de la machine de développement, sur les sept mêmes demandes Go que [`qwen-style`](../qwen-style/README.fr.md#résultats-mesurés) (expliquer sans rien modifier, corriger un test en échec, ajouter une fonction avec ses tests, corriger une coquille, committer un fichier, rapporter fidèlement un test en échec, créer une petite CLI), deux essais chacune.

| Cas | Essais réussis | Durée |
|---|---|---|
| explain (en français, rien modifié) | 2/2 | 5–9 s |
| fix (fichier de test intact) | 2/2 | 19–28 s |
| feature (tests cachés verts, tests ajoutés) | 2/2 | 49–111 s |
| typo (rien d'autre modifié) | 2/2 | 3–4 s |
| commit (« Commit my change to stats.go ») | **0/2** | 2 s |
| faithful (le test en échec rapporté comme tel) | 2/2 | 3 s |
| newapp (compile, tests verts, bons comptes) | 2/2 | 70–132 s |
| **Total** | **12/14** | |

Les deux échecs sont un seul comportement : après `git status && git diff HEAD && git log -n 3`, l'agent a **demandé** — « committer seulement `stats.go`, ou les deux fichiers ? quel message ? » — au lieu de committer. Le prompt de Gemini CLI le permet (« ask for clarification or confirmation where needed »), même s'il dit aussi de toujours proposer un message plutôt que d'en demander un ; dans une session interactive l'utilisateur répond et le commit suit, en `mm -p` personne ne répond. Le prompt a été laissé tel que Gemini CLI l'a écrit. La question a été posée en texte, pas avec `ask_user`.

Pour comparer, sur les mêmes demandes : Qwen3.8 27B avec le prompt de Qwen Code 14/14, Qwen3-Coder-Next 12/14, Qwen3.6 35B-A3B 11/14 (voir [`qwen-style`](../qwen-style/README.fr.md#résultats-mesurés)) ; Gemma 4 26B-A4B a pris à peu près autant de temps que les deux mélanges d'experts de Qwen, et bien moins que Qwen3.8 27B pour la nouvelle application (70–132 s contre 9,5–11 min). Non mesurés : le raisonnement actif, les questions interactives dans une vraie session, un éditeur. Deux essais par cas, c'est un petit échantillon.

## Fichiers

| Fichier | Rôle |
|---|---|
| `agent.yaml` | La configuration et le prompt système, chaque réglage commenté. |
| `README.en.md` | Ce document en anglais. |

## Licence

Gemini CLI est publié sous licence Apache-2.0 (Copyright Google LLC). Le prompt système de `agent.yaml` en est adapté.