palabre 0.9.1 → 0.10.1

package/dist/new.js

@@ -1,9 +1,12 @@
+/** @file Assistant interactif `palabre new` : compose les mêmes flags qu'un lancement direct, sans second chemin d'exécution. */
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { isAgentDetected } from "./agentRegistry.js";
 import { discoverLocalTools } from "./discovery.js";
 import { findPresetNameForPair } from "./presets.js";
 import { MAX_TURNS, turnsOrDefault, validateTurns } from "./limits.js";
+import { accent, bold, brandHeader, card, clearScreen, dim, padBlock, supportsInteractiveOutput, surfaceWidth } from "./renderers/tui-theme.js";
+const interruptedAnswer = "\u0000palabre-interrupted";
 /**
  * Lance le wizard interactif `palabre new`.
  * Détecte les outils locaux, liste les agents de la config et guide la composition du débat.
@@ -17,10 +20,7 @@ export async function runNewWizard(config, messages) {
     }
     const rl = await createQuestioner();
     try {
-        console.log(messages.new.title);
-        console.log(messages.new.quitHint);
-        console.log(messages.new.defaultHint);
-        console.log("");
+        renderWizardIntro(messages);
         const mode = await askMode(rl, config.defaults?.mode ?? "debate", messages);
         if (!mode)
             return undefined;
@@ -175,11 +175,21 @@ async function askMode(rl, defaultMode, messages) {
         { value: "ask", label: messages.new.modeAsk }
     ];
     const fallback = choices.find((choice) => choice.value === defaultMode)?.value ?? "debate";
-    console.log(messages.new.mode);
-    choices.forEach((choice, index) => {
-        const marker = choice.value === fallback ? "(*)" : "   ";
-        console.log(`  ${index + 1}) ${marker} ${choice.label}`);
-    });
+    if (supportsInteractiveOutput) {
+        const lines = choices.map((choice, index) => {
+            const marker = choice.value === fallback ? accent("(*)") : "   ";
+            return `${bold(`${index + 1})`)} ${marker} ${choice.label}`;
+        });
+        console.log(padBlock(card(lines, surfaceWidth(), messages.new.mode)).join("\n"));
+        console.log("");
+    }
+    else {
+        console.log(messages.new.mode);
+        choices.forEach((choice, index) => {
+            const marker = choice.value === fallback ? "(*)" : "   ";
+            console.log(`  ${index + 1}) ${marker} ${choice.label}`);
+        });
+    }
     while (true) {
         const answer = await rl.question(`${messages.new.mode} [${fallback}]: `);
         const value = answer.trim().toLowerCase();
@@ -200,7 +210,33 @@ async function askMode(rl, defaultMode, messages) {
 }
 async function createQuestioner() {
     if (input.isTTY) {
-        return createInterface({ input, output });
+        const rl = createInterface({ input, output });
+        return {
+            question(prompt) {
+                return new Promise((resolve, reject) => {
+                    let settled = false;
+                    const cleanup = () => rl.off("SIGINT", onSigint);
+                    const settle = (value) => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        cleanup();
+                        resolve(value);
+                    };
+                    const onSigint = () => settle(interruptedAnswer);
+                    rl.once("SIGINT", onSigint);
+                    rl.question(prompt).then(settle, (error) => {
+                        if (settled)
+                            return;
+                        cleanup();
+                        reject(error);
+                    });
+                });
+            },
+            close() {
+                rl.close();
+            }
+        };
     }
     const lines = await readPipedLines();
     let index = 0;
@@ -375,7 +411,25 @@ function uniqueNames(names) {
     return names.filter((name, index) => names.indexOf(name) === index);
 }
 function isQuit(value) {
-    return ["q", "quit", "exit"].includes(value.toLowerCase());
+    return value === interruptedAnswer || ["q", "quit", "exit"].includes(value.toLowerCase());
+}
+function renderWizardIntro(messages) {
+    if (!supportsInteractiveOutput) {
+        console.log(messages.new.title);
+        console.log(messages.new.quitHint);
+        console.log(messages.new.defaultHint);
+        console.log("");
+        return;
+    }
+    clearScreen();
+    console.log("");
+    console.log(padBlock([brandHeader(messages.new.title)]).join("\n"));
+    console.log("");
+    console.log(padBlock([
+        dim(messages.new.quitHint),
+        dim(messages.new.defaultHint)
+    ]).join("\n"));
+    console.log("");
 }
 function printCommandPreview(selection, messages) {
     const explicitCommand = buildExplicitCommand(selection);

package/dist/ollamaUrl.js

@@ -1,4 +1,10 @@
+/** Serveur Ollama utilisé quand aucune autre source (flag, env, config) n'est fournie. */
 export const DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
+/**
+ * Erreur levée par `normalizeOllamaBaseUrl` quand la valeur fournie n'est pas une URL HTTP(S) exploitable.
+ * Le message du constructeur est un texte technique de repli non localisé ; les appelants CLI/TUI
+ * doivent reformater `kind`/`value`/`protocol` via les messages traduits plutôt que d'afficher ce message brut.
+ */
 export class OllamaUrlError extends Error {
     kind;
     value;
@@ -15,6 +21,20 @@ export class OllamaUrlError extends Error {
         this.name = "OllamaUrlError";
     }
 }
+/**
+ * Formate une `OllamaUrlError` en message localisé actionnable.
+ * Source unique du mapping `kind` → message, partagée entre le gestionnaire
+ * d'erreur du point d'entrée CLI et la conversion en `DebateFailure` de l'orchestrateur.
+ */
+export function formatOllamaUrlError(error, messages) {
+    if (error.kind === "empty") {
+        return messages.common.ollamaUrlEmpty;
+    }
+    if (error.kind === "protocol") {
+        return messages.common.ollamaUrlProtocol(error.protocol ?? "");
+    }
+    return messages.common.ollamaUrlInvalid(error.value);
+}
 /**
  * Résout l'adresse client Ollama selon la priorité produit :
  * flag CLI > OLLAMA_HOST > config agent > serveur local par défaut.

package/dist/orchestrator.js

@@ -1,9 +1,12 @@
+/** @file Boucle d'orchestration des modes `debate` et `ask` : tours, arrêt anticipé et synthèse finale. */
 import { createAgent } from "./adapters/index.js";
 import { AdapterError } from "./errors.js";
 import { createTranslator } from "./i18n.js";
 import { MAX_ASK_AGENTS } from "./limits.js";
-import { OllamaUrlError } from "./ollamaUrl.js";
+import { formatOllamaUrlError, OllamaUrlError } from "./ollamaUrl.js";
 export { MAX_ASK_AGENTS } from "./limits.js";
+/** Rôle imposé à l'agent de synthèse, indépendant de son rôle configuré. */
+const SUMMARY_ROLE = "summarizer";
 /**
  * Point d'entrée de l'orchestration.
  * Lance le ping-pong entre `agentA` et `agentB` pendant `options.turns` tours,
@@ -52,86 +55,36 @@ export async function runDebate(config, options, renderer, messages = createTran
         const peer = agents[(index + 1) % agents.length];
         const turn = index + 1;
         renderer?.turnStart(turn, options.turns, current.name, current.role);
-        renderer?.thinkingStart(current.name, current.role);
-        let response;
-        try {
-            response = await current.generate({
-                topic: options.topic,
-                turn,
-                totalTurns: options.turns,
-                selfName: current.name,
-                peerName: peer.name,
-                selfRole: current.role,
-                language: options.language,
-                session: options.session,
-                files: options.files,
-                transcript,
-                signal: options.signal
-            });
-        }
-        catch (error) {
-            const failure = toDebateFailure(error, {
-                phase: "debate",
-                agent: current.name,
-                role: current.role,
-                turn
-            }, messages);
-            renderer?.error(failure);
+        const outcome = await generateTurnMessage(current, {
+            topic: options.topic,
+            turn,
+            totalTurns: options.turns,
+            selfName: current.name,
+            peerName: peer.name,
+            selfRole: current.role,
+            language: options.language,
+            session: options.session,
+            files: options.files,
+            transcript,
+            signal: options.signal
+        }, { phase: "debate", agent: current.name, role: current.role, turn }, renderer, messages);
+        if (outcome.failure) {
             return {
                 options,
                 messages: transcript,
                 stopReason,
-                failure
+                failure: outcome.failure
             };
         }
-        finally {
-            renderer?.thinkingEnd();
-        }
-        const message = {
-            agent: current.name,
-            role: current.role,
-            content: response.content,
-            createdAt: new Date().toISOString()
-        };
-        transcript.push(message);
-        renderer?.message(message.content);
+        transcript.push(outcome.message);
+        renderer?.message(outcome.message.content);
         if (shouldStopOnAgreement(options, transcript, messages)) {
             stopReason = messages.orchestrator.agreementStopReason;
             renderer?.notice(messages.orchestrator.earlyStop(stopReason));
             break;
         }
     }
-    let summary;
-    let failure;
-    if (options.summaryEnabled) {
-        try {
-            const cancellation = cancellationFailureIfAborted(options, messages, {
-                phase: "summary",
-                agent: options.summaryAgent,
-                role: summaryRole(),
-                turn: transcript.length + 1
-            });
-            if (cancellation) {
-                renderer?.error(cancellation);
-                return {
-                    options,
-                    messages: transcript,
-                    stopReason,
-                    failure: cancellation
-                };
-            }
-            summary = await generateSummary(config, options, transcript, renderer, messages);
-        }
-        catch (error) {
-            failure = toDebateFailure(error, {
-                phase: "summary",
-                agent: options.summaryAgent,
-                role: summaryRole(),
-                turn: transcript.length + 1
-            }, messages);
-            renderer?.error(failure);
-        }
-    }
+    const { summary, failure } = await runSummaryPhase(config, options, transcript, renderer, messages);
     return {
         options,
         messages: transcript,
@@ -145,6 +98,8 @@ export async function runDebate(config, options, renderer, messages = createTran
  * puis un agent de synthèse résume fidèlement chaque réponse et les compare.
  */
 export async function runAsk(config, options, renderer, messages = createTranslator("fr")) {
+    // `runAsk` est appelable directement, hors du chemin CLI : on revalide la liste
+    // ask même si `resolveRunOptions` l'a déjà normalisée pour `palabre run`.
     const askAgentNames = resolveAskAgentNames(options);
     if (askAgentNames.length === 0) {
         throw new Error(messages.common.noAgentDefined("ask agent"));
@@ -159,7 +114,7 @@ export async function runAsk(config, options, renderer, messages = createTransla
         }
         return [name, agentConfig];
     });
-    warnIfOllamaHasNoContext(options, agentEntries.map(([name, agentConfig]) => [name, agentConfig]), renderer, messages);
+    warnIfOllamaHasNoContext(options, agentEntries, renderer, messages);
     renderer?.start(options, agentEntries.map(([name, agentConfig]) => ({
         name,
         role: agentConfig.role,
@@ -190,86 +145,36 @@ export async function runAsk(config, options, renderer, messages = createTransla
         else {
             renderer?.turnStart(response, agents.length, current.name, current.role);
         }
-        renderer?.thinkingStart(current.name, current.role);
-        let agentResponse;
-        try {
-            agentResponse = await current.generate({
-                topic: options.topic,
-                turn: response,
-                totalTurns: agents.length,
-                selfName: current.name,
-                peerName: "independent-agents",
-                selfRole: current.role,
-                mode: "ask",
-                language: options.language,
-                session: options.session,
-                files: options.files,
-                transcript: [],
-                signal: options.signal
-            });
-        }
-        catch (error) {
-            const failure = toDebateFailure(error, {
-                phase: "ask",
-                agent: current.name,
-                role: current.role,
-                turn: response
-            }, messages);
-            renderer?.error(failure);
+        const outcome = await generateTurnMessage(current, {
+            topic: options.topic,
+            turn: response,
+            totalTurns: agents.length,
+            selfName: current.name,
+            peerName: "independent-agents",
+            selfRole: current.role,
+            mode: "ask",
+            language: options.language,
+            session: options.session,
+            files: options.files,
+            transcript: [],
+            signal: options.signal
+        }, { phase: "ask", agent: current.name, role: current.role, turn: response }, renderer, messages);
+        if (outcome.failure) {
             return {
                 options,
                 messages: transcript,
-                failure
+                failure: outcome.failure
             };
         }
-        finally {
-            renderer?.thinkingEnd();
-        }
-        const message = {
-            agent: current.name,
-            role: current.role,
-            content: agentResponse.content,
-            createdAt: new Date().toISOString()
-        };
-        transcript.push(message);
+        transcript.push(outcome.message);
         if (renderer?.askResponseMessage) {
-            renderer.askResponseMessage(message.content);
+            renderer.askResponseMessage(outcome.message.content);
         }
         else {
-            renderer?.message(message.content);
-        }
-    }
-    let summary;
-    let failure;
-    if (options.summaryEnabled) {
-        try {
-            const summaryAgentName = options.summaryAgent;
-            const cancellation = cancellationFailureIfAborted(options, messages, {
-                phase: "summary",
-                agent: summaryAgentName,
-                role: summaryRole(),
-                turn: transcript.length + 1
-            });
-            if (cancellation) {
-                renderer?.error(cancellation);
-                return {
-                    options,
-                    messages: transcript,
-                    failure: cancellation
-                };
-            }
-            summary = await generateSummary(config, options, transcript, renderer, messages);
-        }
-        catch (error) {
-            failure = toDebateFailure(error, {
-                phase: "summary",
-                agent: options.summaryAgent,
-                role: summaryRole(),
-                turn: transcript.length + 1
-            }, messages);
-            renderer?.error(failure);
+            renderer?.message(outcome.message.content);
         }
     }
+    const { summary, failure } = await runSummaryPhase(config, options, transcript, renderer, messages);
     return {
         options,
         messages: transcript,
@@ -277,6 +182,62 @@ export async function runAsk(config, options, renderer, messages = createTransla
         failure
     };
 }
+/**
+ * Appelle `agent.generate` en encadrant l'état "thinking" du renderer, puis
+ * construit le `DebateMessage` horodaté ou convertit l'erreur en `DebateFailure`
+ * (notifiée au renderer). Mutualisé entre les tours `debate` et les réponses `ask`.
+ */
+async function generateTurnMessage(agent, prompt, context, renderer, messages) {
+    renderer?.thinkingStart(agent.name, agent.role);
+    try {
+        const response = await agent.generate(prompt);
+        return {
+            message: {
+                agent: agent.name,
+                role: agent.role,
+                content: response.content,
+                createdAt: new Date().toISOString()
+            }
+        };
+    }
+    catch (error) {
+        const failure = toDebateFailure(error, context, messages);
+        renderer?.error(failure);
+        return { failure };
+    }
+    finally {
+        renderer?.thinkingEnd();
+    }
+}
+/**
+ * Phase de synthèse commune aux modes `debate` et `ask` : vérifie l'annulation,
+ * génère la synthèse et convertit tout échec en `DebateFailure` déjà notifiée au
+ * renderer. Retourne un objet vide si la synthèse est désactivée.
+ */
+async function runSummaryPhase(config, options, transcript, renderer, messages) {
+    if (!options.summaryEnabled) {
+        return {};
+    }
+    const context = {
+        phase: "summary",
+        agent: options.summaryAgent,
+        role: SUMMARY_ROLE,
+        turn: transcript.length + 1
+    };
+    const cancellation = cancellationFailureIfAborted(options, messages, context);
+    if (cancellation) {
+        renderer?.error(cancellation);
+        return { failure: cancellation };
+    }
+    try {
+        return { summary: await generateSummary(config, options, transcript, renderer, messages) };
+    }
+    catch (error) {
+        const failure = toDebateFailure(error, context, messages);
+        renderer?.error(failure);
+        return { failure };
+    }
+}
 /**
  * Heuristique d'arrêt sur accord explicite.
  * Ne s'active qu'après un tour complet (nombre pair de messages) pour éviter les faux positifs.
@@ -338,7 +299,7 @@ async function generateSummary(config, options, transcript, renderer, messages =
         throw new Error(messages.orchestrator.unknownSummaryAgent(summaryAgentName));
     }
     const summaryAgent = createAgent(summaryAgentName, summaryConfig, { ollamaUrl: options.ollamaUrl });
-    const role = summaryRole();
+    const role = SUMMARY_ROLE;
     renderer?.summaryStart(summaryAgent.name, role);
     renderer?.thinkingStart(summaryAgent.name, role);
     const response = await summaryAgent.generate({
@@ -364,9 +325,6 @@ async function generateSummary(config, options, transcript, renderer, messages =
     renderer?.message(summary.content);
     return summary;
 }
-function summaryRole() {
-    return "summarizer";
-}
 function cancellationFailureIfAborted(options, messages, context) {
     if (!options.signal?.aborted) {
         return undefined;
@@ -399,15 +357,10 @@ function toDebateFailure(error, context, messages) {
         };
     }
     if (error instanceof OllamaUrlError) {
-        const message = error.kind === "empty"
-            ? messages.common.ollamaUrlEmpty
-            : error.kind === "protocol"
-                ? messages.common.ollamaUrlProtocol(error.protocol ?? "")
-                : messages.common.ollamaUrlInvalid(error.value);
         return {
             ...context,
             kind: "unknown",
-            message
+            message: formatOllamaUrlError(error, messages)
         };
     }
     return {

package/dist/output.js

@@ -1,3 +1,4 @@
+/** @file Export Markdown `.debate.md`/`.ask.md` : transcript, table de métadonnées et synthèse finale. */
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createTranslator } from "./i18n.js";

package/dist/presets.js

@@ -1,3 +1,4 @@
+/** @file Source de vérité des presets de paires d'agents et de leur disponibilité calculée. */
 import { detectionForCommand, isRetiredAgentName } from "./agentRegistry.js";
 const presets = {
     "codex-claude": {

package/dist/prompt.js

@@ -1,3 +1,4 @@
+/** @file Rendu des prompts agent (débat, ask, synthèse) avec contexte de session, fichiers et transcript. */
 import { createTranslator } from "./i18n.js";
 /**
  * Formate le prompt complet transmis à l'adapter.

package/dist/renderers/console.js

@@ -255,7 +255,7 @@ function formatContext(options, messages) {
     if (count === 0) {
         return messages.renderers.noInjectedFiles;
     }
-    return messages.renderers.injectedFiles(count);
+    return messages.renderers.injectedFiles(count, options.files.map((file) => file.path));
 }
 function formatFailureLocation(failure, messages) {
     if (failure.phase === "summary") {