palabre 0.1.5 → 0.2.0

package/dist/renderers/console.js

@@ -4,6 +4,10 @@ const supportsInteractiveOutput = Boolean(process.stdout.isTTY);
 export function createConsoleRenderer(plain) {
     return plain ? new PlainConsoleRenderer() : new PrettyConsoleRenderer(supportsColor, supportsInteractiveOutput);
 }
+/**
+ * Renderer interactif avec spinner, couleurs ANSI et encadrés de section.
+ * Utilisé quand `stdout` est un TTY et que `--plain` n'est pas passé.
+ */
 class PrettyConsoleRenderer {
     color;
     interactive;
@@ -11,10 +15,15 @@ class PrettyConsoleRenderer {
     spinnerFrame = 0;
     renderingSummary = false;
     frames = ["-", "\\", "|", "/"];
+    /**
+     * @param color - Active les codes couleur ANSI.
+     * @param interactive - Active le spinner en place (mode TTY interactif).
+     */
     constructor(color, interactive) {
         this.color = color;
         this.interactive = interactive;
     }
+    /** Affiche l'en-tête du débat (sujet, agents, options). */
     start(options, agents = []) {
         const title = "PALABRE";
         process.stdout.write([
@@ -29,21 +38,25 @@ class PrettyConsoleRenderer {
             ""
         ].join("\n"));
     }
+    /** Écrit un avertissement sur `stderr` en jaune. */
     warning(message) {
         process.stderr.write(`${this.c("yellow", "Warning:")} ${message}\n`);
     }
+    /** Écrit une notice informative sur `stdout` en vert. */
     notice(message) {
         process.stdout.write(`${this.c("green", "Info:")} ${message}\n`);
     }
+    /** Affiche l'en-tête d'un nouveau tour (agent, rôle, progression). */
     turnStart(turn, totalTurns, agent, role) {
         this.renderingSummary = false;
         process.stdout.write([
             "",
-            this.c("blue", `◆ ${agent}`) + this.dim(` · ${role} · tour ${turn}/${totalTurns}`),
+            this.c("orange", `◆ ${agent}`) + this.dim(` · ${role} · tour ${turn}/${totalTurns}`),
             this.dim("─".repeat(60)),
             ""
         ].join("\n"));
     }
+    /** Démarre le spinner de réflexion (ou affiche une ligne fixe si non interactif). */
     thinkingStart(agent, role) {
         this.thinkingEnd();
         const text = `${agent} (${role}) reflechit`;
@@ -59,6 +72,7 @@ class PrettyConsoleRenderer {
         render();
         this.spinner = setInterval(render, 120);
     }
+    /** Arrête le spinner et efface la ligne de réflexion en mode interactif. */
     thinkingEnd() {
         if (this.spinner) {
             clearInterval(this.spinner);
@@ -68,22 +82,29 @@ class PrettyConsoleRenderer {
             process.stdout.write("\r\u001b[2K");
         }
     }
+    /** Écrit le contenu d'un message agent, avec formatage de synthèse si applicable. */
     message(content) {
         const trimmed = content.trim();
         process.stdout.write(`${this.renderingSummary ? this.formatSummaryMessage(trimmed) : trimmed}\n`);
     }
+    /** Affiche l'en-tête de section synthèse et active le mode formatage de résumé. */
     summaryStart(agent, role) {
         this.renderingSummary = true;
         process.stdout.write([
             "",
-            this.c("magenta", `◆ Synthese`) + this.dim(` · ${agent} · ${role}`),
+            this.c("pink", `◆ Synthese`) + this.dim(` · ${agent} · ${role}`),
             this.dim("─".repeat(60)),
             ""
         ].join("\n"));
     }
+    /** Affiche le chemin du fichier de sortie en vert à la fin du débat. */
     done(outputPath) {
-        process.stdout.write(`\n${this.c("green", "Debat exporte:")} ${outputPath}\n`);
+        process.stdout.write(`\n\n${this.c("green", "Debat exporte:")} ${outputPath}\n\n`);
     }
+    /**
+     * Convertit les titres Markdown `### Heading` en titres colorés avec séparateur.
+     * @param content - Contenu texte de la synthèse.
+     */
     formatSummaryMessage(content) {
         return content
             .split(/\r?\n/)
@@ -93,66 +114,99 @@ class PrettyConsoleRenderer {
                 return line;
             return [
                 "",
-                this.c("magenta", heading[1] ?? line),
+                this.c("pink", heading[1] ?? line),
                 this.dim("─".repeat(40))
             ].join("\n");
         })
             .join("\n")
             .trimStart();
     }
+    /** Entoure `value` avec le code couleur ANSI si les couleurs sont activées. */
     c(color, value) {
         if (!this.color)
             return value;
         return `${codes[color]}${value}${codes.reset}`;
     }
+    /** Applique le style dim (atténué) si les couleurs sont activées. */
     dim(value) {
         if (!this.color)
             return value;
         return `${codes.dim}${value}${codes.reset}`;
     }
 }
+/**
+ * Renderer minimaliste sans couleurs ni spinner.
+ * Utilisé avec `--plain` ou quand `stdout` n'est pas un TTY.
+ */
 class PlainConsoleRenderer {
+    /** Affiche les informations de démarrage du débat en texte brut. */
     start(options, agents = []) {
         process.stdout.write(`Sujet: ${options.topic}` + "\n");
         process.stdout.write(`Agents: ${formatAgentPair(options, agents)}` + "\n");
         process.stdout.write(`Réponses: ${options.turns} | Synthèse: ${formatSummary(options)} | Contexte: ${formatContext(options)}` + "\n");
     }
+    /** Écrit un avertissement sur `stderr`. */
     warning(message) {
         process.stderr.write(`Warning: ${message}\n`);
     }
+    /** Écrit une notice informative sur `stdout`. */
     notice(message) {
         process.stdout.write(`Info: ${message}\n`);
     }
+    /** Affiche la progression du tour en texte brut. */
     turnStart(turn, totalTurns, agent, role) {
         process.stdout.write(`\n[${turn}/${totalTurns}] ${agent} (${role})...\n`);
     }
+    /** No-op : pas de spinner en mode plain. */
     thinkingStart(_agent, _role) { }
+    /** No-op : pas de spinner à arrêter en mode plain. */
     thinkingEnd() { }
+    /** Écrit le contenu du message agent trimé. */
     message(content) {
         process.stdout.write(`${content.trim()}\n`);
     }
+    /** Affiche l'en-tête de la section synthèse en texte brut. */
     summaryStart(agent, role) {
         process.stdout.write(`\n[Synthese] ${agent} (${role})...\n`);
     }
+    /** Affiche le chemin du fichier de sortie à la fin du débat. */
     done(outputPath) {
         process.stdout.write(`\nDebat exporte: ${outputPath}\n`);
     }
 }
+/**
+ * Formate la paire d'agents pour l'en-tête : utilise les infos enrichies si disponibles,
+ * sinon les noms bruts des options.
+ * @param options - Options du débat.
+ * @param agents - Infos de démarrage des agents (type, rôle, nom).
+ */
 function formatAgentPair(options, agents) {
     if (agents.length >= 2) {
         return `${formatAgentLabel(agents[0])} <-> ${formatAgentLabel(agents[1])}`;
     }
     return `${options.agentA} <-> ${options.agentB}`;
 }
+/**
+ * Formate un agent en `nom (rôle, type)` ou `"?"` si absent.
+ * @param agent - Info de démarrage de l'agent, ou `undefined`.
+ */
 function formatAgentLabel(agent) {
     if (!agent) {
         return "?";
     }
     return `${agent.name} (${agent.role}, ${agent.type})`;
 }
+/**
+ * Renvoie le nom de l'agent de synthèse ou `"désactivée"` si la synthèse est désactivée.
+ * @param options - Options du débat.
+ */
 function formatSummary(options) {
     return options.summaryEnabled ? options.summaryAgent ?? options.agentB : "désactivée";
 }
+/**
+ * Renvoie un résumé du contexte injecté (nombre de fichiers ou mention d'absence).
+ * @param options - Options du débat.
+ */
 function formatContext(options) {
     const count = options.files.length;
     if (count === 0) {
@@ -160,6 +214,7 @@ function formatContext(options) {
     }
     return `${count} fichier${count > 1 ? "s" : ""} injecté${count > 1 ? "s" : ""}`;
 }
+/** Codes d'échappement ANSI utilisés par `PrettyConsoleRenderer`. */
 const codes = {
     reset: "\u001b[0m",
     dim: "\u001b[2m",
@@ -167,5 +222,7 @@ const codes = {
     cyan: "\u001b[36m",
     green: "\u001b[32m",
     magenta: "\u001b[35m",
-    yellow: "\u001b[33m"
+    yellow: "\u001b[33m",
+    orange: "\u001b[38;5;208m",
+    pink: "\u001b[38;5;205m"
 };

package/dist/renderers/ndjson.js

@@ -0,0 +1,116 @@
+/**
+ * Renderer NDJSON : émet une ligne JSON par événement DebateRenderer.
+ *
+ * Cible : intégrations qui pilotent Palabre en out-of-process (extension
+ * VS Code, plugin Obsidian, scripts shell). Le rendu humain reste
+ * `PrettyConsoleRenderer` ou `PlainConsoleRenderer`.
+ *
+ * Contrat :
+ * - une ligne = un événement JSON valide, terminé par `\n` ;
+ * - tous les événements portent un champ `v` (entier) pour le versioning ;
+ * - toute évolution cassante du schéma doit incrémenter `v` et documenter
+ *   la migration dans AGENTS.md (section "Renderer NDJSON").
+ *
+ * Sortie : stdout uniquement. stderr reste libre pour les messages bas
+ * niveau (Node, shell) que les consommateurs peuvent agréger comme ils
+ * veulent.
+ */
+export class NdjsonRenderer {
+    schemaVersion = 1;
+    currentSection = "debate";
+    currentTurn = 0;
+    currentAgent = null;
+    currentRole = null;
+    /** Émet `start` avec le sujet, les agents, les options principales et le contexte de session. */
+    start(options, agents = []) {
+        this.emit({
+            type: "start",
+            topic: options.topic,
+            turns: options.turns,
+            agents: agents.map((a) => ({ name: a.name, role: a.role, type: a.type })),
+            summaryEnabled: options.summaryEnabled,
+            summaryAgent: options.summaryEnabled
+                ? options.summaryAgent ?? options.agentB
+                : null,
+            earlyStop: options.earlyStopOnAgreement,
+            filesCount: options.files.length,
+            session: {
+                startedAt: options.session.startedAt,
+                localDate: options.session.localDate,
+                timeZone: options.session.timeZone,
+                cwd: options.session.cwd,
+            },
+        });
+    }
+    /** Émet un événement informatif. */
+    notice(message) {
+        this.emit({ type: "notice", message });
+    }
+    /** Émet un avertissement. Reste sur stdout pour conserver l'ordre des événements. */
+    warning(message) {
+        this.emit({ type: "warning", message });
+    }
+    /** Émet `turn-start` et bascule la section courante en débat. */
+    turnStart(turn, totalTurns, agent, role) {
+        this.currentSection = "debate";
+        this.currentTurn = turn;
+        this.currentAgent = agent;
+        this.currentRole = role;
+        this.emit({ type: "turn-start", turn, totalTurns, agent, role });
+    }
+    /**
+     * Émet `thinking-start`. Les consommateurs UI peuvent l'utiliser pour un
+     * indicateur "agent en cours" ; les consommateurs purement data peuvent
+     * l'ignorer sans perte d'information sémantique.
+     */
+    thinkingStart(agent, role) {
+        this.emit({ type: "thinking-start", agent, role });
+    }
+    /** Émet `thinking-end`. */
+    thinkingEnd() {
+        this.emit({ type: "thinking-end" });
+    }
+    /**
+     * Émet `message` (section débat) ou `summary-message` (section synthèse)
+     * selon l'état courant. La discrimination par type permet aux
+     * consommateurs de router sans maintenir d'état eux-mêmes.
+     */
+    message(content) {
+        if (this.currentSection === "summary") {
+            this.emit({
+                type: "summary-message",
+                agent: this.currentAgent,
+                role: this.currentRole,
+                content,
+            });
+        }
+        else {
+            this.emit({
+                type: "message",
+                turn: this.currentTurn,
+                agent: this.currentAgent,
+                role: this.currentRole,
+                content,
+            });
+        }
+    }
+    /** Émet `summary-start` et bascule la section courante en synthèse. */
+    summaryStart(agent, role) {
+        this.currentSection = "summary";
+        this.currentAgent = agent;
+        this.currentRole = role;
+        this.emit({ type: "summary-start", agent, role });
+    }
+    /** Émet `done` avec le chemin du `.debate.md` écrit. */
+    done(outputPath) {
+        this.emit({ type: "done", outputPath });
+    }
+    /** Sérialise un événement et l'écrit sur stdout, terminé par `\n`. */
+    emit(event) {
+        process.stdout.write(JSON.stringify({ v: this.schemaVersion, ...event }) + "\n");
+    }
+}
+/** Factory pratique pour conserver la symétrie avec `createConsoleRenderer`. */
+export function createNdjsonRenderer() {
+    return new NdjsonRenderer();
+}

package/package.json

@@ -1,49 +1,50 @@
-{
-  "name": "palabre",
-  "version": "0.1.5",
-  "description": "Orchestrateur de debat entre agents IA locaux, CLIs et Ollama.",
-  "license": "MIT",
-  "type": "module",
-  "packageManager": "pnpm@10.18.3",
-  "homepage": "https://github.com/JuReyms/Palabre#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/JuReyms/Palabre.git"
-  },
-  "bugs": {
-    "url": "https://github.com/JuReyms/Palabre/issues"
-  },
-  "keywords": [
-    "ai",
-    "cli",
-    "agents",
-    "ollama",
-    "codex",
-    "claude",
-    "gemini",
-    "opencode"
-  ],
-  "bin": {
-    "palabre": "dist/index.js"
-  },
-  "files": [
-    "dist/",
-    "README.md",
-    "palabre.config.example.json"
-  ],
-  "scripts": {
-    "build": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
-    "check": "tsc -p tsconfig.json --noEmit",
-    "prepack": "pnpm build",
-    "start": "node ./dist/index.js",
-    "test": "pnpm build:test && node --test .tmp/test-dist/tests/*.test.js",
-    "build:test": "node -e \"fs.rmSync('.tmp/test-dist',{recursive:true,force:true})\" && tsc -p tsconfig.test.json"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "devDependencies": {
-    "@types/node": "^20.12.0",
-    "typescript": "^5.4.0"
-  }
-}
+{
+  "name": "palabre",
+  "version": "0.2.0",
+  "description": "Orchestrateur de debat entre agents IA locaux, CLIs et Ollama.",
+  "license": "MIT",
+  "type": "module",
+  "packageManager": "pnpm@10.18.3",
+  "homepage": "https://github.com/JuReyms/Palabre#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JuReyms/Palabre.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JuReyms/Palabre/issues"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "agents",
+    "ollama",
+    "codex",
+    "claude",
+    "opencode",
+    "debate",
+    "orchestrator"
+  ],
+  "bin": {
+    "palabre": "dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "palabre.config.example.json"
+  ],
+  "scripts": {
+    "build": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "prepack": "pnpm build",
+    "start": "node ./dist/index.js",
+    "test": "pnpm build:test && node --test .tmp/test-dist/tests/*.test.js",
+    "build:test": "node -e \"fs.rmSync('.tmp/test-dist',{recursive:true,force:true})\" && tsc -p tsconfig.test.json"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.0",
+    "typescript": "^5.4.0"
+  }
+}

package/palabre.config.example.json

@@ -66,7 +66,7 @@
       "shell": true,
       "role": "reviewer",
       "tier": "primary"
-    },
+    },
     "ollama-local": {
       "type": "ollama",
       "baseUrl": "http://localhost:11434",
@@ -78,4 +78,4 @@
       "unloadOtherModels": true
     }
   }
-}
+}