@devilnside/pi-auto-improve 1.0.0

package/README.md

@@ -0,0 +1,65 @@
+# @ajoye/pi-auto-improve
+
+Système d'auto-amélioration pour [Pi Coding Agent](https://pi.dev). Permet à l'agent d'apprendre de ses erreurs via un système de feedback utilisateur.
+
+## Installation
+
+```bash
+pi install npm:@ajoye/pi-auto-improve
+```
+
+Ou essayer sans installer :
+
+```bash
+pi -e npm:@ajoye/pi-auto-improve
+```
+
+Puis redémarre Pi ou tape `/reload`.
+
+## Fonctionnalités
+
+- **Feedback manuel** — Commandes `/good` et `/bad` pour évaluer les réponses
+- **Boutons Telegram** — 👍/👎 sur chaque réponse en mode Telegram
+- **Analyse d'échec** — Sur feedback négatif, l'agent analyse ce qui a mal tourné et propose une leçon
+- **Leçons validées** — Chaque leçon doit être validée par l'utilisateur avant stockage
+- **3 scopes** — Global, par domaine (debug, refactoring, feature, review, general), par projet
+- **Injection automatique** — Les leçons globales sont injectées dans le prompt système à chaque tour
+
+## Usage
+
+### Feedback
+
+- `/good [commentaire]` — Enregistrer un feedback positif
+- `/bad [commentaire]` — Feedback négatif + déclenche l'analyse
+
+### Leçons
+
+- `/lessons [scope]` — Afficher les leçons (`global`, `domain`, `project`, `all`)
+- `/lesson-add <domain> <règle>` — Ajouter manuellement une leçon
+- `/lesson-remove <id>` — Désactiver une leçon
+
+### Domaines
+
+- `debug` — Tests, erreurs, stack traces
+- `refactoring` — Modifications multiples de fichiers
+- `feature` — Nouveaux fichiers, nouvelles fonctionnalités
+- `review` — Lecture de code
+- `general` — Par défaut
+
+## Architecture
+
+Les données sont stockées dans `~/.pi/agent/data/auto-improve/` :
+
+```
+data/auto-improve/
+├── feedback.jsonl             # Historique des feedbacks
+├── lessons/
+│   ├── global.json            # Leçons globales (toujours chargées)
+│   ├── domain-debug.json      # Leçons par domaine
+│   └── ...
+└── projects/                  # Leçons par projet (hash du chemin)
+```
+
+## Design
+
+Voir [docs/features/2026-05-10-auto-improve-design.md](docs/features/2026-05-10-auto-improve-design.md) pour le spec complet.

package/docs/features/2026-05-10-auto-improve-design.md

@@ -0,0 +1,208 @@
+# Pi Auto-Improve — Design
+
+**Date :** 2026-05-10
+**Statut :** Validé
+
+## Résumé
+
+Système d'auto-amélioration pour Pi composé d'un skill (logique métier) et d'une extension légère (intégration Pi). L'utilisateur donne du feedback manuel (CLI ou boutons Telegram 👍/👎). Sur feedback négatif, Pi analyse l'échec, propose une leçon à valider. Les leçons sont stockées en JSON structuré, avec des règles globales toujours chargées au démarrage et des leçons domaine/projet consultées à la demande.
+
+## Approche retenue
+
+Skill + Extension légère (Approche C) :
+- **Skill** = logique métier (analyse, génération de leçons, consolidation)
+- **Extension** = intégration Pi (commandes, hooks, Telegram, chargement contexte)
+
+## Architecture
+
+```
+~/Projects/pi-self-improve/
+├── README.md
+├── docs/features/                     # Design docs
+├── skill/
+│   └── auto-improve/
+│       └── SKILL.md                   # Logique d'analyse et leçons
+├── extension/
+│   └── auto-improve.ts               # Commandes, hooks, Telegram
+├── data/
+│   ├── feedback.jsonl                 # Historique brut des feedbacks
+│   ├── lessons/
+│   │   ├── global.json                # Leçons globales
+│   │   ├── domain-debug.json
+│   │   ├── domain-refactoring.json
+│   │   ├── domain-feature.json
+│   │   ├── domain-review.json
+│   │   └── domain-general.json
+│   └── projects/
+│       └── <project-hash>.json        # Leçons spécifiques par projet
+└── scripts/
+    └── install.sh                     # Installation dans ~/.pi/agent/
+```
+
+## Format de stockage
+
+### feedback.jsonl
+
+Un JSON par ligne, append-only.
+
+```json
+{
+  "id": "abc123",
+  "timestamp": "2026-05-10T14:30:00Z",
+  "type": "positive | negative",
+  "source": "cli | telegram",
+  "session": "sess-456",
+  "project": "/var/home/ajoye/Projects/my-app",
+  "domain": "refactoring",
+  "context": "Refactor du module auth",
+  "user_comment": "Trop de changements d'un coup"
+}
+```
+
+Champs :
+- `id` — identifiant unique (timestamp-based)
+- `timestamp` — ISO 8601
+- `type` — `positive` ou `negative`
+- `source` — `cli` (commande `/good`/`/bad`) ou `telegram` (bouton)
+- `session` — ID de la session Pi
+- `project` — chemin du projet (cwd au moment du feedback)
+- `domain` — domaine détecté ou `general` par défaut
+- `context` — résumé court de la tâche en cours
+- `user_comment` — texte libre optionnel
+
+### lessons/*.json et projects/*.json
+
+Même structure, scope différent.
+
+```json
+{
+  "project": "global",
+  "updated": "2026-05-10T14:35:00Z",
+  "lessons": [
+    {
+      "id": "l-001",
+      "created": "2026-05-10T14:35:00Z",
+      "domain": "refactoring",
+      "rule": "Toujours découper les refactors larges en petites étapes incrémentales, une fonction ou un fichier à la fois",
+      "rationale": "L'utilisateur préfère voir chaque étape validée avant de continuer",
+      "source_feedback": ["abc123"],
+      "positive_examples": 2,
+      "violations": 0,
+      "active": true
+    }
+  ]
+}
+```
+
+Champs :
+- `id` — identifiant unique de la leçon
+- `created` — date de création
+- `domain` — `debug`, `refactoring`, `feature`, `review`, `general`
+- `rule` — la leçon en langage naturel, concise et actionnable
+- `rationale` — pourquoi cette règle existe
+- `source_feedback` — IDs des feedbacks ayant généré cette leçon
+- `positive_examples` — compteur de fois où la règle a été suivie avec succès
+- `violations` — compteur de fois où la règle a été enfreinte
+- `active` — `false` = désactivée sans suppression
+
+Hash projet : hash court (6-8 chars) du chemin absolu du projet.
+
+## Extension (auto-improve.ts)
+
+### Commandes
+
+| Commande | Description |
+|----------|-------------|
+| `/good [commentaire]` | Enregistre un feedback positif |
+| `/bad [commentaire]` | Feedback négatif + déclenche l'analyse |
+| `/lessons [scope]` | Affiche les leçons (global, domain, project) |
+| `/lesson-add <domain> <règle>` | Ajout manuel d'une leçon |
+| `/lesson-remove <id>` | Désactive une leçon |
+
+### Hooks
+
+- **`on("session_start")`** — Charge `global.json` et l'injecte dans le contexte
+- **`on("tool_call", filter="bash")`** — Détecte le domaine courant basé sur les actions
+
+### Intégration Telegram
+
+Après chaque réponse en mode Telegram, ajout de boutons cachés :
+```
+<!-- telegram_button label="👍" prompt="Feedback positif pour la dernière réponse." -->
+<!-- telegram_button label="👎" prompt="Feedback négatif pour la dernière réponse." -->
+```
+
+Le feedback négatif via bouton déclenche le même flux que `/bad`.
+
+### Chargement au démarrage
+
+Le fichier `global.json` est lu, formaté en Markdown, injecté dans le contexte :
+
+```markdown
+## Leçons apprises (auto-improve)
+- [refactoring] Toujours découper les refactors en petites étapes incrémentales
+- [debug] Commencer par reproduire le bug avant de proposer des fixes
+```
+
+## Skill (auto-improve/SKILL.md)
+
+### Frontmatter
+
+```yaml
+---
+name: auto-improve
+description: "Use when the user gives negative feedback (👎, /bad) or asks to analyze a failure. Handles failure analysis, lesson generation, and lesson consolidation."
+---
+```
+
+### Responsabilités
+
+1. **Analyser l'échec** — Examiner la conversation récente, identifier la cause
+2. **Formuler une leçon** — Règle concise, actionnable, en français
+3. **Détecter le domaine** — `debug`, `refactoring`, `feature`, `review`, `general`
+4. **Proposer à l'utilisateur** — Validation avant stockage
+5. **Consolider** — Fusionner avec les leçons existantes si similaire
+
+### Processus
+
+```
+Feedback négatif reçu
+  → Relire les derniers échanges
+  → Identifier la cause probable
+  → Vérifier si une leçon similaire existe
+    → Si oui : proposer une fusion
+    → Si non : proposer une nouvelle leçon
+  → Présenter à l'utilisateur : règle + justification
+  → Si validé → écrire dans le JSON
+  → Si refusé → ne rien stocker
+```
+
+### Consultation à la demande
+
+`/lessons domain debug` ou `/lessons project` :
+- Lire le JSON correspondant
+- Filtrer `active: true`
+- Présenter en liste concise
+
+## Chargement hybride
+
+- **Toujours chargé** : `global.json` → injecté au démarrage de chaque session
+- **À la demande** : leçons domaine et projet → consultées via `/lessons` ou par le skill quand c'est pertinent
+
+## Domaines supportés
+
+| Domaine | Détection |
+|---------|-----------|
+| `debug` | Commandes de test, grep d'erreurs, lecture de stack traces |
+| `refactoring` | Modifications multiples de fichiers existants |
+| `feature` | Création de nouveaux fichiers, ajout de fonctionnalités |
+| `review` | Lecture de code sans modification |
+| `general` | Par défaut, quand aucun domaine clair |
+
+## Décisions de design
+
+1. **Pas d'auto-correction immédiate** — Sur feedback négatif, analyse + proposition de leçon uniquement. L'utilisateur valide.
+2. **Feedback positif stocké aussi** — Sert pour les compteurs `positive_examples` et pour renforcer les leçons existantes.
+3. **Leçons désactivables** — `active: false` plutôt que suppression, pour garder l'historique.
+4. **Pas de ML** — Tout repose sur l'analyse par le LLM et la validation humaine.
+5. **Hash court pour les projets** — Pas de chemins complets dans les noms de fichiers.

package/extensions/auto-improve.ts

@@ -0,0 +1,554 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { createHash } from "node:crypto";
+import { appendFile, readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve, dirname, join } from "node:path";
+
+// ── Configuration ──────────────────────────────────────────────────────────
+const DATA_DIR = resolve(process.env.HOME!, ".pi/agent/data/auto-improve");
+const FEEDBACK_FILE = join(DATA_DIR, "feedback.jsonl");
+const LESSONS_DIR = join(DATA_DIR, "lessons");
+const PROJECTS_DIR = join(DATA_DIR, "projects");
+
+const DOMAINS = ["debug", "refactoring", "feature", "review", "general"] as const;
+type Domain = (typeof DOMAINS)[number];
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+function generateId(): string {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+}
+
+function projectHash(cwd: string): string {
+  return createHash("sha256").update(cwd).digest("hex").slice(0, 8);
+}
+
+function timestamp(): string {
+  return new Date().toISOString();
+}
+
+async function ensureDir(path: string) {
+  if (!existsSync(path)) await mkdir(path, { recursive: true });
+}
+
+async function ensureFile(path: string, defaultContent: string) {
+  if (!existsSync(path)) await writeFile(path, defaultContent, "utf8");
+}
+
+function domainFromActions(recentActions: string[]): Domain {
+  const combined = recentActions.join(" ").toLowerCase();
+  if (/test|spec|grep.*error|stack.?trace|fail|exception/.test(combined)) return "debug";
+  if (/edit|modify|refactor|rename|move/.test(combined)) return "refactoring";
+  if (/create|new file|add.*feature|implement|write.*new/.test(combined)) return "feature";
+  if (/review|read.*only|audit|check/.test(combined)) return "review";
+  return "general";
+}
+
+// ── Feedback ───────────────────────────────────────────────────────────────
+interface FeedbackEntry {
+  id: string;
+  timestamp: string;
+  type: "positive" | "negative";
+  source: "cli" | "telegram";
+  session: string;
+  project: string;
+  domain: string;
+  context: string;
+  user_comment?: string;
+}
+
+async function appendFeedback(entry: FeedbackEntry): Promise<void> {
+  await ensureDir(DATA_DIR);
+  await appendFile(FEEDBACK_FILE, JSON.stringify(entry) + "\n", "utf8");
+}
+
+// ── Lessons ────────────────────────────────────────────────────────────────
+interface Lesson {
+  id: string;
+  created: string;
+  domain: Domain;
+  rule: string;
+  rationale: string;
+  source_feedback: string[];
+  positive_examples: number;
+  violations: number;
+  active: boolean;
+}
+
+interface LessonFile {
+  project: string;
+  updated: string;
+  lessons: Lesson[];
+}
+
+function emptyLessonFile(project: string): LessonFile {
+  return { project, updated: timestamp(), lessons: [] };
+}
+
+async function readLessonFile(path: string): Promise<LessonFile> {
+  await ensureDir(dirname(path));
+  await ensureFile(path, JSON.stringify(emptyLessonFile("unknown"), null, 2));
+  const raw = await readFile(path, "utf8");
+  return JSON.parse(raw);
+}
+
+async function writeLessonFile(path: string, data: LessonFile): Promise<void> {
+  data.updated = timestamp();
+  await writeFile(path, JSON.stringify(data, null, 2), "utf8");
+}
+
+function globalPath(): string {
+  return join(LESSONS_DIR, "global.json");
+}
+
+function domainPath(domain: Domain): string {
+  return join(LESSONS_DIR, `domain-${domain}.json`);
+}
+
+function projectPath(cwd: string): string {
+  return join(PROJECTS_DIR, `${projectHash(cwd)}.json`);
+}
+
+// ── Format lessons as markdown for injection ───────────────────────────────
+function formatLessonsMarkdown(lessons: Lesson[]): string {
+  if (lessons.length === 0) return "";
+  const active = lessons.filter((l) => l.active);
+  if (active.length === 0) return "";
+  const lines = active.map((l) => `- [${l.domain}] ${l.rule}`);
+  return "## Leçons apprises (auto-improve)\n" + lines.join("\n");
+}
+
+async function loadGlobalLessons(): Promise<string> {
+  const data = await readLessonFile(globalPath());
+  return formatLessonsMarkdown(data.lessons);
+}
+
+// ── Track recent bash actions for domain detection ─────────────────────────
+const recentActions: string[] = [];
+const MAX_ACTIONS = 10;
+
+function trackAction(command: string) {
+  recentActions.push(command);
+  if (recentActions.length > MAX_ACTIONS) recentActions.shift();
+}
+
+// ── Context summary from session ───────────────────────────────────────────
+function getContextSummary(entries: any[]): string {
+  // Get last few user messages as context
+  const userMsgs = entries
+    .filter(
+      (e: any) =>
+        e.type === "message" &&
+        e.message?.role === "user" &&
+        typeof e.message?.content === "string"
+    )
+    .slice(-3);
+  return userMsgs
+    .map((e: any) => e.message.content.slice(0, 100))
+    .join(" | ");
+}
+
+// ── Extension ──────────────────────────────────────────────────────────────
+export default function (pi: ExtensionAPI) {
+  // Ensure data structure on startup
+  pi.on("session_start", async (_event, ctx) => {
+    await ensureDir(LESSONS_DIR);
+    await ensureDir(PROJECTS_DIR);
+    await ensureFile(
+      globalPath(),
+      JSON.stringify(emptyLessonFile("global"), null, 2)
+    );
+    for (const d of DOMAINS) {
+      await ensureFile(
+        domainPath(d),
+        JSON.stringify(emptyLessonFile(`domain-${d}`), null, 2)
+      );
+    }
+  });
+
+  // Track bash actions for domain detection
+  pi.on("tool_call", async (event) => {
+    if (event.toolName === "bash" && event.input?.command) {
+      trackAction(event.input.command);
+    }
+  });
+
+  // Inject global lessons into system prompt
+  pi.on("before_agent_start", async (event) => {
+    const md = await loadGlobalLessons();
+    if (md) {
+      return { systemPrompt: event.systemPrompt + "\n\n" + md };
+    }
+  });
+
+  // ── Command: /good ─────────────────────────────────────────────────────
+  pi.registerCommand("good", {
+    description: "Enregistrer un feedback positif sur la dernière réponse",
+    handler: async (args, ctx) => {
+      const sessionId =
+        ctx.sessionManager.getSessionFile()?.split("/").pop() ?? "unknown";
+      const domain = domainFromActions(recentActions);
+      const context = getContextSummary(ctx.sessionManager.getEntries());
+
+      await appendFeedback({
+        id: generateId(),
+        timestamp: timestamp(),
+        type: "positive",
+        source: "cli",
+        session: sessionId,
+        project: ctx.cwd,
+        domain,
+        context,
+        user_comment: args || undefined,
+      });
+
+      ctx.ui.notify("👍 Feedback positif enregistré", "info");
+    },
+  });
+
+  // ── Command: /bad ──────────────────────────────────────────────────────
+  pi.registerCommand("bad", {
+    description:
+      "Enregistrer un feedback négatif et déclencher l'analyse d'auto-amélioration",
+    handler: async (args, ctx) => {
+      const sessionId =
+        ctx.sessionManager.getSessionFile()?.split("/").pop() ?? "unknown";
+      const domain = domainFromActions(recentActions);
+      const context = getContextSummary(ctx.sessionManager.getEntries());
+      const feedbackId = generateId();
+
+      await appendFeedback({
+        id: feedbackId,
+        timestamp: timestamp(),
+        type: "negative",
+        source: "cli",
+        session: sessionId,
+        project: ctx.cwd,
+        domain,
+        context,
+        user_comment: args || undefined,
+      });
+
+      ctx.ui.notify("👎 Feedback négatif enregistré — analyse en cours...", "warning");
+
+      // Send analysis prompt to the agent
+      const comment = args ? ` Commentaire de l'utilisateur : "${args}"` : "";
+      pi.sendUserMessage(
+        `Feedback négatif reçu (id: ${feedbackId}, domaine détecté: ${domain}).${comment}\n\n` +
+          `Utilise le skill auto-improve pour analyser ce qui n'a pas fonctionné dans tes dernières réponses. ` +
+          `Propose une leçon à l'utilisateur et attends sa validation avant de la sauvegarder via l'outil save_lesson.`,
+        { deliverAs: "steer" }
+      );
+    },
+  });
+
+  // ── Command: /lessons ──────────────────────────────────────────────────
+  pi.registerCommand("lessons", {
+    description:
+      "Afficher les leçons apprises. Usage: /lessons [global|domain|project|all]",
+    handler: async (args, ctx) => {
+      const scope = args?.trim().toLowerCase() || "global";
+      let output = "";
+
+      try {
+        if (scope === "global" || scope === "all") {
+          const data = await readLessonFile(globalPath());
+          const active = data.lessons.filter((l) => l.active);
+          output += `📚 Leçons globales (${active.length}) :\n`;
+          for (const l of active) {
+            output += `  [${l.domain}] ${l.rule}\n`;
+          }
+        }
+
+        if (scope === "domain" || scope === "all") {
+          for (const d of DOMAINS) {
+            const data = await readLessonFile(domainPath(d));
+            const active = data.lessons.filter((l) => l.active);
+            if (active.length > 0) {
+              output += `\n📚 Leçons ${d} (${active.length}) :\n`;
+              for (const l of active) {
+                output += `  ${l.rule}\n`;
+              }
+            }
+          }
+        }
+
+        if (scope === "project" || scope === "all") {
+          const pPath = projectPath(ctx.cwd);
+          const data = await readLessonFile(pPath);
+          const active = data.lessons.filter((l) => l.active);
+          output += `\n📚 Leçons projet (${active.length}) :\n`;
+          for (const l of active) {
+            output += `  [${l.domain}] ${l.rule}\n`;
+          }
+        }
+
+        ctx.ui.notify(output || "Aucune leçon trouvée.", "info");
+      } catch (err: any) {
+        ctx.ui.notify(`Erreur: ${err.message}`, "error");
+      }
+    },
+  });
+
+  // ── Command: /lesson-add ───────────────────────────────────────────────
+  pi.registerCommand("lesson-add", {
+    description:
+      "Ajouter manuellement une leçon. Usage: /lesson-add <domain> <règle>",
+    handler: async (args, ctx) => {
+      const parts = args?.trim().split(/\s+/);
+      if (!parts || parts.length < 2) {
+        ctx.ui.notify(
+          "Usage: /lesson-add <domain> <règle>\nDomaines: debug, refactoring, feature, review, general",
+          "warning"
+        );
+        return;
+      }
+
+      const domain = parts[0] as Domain;
+      if (!DOMAINS.includes(domain)) {
+        ctx.ui.notify(
+          `Domaine invalide: ${domain}. Utilise: ${DOMAINS.join(", ")}`,
+          "error"
+        );
+        return;
+      }
+
+      const rule = parts.slice(1).join(" ");
+      const scope = ctx.hasUI ? "global" : "global"; // default to global for manual adds
+
+      const path = globalPath();
+      const data = await readLessonFile(path);
+      const lesson: Lesson = {
+        id: `l-${generateId()}`,
+        created: timestamp(),
+        domain,
+        rule,
+        rationale: "Ajoutée manuellement par l'utilisateur",
+        source_feedback: [],
+        positive_examples: 0,
+        violations: 0,
+        active: true,
+      };
+      data.lessons.push(lesson);
+      await writeLessonFile(path, data);
+
+      ctx.ui.notify(`✅ Leçon ajoutée: [${domain}] ${rule}`, "info");
+    },
+  });
+
+  // ── Command: /lesson-remove ────────────────────────────────────────────
+  pi.registerCommand("lesson-remove", {
+    description:
+      "Désactiver une leçon. Usage: /lesson-remove <id>",
+    handler: async (args, ctx) => {
+      const id = args?.trim();
+      if (!id) {
+        ctx.ui.notify("Usage: /lesson-remove <id>", "warning");
+        return;
+      }
+
+      // Search across all lesson files
+      const filesToSearch = [
+        globalPath(),
+        ...DOMAINS.map(domainPath),
+        projectPath(ctx.cwd),
+      ];
+
+      let found = false;
+      for (const path of filesToSearch) {
+        if (!existsSync(path)) continue;
+        const data = await readLessonFile(path);
+        const lesson = data.lessons.find((l) => l.id === id);
+        if (lesson) {
+          lesson.active = false;
+          await writeLessonFile(path, data);
+          ctx.ui.notify(`🗑️ Leçon désactivée: ${lesson.rule}`, "info");
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) {
+        ctx.ui.notify(`Leçon ${id} non trouvée.`, "warning");
+      }
+    },
+  });
+
+  // ── Tool: save_lesson ──────────────────────────────────────────────────
+  // Used by the agent (guided by the skill) to save a validated lesson
+  pi.registerTool({
+    name: "save_lesson",
+    label: "Save Lesson",
+    description:
+      "Sauvegarder une leçon validée par l'utilisateur. Spécifier le scope, domaine, règle et justification.",
+    promptSnippet: "Sauvegarder une leçon d'auto-amélioration validée",
+    parameters: Type.Object({
+      scope: Type.Union([
+        Type.Literal("global"),
+        Type.Literal("domain"),
+        Type.Literal("project"),
+      ], { description: "Scope de la leçon: global, domain, ou project" }),
+      domain: Type.Union([
+        Type.Literal("debug"),
+        Type.Literal("refactoring"),
+        Type.Literal("feature"),
+        Type.Literal("review"),
+        Type.Literal("general"),
+      ], { description: "Domaine de la leçon" }),
+      rule: Type.String({ description: "La leçon en français, concise et actionnable" }),
+      rationale: Type.String({ description: "Pourquoi cette règle existe" }),
+      source_feedback_id: Type.Optional(
+        Type.String({ description: "ID du feedback ayant généré cette leçon" })
+      ),
+      merge_with: Type.Optional(
+        Type.String({ description: "ID d'une leçon existante à fusionner" })
+      ),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      let path: string;
+      if (params.scope === "global") {
+        path = globalPath();
+      } else if (params.scope === "domain") {
+        path = domainPath(params.domain);
+      } else {
+        path = projectPath(ctx.cwd);
+      }
+
+      const data = await readLessonFile(path);
+
+      // Check for merge
+      if (params.merge_with) {
+        const existing = data.lessons.find((l) => l.id === params.merge_with);
+        if (existing) {
+          existing.rule = params.rule;
+          existing.rationale = params.rationale;
+          existing.domain = params.domain;
+          if (params.source_feedback_id) {
+            existing.source_feedback.push(params.source_feedback_id);
+          }
+          await writeLessonFile(path, data);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Leçon fusionnée: [${params.domain}] ${params.rule}`,
+              },
+            ],
+            details: { merged: true, id: existing.id },
+          };
+        }
+      }
+
+      // New lesson
+      const lesson: Lesson = {
+        id: `l-${generateId()}`,
+        created: timestamp(),
+        domain: params.domain,
+        rule: params.rule,
+        rationale: params.rationale,
+        source_feedback: params.source_feedback_id
+          ? [params.source_feedback_id]
+          : [],
+        positive_examples: 0,
+        violations: 0,
+        active: true,
+      };
+      data.lessons.push(lesson);
+      await writeLessonFile(path, data);
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Leçon sauvegardée (${params.scope}): [${params.domain}] ${params.rule}`,
+          },
+        ],
+        details: { id: lesson.id, scope: params.scope },
+      };
+    },
+  });
+
+  // ── Tool: list_lessons ─────────────────────────────────────────────────
+  // Let the agent query lessons programmatically
+  pi.registerTool({
+    name: "list_lessons",
+    label: "List Lessons",
+    description:
+      "Lister les leçons apprises pour un scope donné. Utile pour vérifier les leçons existantes avant d'en proposer une nouvelle.",
+    promptSnippet: "Lister les leçons d'auto-amélioration existantes",
+    parameters: Type.Object({
+      scope: Type.Union([
+        Type.Literal("global"),
+        Type.Literal("domain"),
+        Type.Literal("project"),
+        Type.Literal("all"),
+      ], { description: "Scope à lister" }),
+      domain: Type.Optional(
+        Type.Union([
+          Type.Literal("debug"),
+          Type.Literal("refactoring"),
+          Type.Literal("feature"),
+          Type.Literal("review"),
+          Type.Literal("general"),
+        ], { description: "Filtrer par domaine" })
+      ),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const results: { scope: string; lessons: Lesson[] }[] = [];
+
+      if (params.scope === "global" || params.scope === "all") {
+        const data = await readLessonFile(globalPath());
+        const filtered = params.domain
+          ? data.lessons.filter(
+              (l) => l.active && l.domain === params.domain
+            )
+          : data.lessons.filter((l) => l.active);
+        if (filtered.length > 0) results.push({ scope: "global", lessons: filtered });
+      }
+
+      if (params.scope === "domain" || params.scope === "all") {
+        if (params.domain) {
+          const data = await readLessonFile(domainPath(params.domain));
+          const filtered = data.lessons.filter((l) => l.active);
+          if (filtered.length > 0)
+            results.push({ scope: `domain-${params.domain}`, lessons: filtered });
+        } else {
+          for (const d of DOMAINS) {
+            const data = await readLessonFile(domainPath(d));
+            const filtered = data.lessons.filter((l) => l.active);
+            if (filtered.length > 0)
+              results.push({ scope: `domain-${d}`, lessons: filtered });
+          }
+        }
+      }
+
+      if (params.scope === "project" || params.scope === "all") {
+        const data = await readLessonFile(projectPath(ctx.cwd));
+        const filtered = params.domain
+          ? data.lessons.filter(
+              (l) => l.active && l.domain === params.domain
+            )
+          : data.lessons.filter((l) => l.active);
+        if (filtered.length > 0) results.push({ scope: "project", lessons: filtered });
+      }
+
+      if (results.length === 0) {
+        return {
+          content: [{ type: "text", text: "Aucune leçon trouvée pour ce scope/domaine." }],
+          details: {},
+        };
+      }
+
+      const lines = results.flatMap((r) =>
+        r.lessons.map(
+          (l) => `[${r.scope}][${l.domain}] ${l.id}: ${l.rule}`
+        )
+      );
+
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: { results },
+      };
+    },
+  });
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@devilnside/pi-auto-improve",
+  "version": "1.0.0",
+  "description": "Auto-improvement skill for Pi Coding Agent — feedback analysis, lesson generation and consolidation",
+  "keywords": ["pi-package"],
+  "license": "MIT",
+  "author": "ajoye",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/devilnside/pi-auto-improve"
+  },
+  "pi": {
+    "extensions": ["./extensions"],
+    "skills": ["./skills"]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  }
+}

package/skills/auto-improve/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: auto-improve
+description: "Use when the user gives negative feedback (👎, /bad) or asks to analyze a failure. Handles failure analysis, lesson generation, and lesson consolidation."
+---
+
+# Auto-Improve
+
+## Overview
+
+Analyse les échecs de l'agent, génère des leçons actionnables, et les consolide avec les leçons existantes. L'utilisateur valide chaque leçon avant stockage.
+
+## When to Use
+
+- L'utilisateur donne un feedback négatif (`/bad`, bouton 👎)
+- L'utilisateur donne un feedback positif (`/good`, bouton 👍)
+- L'utilisateur demande une analyse d'échec
+- L'utilisateur utilise `/lesson-add` ou `/lesson-remove`
+
+## Boutons Telegram — OBLIGATOIRE
+
+**À CHAQUE réponse** (sauf si la réponse EST un feedback `/good`/`/bad`), ajouter les boutons à la fin :
+
+```
+<!-- telegram_button label="👍" prompt="/good" -->
+<!-- telegram_button label="👎" prompt="/bad" -->
+```
+
+Ne PAS ajouter les boutons si :
+- La réponse est elle-même un traitement de feedback
+- L'utilisateur vient de cliquer 👍 ou 👎 (ça ferait une boucle)
+
+## Gestion des feedbacks entrants
+
+### Feedback positif (`/good`)
+
+1. Utiliser l'outil `save_lesson` avec `scope: "global"`, `domain: "general"`, une règle positive si pertinent, ou simplement accuser réception
+2. Répondre brièvement : "Merci ! 👍"
+3. NE PAS ajouter les boutons 👍/👎 à cette réponse
+
+### Feedback négatif (`/bad`)
+
+Suivre le processus d'analyse ci-dessous. NE PAS ajouter les boutons 👍/👎 à la réponse de validation de leçon.
+
+## Processus d'analyse (feedback négatif)
+
+```dot
+digraph analyze {
+  "Feedback négatif reçu" -> "Relire les derniers échanges (5-10 derniers messages)";
+  "Relire les derniers échanges" -> "Identifier la cause probable de l'insatisfaction";
+  "Identifier la cause probable" -> "Vérifier leçons existantes via list_lessons";
+  "Vérifier leçons existantes" -> "Leçon similaire?";
+  "Leçon similaire?" -> "Oui: Proposer fusion (affiner règle existante)" [label="Oui"];
+  "Leçon similaire?" -> "Non: Proposer nouvelle leçon" [label="Non"];
+  "Proposer fusion" -> "Présenter à l'utilisateur";
+  "Proposer nouvelle leçon" -> "Présenter à l'utilisateur";
+  "Présenter à l'utilisateur" -> "Validé?";
+  "Validé?" -> "Oui: Sauvegarder via save_lesson" [label="Oui"];
+  "Validé?" -> "Non: Ne rien stocker" [label="Non"];
+}
+```
+
+## Domaines
+
+| Domaine | Détection |
+|---------|-----------|
+| `debug` | Commandes de test, grep d'erreurs, stack traces |
+| `refactoring` | Modifications multiples de fichiers existants |
+| `feature` | Création de nouveaux fichiers, ajout de fonctionnalités |
+| `review` | Lecture de code sans modification |
+| `general` | Par défaut |
+
+## Format de leçon proposée
+
+Quand une leçon est proposée, la présenter ainsi :
+
+```
+📝 Nouvelle leçon proposée :
+   Domaine : [domaine]
+   Règle : [règle concise en français]
+   Justification : [pourquoi]
+
+Valider ? (oui/non)
+```
+
+## Format de fusion proposée
+
+```
+🔄 Fusion de leçons proposée :
+   Leçon existante : [ancienne règle]
+   Nouvelle règle fusionnée : [règle mise à jour]
+   Justification : [pourquoi la fusion]
+
+Valider ? (oui/non)
+```
+
+## Règles
+
+1. Toujours formuler les leçons en français, de manière concise et actionnable
+2. Toujours valider avec l'utilisateur avant de stocker via `save_lesson`
+3. Préférer fusionner plutôt que dupliquer
+4. Détecter le domaine automatiquement si possible, sinon `general`
+5. Ne jamais stocker sans validation explicite de l'utilisateur
+6. Sur Telegram, toujours inclure les boutons 👍/👎 sauf si la réponse est un traitement de feedback