palabre 0.9.1 → 0.10.0

package/dist/messages/adapter-errors.js

@@ -29,10 +29,34 @@ const enHints = {
 export const adapterErrorMessages = {
     fr: {
         suggestionPrefix: "Suggestion",
-        hint: (kind) => frHints[kind]
+        hint: (kind) => frHints[kind],
+        usageLimit: (adapterName, detail) => `${adapterName} a atteint une limite d'utilisation: ${detail}`,
+        unsupportedModel: (adapterName, detail) => `${adapterName} ne peut pas utiliser ce modèle: ${detail}`,
+        noStderrCaptured: "aucun stderr capturé.",
+        noPtyOutputCaptured: "aucune sortie PTY capturée.",
+        ollamaModelUnavailable: (model, installedModels) => `Modèle Ollama indisponible: ${model}. Modèles détectés: ${installedModels.join(", ") || "aucun"}. ` +
+            "Utilise --pull-models ou autoPullModel: true pour autoriser le téléchargement.",
+        ollamaModelStillUnavailable: (model) => `Le modèle Ollama ${model} reste indisponible après téléchargement.`,
+        ollamaPullProgress: (model) => `[ollama] Modèle absent, téléchargement: ${model}`,
+        ollamaPullFailed: (model, detail) => `Échec du téléchargement Ollama ${model}: ${detail}`,
+        ollamaTagsHttpError: (status) => `Ollama HTTP ${status} pendant la détection des modèles`,
+        ollamaPsHttpError: (status) => `Ollama HTTP ${status} pendant la détection des modèles chargés`,
+        ollamaUnloadFailed: (model, status) => `Impossible de décharger le modèle Ollama ${model}: HTTP ${status}`
     },
     en: {
         suggestionPrefix: "Suggestion",
-        hint: (kind) => enHints[kind]
+        hint: (kind) => enHints[kind],
+        usageLimit: (adapterName, detail) => `${adapterName} hit a usage limit: ${detail}`,
+        unsupportedModel: (adapterName, detail) => `${adapterName} cannot use this model: ${detail}`,
+        noStderrCaptured: "no stderr captured.",
+        noPtyOutputCaptured: "no PTY output captured.",
+        ollamaModelUnavailable: (model, installedModels) => `Ollama model unavailable: ${model}. Detected models: ${installedModels.join(", ") || "none"}. ` +
+            "Use --pull-models or autoPullModel: true to allow downloading.",
+        ollamaModelStillUnavailable: (model) => `Ollama model ${model} is still unavailable after downloading.`,
+        ollamaPullProgress: (model) => `[ollama] Model missing, downloading: ${model}`,
+        ollamaPullFailed: (model, detail) => `Ollama download failed for ${model}: ${detail}`,
+        ollamaTagsHttpError: (status) => `Ollama HTTP ${status} while detecting models`,
+        ollamaPsHttpError: (status) => `Ollama HTTP ${status} while detecting loaded models`,
+        ollamaUnloadFailed: (model, status) => `Failed to unload Ollama model ${model}: HTTP ${status}`
     }
 };

package/dist/messages/config.js

@@ -9,6 +9,9 @@ export const configMessages = {
         ollamaModelUnavailable: (model) => `Modèle Ollama non installé: ${model}. Action: choisis un modèle installé ou lance \`ollama pull ${model}\`.`,
         ollamaModelNoAgent: "Agent ollama-local absent ou invalide dans la config.",
         ollamaModelNoInstalledModels: "Aucun modèle Ollama installé détecté. Action: lance `ollama pull <modèle>`.",
+        ollamaModelsCurrent: (model) => `ollama-local: ${model ?? "(non configuré)"}`,
+        ollamaModelsApi: (available, baseUrl) => `Ollama API: ${available ? "joignable" : "indisponible"} (${baseUrl})`,
+        ollamaModelsInstalled: (models) => `Modèles installés: ${models.length > 0 ? models.join(", ") : "(aucun)"}`,
         updated: (path, defaults, language) => `Configuration mise à jour dans ${path}: ${defaults}, langue: ${language}.`,
         cleared: (path) => `Paramètres par défaut supprimés dans ${path}. Utilise maintenant un preset ou --agent-a/--agent-b pour lancer un débat.`,
         defaultsSummary: (agentA, agentB, turns, summaryAgent, askSummaryAgent, mode, askAgents, interfaceName) => {
@@ -63,6 +66,9 @@ export const configMessages = {
         ollamaModelUnavailable: (model) => `Ollama model is not installed: ${model}. Action: choose an installed model or run \`ollama pull ${model}\`.`,
         ollamaModelNoAgent: "ollama-local agent is missing or invalid in the config.",
         ollamaModelNoInstalledModels: "No installed Ollama model detected. Action: run `ollama pull <model>`.",
+        ollamaModelsCurrent: (model) => `ollama-local: ${model ?? "(not configured)"}`,
+        ollamaModelsApi: (available, baseUrl) => `Ollama API: ${available ? "reachable" : "unavailable"} (${baseUrl})`,
+        ollamaModelsInstalled: (models) => `Installed models: ${models.length > 0 ? models.join(", ") : "(none)"}`,
         updated: (path, defaults, language) => `Configuration updated in ${path}: ${defaults}, language: ${language}.`,
         cleared: (path) => `Default settings cleared in ${path}. Use a preset or --agent-a/--agent-b to start a debate now.`,
         defaultsSummary: (agentA, agentB, turns, summaryAgent, askSummaryAgent, mode, askAgents, interfaceName) => {

package/dist/messages/index.js

@@ -16,6 +16,7 @@ import { previewMessages } from "./preview.js";
 import { rendererMessages } from "./renderers.js";
 import { tuiMessages } from "./tui.js";
 import { updateMessages } from "./update.js";
+/** Construit le dictionnaire `Messages` pour `language`, en assemblant chaque domaine indépendamment. */
 export function createTranslator(language) {
     return {
         adapterErrors: adapterErrorMessages[language],

package/dist/messages/renderers.js

@@ -1,3 +1,9 @@
+/** Tronque une liste de chemins pour l'affichage : 3 premiers + compteur du reste. */
+function summarizePaths(paths) {
+    const shown = paths.slice(0, 3);
+    const extra = paths.length - shown.length;
+    return `${shown.join(", ")}${extra > 0 ? ` (+${extra})` : ""}`;
+}
 export const rendererMessages = {
     fr: {
         subject: (topic) => `Sujet: ${topic}`,
@@ -5,6 +11,7 @@ export const rendererMessages = {
         responsesSummaryContext: (turns, summary, context) => `Réponses: ${turns} | Synthèse: ${summary} | Contexte: ${context}`,
         responsesSummary: (turns, summary) => `Réponses: ${turns} | Synthèse: ${summary}`,
         context: (context) => `Contexte: ${context}`,
+        workingFolder: (path) => `Dossier: ${path}`,
         options: (earlyStop, pullModels) => `Options: arrêt anticipé ${earlyStop ? "activé" : "désactivé"}, auto-pull Ollama ${pullModels ? "activé" : "désactivé"}`,
         enabled: "activé",
         disabled: "désactivée",
@@ -15,7 +22,7 @@ export const rendererMessages = {
         summaryTitle: "Synthese",
         exported: (path) => `Palabre exporte: ${path}`,
         noInjectedFiles: "aucun fichier injecté",
-        injectedFiles: (count) => `${count} fichier${count > 1 ? "s" : ""} injecté${count > 1 ? "s" : ""}`
+        injectedFiles: (count, paths) => `${count} fichier${count > 1 ? "s" : ""} injecté${count > 1 ? "s" : ""} : ${summarizePaths(paths)}`
     },
     en: {
         subject: (topic) => `Subject: ${topic}`,
@@ -23,6 +30,7 @@ export const rendererMessages = {
         responsesSummaryContext: (turns, summary, context) => `Responses: ${turns} | Summary: ${summary} | Context: ${context}`,
         responsesSummary: (turns, summary) => `Responses: ${turns} | Summary: ${summary}`,
         context: (context) => `Context: ${context}`,
+        workingFolder: (path) => `Folder: ${path}`,
         options: (earlyStop, pullModels) => `Options: early stop ${earlyStop ? "enabled" : "disabled"}, Ollama auto-pull ${pullModels ? "enabled" : "disabled"}`,
         enabled: "enabled",
         disabled: "disabled",
@@ -33,6 +41,6 @@ export const rendererMessages = {
         summaryTitle: "Summary",
         exported: (path) => `Palabre exported: ${path}`,
         noInjectedFiles: "no injected files",
-        injectedFiles: (count) => `${count} injected file${count > 1 ? "s" : ""}`
+        injectedFiles: (count, paths) => `${count} injected file${count > 1 ? "s" : ""}: ${summarizePaths(paths)}`
     }
 };

package/dist/messages/tui.js

@@ -9,7 +9,7 @@ export const tuiMessages = {
         roles: "Roles",
         summary: "Synthese",
         ollamaModel: "Modele Ollama",
-        ollamaUrl: "Adresse Ollama configuree",
+        ollamaUrl: "Adresse Ollama",
         ollamaUrlEffective: "Adresse Ollama effective",
         responses: "Tours",
         folder: "Dossier",
@@ -53,6 +53,9 @@ export const tuiMessages = {
         roleReviewer: "cherche risques et tests manquants",
         roleSummarizer: "synthetise fidelement",
         configTitle: "Configuration Palabre",
+        configSectionGeneral: "Général",
+        exportedFile: "Fichier exporté",
+        exportedFolder: "Dossier d'export",
         configFile: "Config",
         interface: "Interface",
         language: "Langue",
@@ -129,7 +132,7 @@ export const tuiMessages = {
         roles: "Roles",
         summary: "Summary",
         ollamaModel: "Ollama model",
-        ollamaUrl: "Configured Ollama address",
+        ollamaUrl: "Ollama address",
         ollamaUrlEffective: "Effective Ollama address",
         responses: "Turns",
         folder: "Folder",
@@ -173,6 +176,9 @@ export const tuiMessages = {
         roleReviewer: "looks for risks and missing tests",
         roleSummarizer: "summarizes faithfully",
         configTitle: "Palabre Configuration",
+        configSectionGeneral: "General",
+        exportedFile: "Exported file",
+        exportedFolder: "Export folder",
         configFile: "Config",
         interface: "Interface",
         language: "Language",

package/dist/new.js

@@ -1,3 +1,4 @@
+/** @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";

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") {