palabre 0.3.0 → 0.6.0

package/dist/context.js

@@ -1,5 +1,6 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
+import { createTranslator } from "./i18n.js";
 const MAX_FILE_BYTES = 64 * 1024;
 const MAX_TOTAL_BYTES = 192 * 1024;
 const DEFAULT_EXCLUDED_NAMES = new Set([
@@ -32,8 +33,8 @@ const TEXT_EXTENSIONS = new Set([
  * Mode strict (`--files`) : charge uniquement les fichiers explicitement listés.
  * Lève une erreur si un chemin est un dossier, un binaire, ou dépasse 64 KiB / 192 KiB au total.
  */
-export async function loadProjectFiles(paths, cwd = process.cwd()) {
-    const result = await loadProjectInputs(paths, [], cwd);
+export async function loadProjectFiles(paths, cwd = process.cwd(), messages = createTranslator("fr")) {
+    const result = await loadProjectInputs(paths, [], cwd, messages);
     return result.files;
 }
 /**
@@ -41,13 +42,14 @@ export async function loadProjectFiles(paths, cwd = process.cwd()) {
  * Les fichiers explicites sont chargés en premier et comptent dans le budget total.
  * Les chemins de contexte acceptent fichiers et dossiers ; les fichiers ignorés génèrent des warnings, pas des erreurs.
  */
-export async function loadProjectInputs(filePaths, contextPaths, cwd = process.cwd()) {
+export async function loadProjectInputs(filePaths, contextPaths, cwd = process.cwd(), messages = createTranslator("fr")) {
     const state = {
         files: [],
         warnings: [],
         seen: new Set(),
         totalBytes: 0,
-        gitignoreRules: await loadGitignoreRules(cwd)
+        gitignoreRules: await loadGitignoreRules(cwd),
+        messages
     };
     await addExplicitFiles(filePaths, cwd, state);
     await addContextPaths(contextPaths, cwd, state);
@@ -62,14 +64,14 @@ async function addExplicitFiles(paths, cwd, state) {
         const absolutePath = path.resolve(cwd, inputPath);
         const fileStat = await stat(absolutePath);
         if (!fileStat.isFile()) {
-            throw new Error(`Le contexte fichier doit pointer vers un fichier: ${inputPath}`);
+            throw new Error(state.messages.context.explicitMustBeFile(inputPath));
         }
         if (fileStat.size > MAX_FILE_BYTES) {
-            throw new Error(`Fichier trop gros pour le contexte: ${inputPath} (${fileStat.size} bytes, max ${MAX_FILE_BYTES})`);
+            throw new Error(state.messages.context.explicitTooLarge(inputPath, fileStat.size, MAX_FILE_BYTES));
         }
         const content = await readFile(absolutePath, "utf8");
         if (content.includes("\u0000")) {
-            throw new Error(`Fichier binaire ou non texte refuse: ${inputPath}`);
+            throw new Error(state.messages.context.explicitBinary(inputPath));
         }
         addFileToState(cwd, state, absolutePath, content, fileStat.size, "explicit");
     }
@@ -84,7 +86,7 @@ async function addContextPaths(paths, cwd, state) {
             continue;
         }
         if (!fileStat.isDirectory()) {
-            state.warnings.push(`Contexte ignore (ni fichier ni dossier): ${inputPath}`);
+            state.warnings.push(state.messages.context.ignoredNotFileOrDirectory(inputPath));
             continue;
         }
         await walkContextDirectory(absolutePath, cwd, state);
@@ -113,21 +115,21 @@ async function addContextFile(absolutePath, cwd, state) {
         return;
     }
     if (!isLikelyTextFile(absolutePath)) {
-        state.warnings.push(`Contexte ignore (extension non texte): ${relativePath}`);
+        state.warnings.push(state.messages.context.ignoredNonTextExtension(relativePath));
         return;
     }
     const fileStat = await stat(absolutePath);
     if (fileStat.size > MAX_FILE_BYTES) {
-        state.warnings.push(`Contexte ignore (fichier trop gros): ${relativePath} (${fileStat.size} bytes)`);
+        state.warnings.push(state.messages.context.ignoredTooLarge(relativePath, fileStat.size));
         return;
     }
     if (state.totalBytes + fileStat.size > MAX_TOTAL_BYTES) {
-        state.warnings.push(`Contexte ignore (limite totale atteinte): ${relativePath}`);
+        state.warnings.push(state.messages.context.ignoredTotalLimit(relativePath));
         return;
     }
     const content = await readFile(absolutePath, "utf8");
     if (content.includes("\u0000")) {
-        state.warnings.push(`Contexte ignore (binaire detecte): ${relativePath}`);
+        state.warnings.push(state.messages.context.ignoredBinary(relativePath));
         return;
     }
     addFileToState(cwd, state, absolutePath, content, fileStat.size, "context");
@@ -138,9 +140,9 @@ function addFileToState(cwd, state, absolutePath, content, sizeBytes, source) {
     }
     if (state.totalBytes + sizeBytes > MAX_TOTAL_BYTES) {
         if (source === "explicit") {
-            throw new Error(`Contexte fichiers trop gros (${state.totalBytes + sizeBytes} bytes, max ${MAX_TOTAL_BYTES})`);
+            throw new Error(state.messages.context.explicitTotalTooLarge(state.totalBytes + sizeBytes, MAX_TOTAL_BYTES));
         }
-        state.warnings.push(`Contexte ignore (limite totale atteinte): ${normalizePath(path.relative(cwd, absolutePath))}`);
+        state.warnings.push(state.messages.context.ignoredTotalLimit(normalizePath(path.relative(cwd, absolutePath))));
         return;
     }
     state.seen.add(absolutePath);

package/dist/discovery.js

@@ -5,10 +5,11 @@ import path from "node:path";
  * Sur Windows, tente `claude.exe` avant `claude`.
  */
 export async function discoverLocalTools() {
-    const [codex, claude, gemini, opencode, ollamaCommand] = await Promise.all([
+    const [codex, claude, gemini, antigravity, opencode, ollamaCommand] = await Promise.all([
         detectCommand("codex"),
         detectFirstCommand(process.platform === "win32" ? ["claude.exe", "claude"] : ["claude"]),
         detectCommand("gemini"),
+        detectCommand("agy"),
         detectCommand("opencode"),
         detectCommand("ollama")
     ]);
@@ -17,6 +18,7 @@ export async function discoverLocalTools() {
         codex,
         claude,
         gemini,
+        antigravity,
         opencode,
         ollama: {
             ...ollamaServer,

package/dist/doctor.js

@@ -1,218 +1,238 @@
 import path from "node:path";
 import { stat } from "node:fs/promises";
-import { configExists, loadConfig, resolveDefaultConfigPath } from "./config.js";
+import { configExists, loadConfig, resolveDefaultConfigPath, resolveOutputDir } from "./config.js";
 import { discoverLocalTools } from "./discovery.js";
+import { createTranslator, resolveLanguage } from "./i18n.js";
 import { DEFAULT_TURNS, MAX_TURNS } from "./limits.js";
 /**
  * Exécute le diagnostic complet : config, outils locaux et agents.
  * Retourne toujours un résultat (pas de throw) ; les erreurs de config sont reportées comme lignes `error`.
  */
-export async function runDoctor(explicitConfigPath, plain = false) {
+export async function runDoctor(explicitConfigPath, plain = false, explicitLanguage) {
     const lines = [];
     const configPath = explicitConfigPath ?? await resolveDefaultConfigPath();
     const hasConfig = await configExists(configPath);
-    lines.push(info("PALABRE doctor"));
-    lines.push(info(`Dossier courant: ${process.cwd()}`));
+    const config = hasConfig ? await loadConfigSafely(configPath) : undefined;
+    const language = resolveLanguage({
+        explicitLanguage,
+        configLanguage: config?.language
+    });
+    const t = createTranslator(language);
+    lines.push(info(t.doctor.title, "title"));
+    lines.push(info(t.doctor.currentDirectory(process.cwd()), "cwd"));
     lines.push(hasConfig
-        ? ok(`Config trouvee: ${configPath}`)
-        : error(`Config absente: ${configPath}`));
+        ? ok(t.doctor.configFound(configPath))
+        : error(t.doctor.configMissing(configPath)));
     if (!hasConfig) {
-        lines.push(info("Action: lance `palabre init` pour creer la config globale, ou `palabre init --local` pour une config projet."));
-        return render(lines, plain);
+        lines.push(info(t.doctor.noConfigAction));
+        return render(lines, plain, t);
     }
-    const config = await loadConfigSafely(configPath, lines);
     if (!config) {
-        return render(lines, plain);
+        const loadError = await getConfigLoadError(configPath);
+        lines.push(error(t.doctor.configUnreadable(loadError)));
+        lines.push(info(t.doctor.configUnreadableAction));
+        return render(lines, plain, t);
     }
-    await inspectConfig(config, lines);
+    lines.push(ok(t.doctor.configReadable));
+    lines.push(ok(t.doctor.interfaceLanguage(language)));
+    await inspectConfig(config, lines, t);
     const discovery = await discoverLocalTools();
-    lines.push(info("Outils locaux:"));
-    lines.push(formatCommand("Codex CLI", discovery.codex.available, discovery.codex.command, discovery.codex.path));
-    lines.push(formatCommand("Claude CLI", discovery.claude.available, discovery.claude.command, discovery.claude.path));
-    lines.push(formatCommand("Gemini CLI", discovery.gemini.available, discovery.gemini.command, discovery.gemini.path));
-    lines.push(formatCommand("OpenCode CLI", discovery.opencode.available, discovery.opencode.command, discovery.opencode.path));
+    lines.push(info(t.doctor.localTools, "tools"));
+    lines.push(formatCommand("Codex CLI", discovery.codex.available, discovery.codex.command, discovery.codex.path, t));
+    lines.push(formatCommand("Claude CLI", discovery.claude.available, discovery.claude.command, discovery.claude.path, t));
+    lines.push(formatCommand("Gemini CLI", discovery.gemini.available, discovery.gemini.command, discovery.gemini.path, t));
+    lines.push(formatCommand("Antigravity CLI", discovery.antigravity.available, discovery.antigravity.command, discovery.antigravity.path, t));
+    lines.push(formatCommand("OpenCode CLI", discovery.opencode.available, discovery.opencode.command, discovery.opencode.path, t));
     lines.push(discovery.ollama.available
-        ? ok(`Ollama API joignable: ${discovery.ollama.baseUrl} (${discovery.ollama.models.length} modele(s))`)
+        ? ok(t.doctor.ollamaReachable(discovery.ollama.baseUrl, discovery.ollama.models.length))
         : warn(discovery.ollama.commandAvailable
-            ? `Ollama installe mais API non joignable: ${discovery.ollama.baseUrl}${formatErrorSuffix(discovery.ollama.error)}`
-            : `Ollama non detecte et API non joignable: ${discovery.ollama.baseUrl}${formatErrorSuffix(discovery.ollama.error)}`));
-    inspectDetectedMissingAgents(config, discovery, lines);
-    inspectAgents(config, discovery, lines);
-    return render(lines, plain);
+            ? t.doctor.ollamaInstalledNoApi(discovery.ollama.baseUrl, formatErrorSuffix(discovery.ollama.error))
+            : t.doctor.ollamaMissingNoApi(discovery.ollama.baseUrl, formatErrorSuffix(discovery.ollama.error))));
+    inspectDetectedMissingAgents(config, discovery, lines, t);
+    inspectAgents(config, discovery, lines, t);
+    return render(lines, plain, t);
 }
-async function loadConfigSafely(configPath, lines) {
+async function loadConfigSafely(configPath) {
     try {
-        const config = await loadConfig(configPath);
-        lines.push(ok("Config JSON lisible."));
-        return config;
+        return await loadConfig(configPath);
     }
-    catch (loadError) {
-        const message = loadError instanceof Error ? loadError.message : String(loadError);
-        lines.push(error(`Config illisible: ${message}`));
-        lines.push(info("Action: corrige le JSON ou relance `palabre init --config <path>` vers un nouveau fichier."));
+    catch {
         return undefined;
     }
 }
-async function inspectConfig(config, lines) {
+async function getConfigLoadError(configPath) {
+    try {
+        await loadConfig(configPath);
+        return "";
+    }
+    catch (loadError) {
+        return loadError instanceof Error ? loadError.message : String(loadError);
+    }
+}
+async function inspectConfig(config, lines, t) {
     const agentNames = Object.keys(config.agents ?? {});
     if (agentNames.length === 0) {
-        lines.push(error("Aucun agent configure."));
+        lines.push(error(t.doctor.noAgents));
     }
     else if (agentNames.length === 1) {
-        lines.push(warn(`1 agent configure: ${agentNames[0]}. Palabre fonctionne mieux avec au moins deux agents.`));
+        lines.push(warn(t.doctor.oneAgent(agentNames[0])));
     }
     else {
-        lines.push(ok(`${agentNames.length} agent(s) configure(s): ${agentNames.join(", ")}`));
+        lines.push(ok(t.doctor.agentCount(agentNames.length, agentNames.join(", "))));
     }
-    inspectDefaultAgent("defaults.agentA", config.defaults?.agentA, config, lines);
-    inspectDefaultAgent("defaults.agentB", config.defaults?.agentB, config, lines);
-    inspectDefaultPair(config, lines);
-    inspectDefaultTurns(config.defaults?.turns, lines);
+    inspectDefaultAgent("defaults.agentA", config.defaults?.agentA, config, lines, t);
+    inspectDefaultAgent("defaults.agentB", config.defaults?.agentB, config, lines, t);
+    inspectDefaultPair(config, lines, t);
+    inspectDefaultTurns(config.defaults?.turns, lines, t);
     if (config.defaults?.summaryAgent) {
-        inspectDefaultAgent("defaults.summaryAgent", config.defaults.summaryAgent, config, lines);
+        inspectDefaultAgent("defaults.summaryAgent", config.defaults.summaryAgent, config, lines, t);
     }
     else {
-        lines.push(warn("defaults.summaryAgent absent: la synthese utilisera agentB."));
+        lines.push(warn(t.doctor.summaryAgentMissing));
     }
-    await inspectOutputDir(config.outputDir, lines);
+    await inspectOutputDir(config.outputDir, lines, t);
 }
-function inspectDefaultAgent(label, agentName, config, lines) {
+function inspectDefaultAgent(label, agentName, config, lines, t) {
     if (!agentName) {
-        lines.push(warn(`${label} absent.`));
+        lines.push(warn(t.doctor.defaultAgentMissing(label)));
         return;
     }
     if (!config.agents[agentName]) {
-        lines.push(error(`${label} pointe vers un agent inconnu: ${agentName}`));
+        lines.push(error(t.doctor.defaultAgentUnknown(label, agentName)));
         return;
     }
-    lines.push(ok(`${label}: ${agentName}`));
+    lines.push(ok(t.doctor.defaultAgentOk(label, agentName)));
 }
-function inspectDefaultPair(config, lines) {
+function inspectDefaultPair(config, lines, t) {
     const { agentA, agentB } = config.defaults ?? {};
     if (!agentA || !agentB) {
-        lines.push(warn("Paire par defaut incomplete. Action: `palabre config --set-defaults <agentA> <agentB>`."));
+        lines.push(warn(t.doctor.defaultPairIncomplete));
         return;
     }
     if (agentA === agentB) {
-        lines.push(warn(`defaults.agentA et defaults.agentB pointent vers le meme agent (${agentA}). C'est possible, mais souvent moins utile qu'une vraie paire.`));
+        lines.push(warn(t.doctor.sameDefaultAgent(agentA)));
     }
 }
-function inspectDefaultTurns(turns, lines) {
+function inspectDefaultTurns(turns, lines, t) {
     const value = turns ?? DEFAULT_TURNS;
     if (turns === undefined) {
-        lines.push(info(`defaults.turns absent: Palabre utilisera ${DEFAULT_TURNS} reponses.`));
+        lines.push(info(t.doctor.defaultTurnsMissing(DEFAULT_TURNS)));
         return;
     }
     if (!Number.isInteger(value) || value < 1 || value > MAX_TURNS) {
-        lines.push(error(`defaults.turns invalide: ${String(turns)}. Action: choisis un entier entre 1 et ${MAX_TURNS}.`));
+        lines.push(error(t.doctor.defaultTurnsInvalid(String(turns), MAX_TURNS)));
         return;
     }
-    lines.push(ok(`defaults.turns: ${value}`));
+    lines.push(ok(t.doctor.defaultTurnsOk(value)));
 }
-async function inspectOutputDir(outputDir, lines) {
-    const resolved = path.resolve(outputDir ?? ".");
+async function inspectOutputDir(outputDir, lines, t) {
+    const effectiveOutputDir = resolveOutputDir(outputDir);
+    const resolved = path.resolve(effectiveOutputDir);
     if (!outputDir) {
-        lines.push(info(`outputDir absent: les exports seront ecrits dans le dossier courant (${resolved}).`));
-        return;
+        lines.push(info(t.doctor.outputDirMissing(resolved)));
+    }
+    else if (outputDir.trim() === ".") {
+        lines.push(info(t.doctor.outputDirLegacy(resolved)));
     }
     try {
         const stats = await stat(resolved);
         if (!stats.isDirectory()) {
-            lines.push(error(`outputDir pointe vers un fichier, pas un dossier: ${resolved}`));
+            lines.push(error(t.doctor.outputDirIsFile(resolved)));
             return;
         }
-        lines.push(ok(`outputDir configure: ${resolved}`));
+        lines.push(ok(t.doctor.outputDirConfigured(resolved)));
     }
     catch {
-        lines.push(warn(`outputDir n'existe pas encore: ${resolved}. Palabre tentera de le creer au moment de l'export.`));
+        lines.push(warn(t.doctor.outputDirWillCreate(resolved)));
     }
 }
-function inspectDetectedMissingAgents(config, discovery, lines) {
+function inspectDetectedMissingAgents(config, discovery, lines, t) {
     const missing = detectedAgentNames(discovery).filter((name) => !config.agents[name]);
     if (missing.length === 0) {
         return;
     }
-    lines.push(warn(`Agent(s) detecte(s) mais absent(s) de la config: ${missing.join(", ")}. Action: lance ` + "`palabre config --sync-agents`."));
+    lines.push(warn(t.doctor.detectedMissing(missing.join(", "))));
 }
-function inspectAgents(config, discovery, lines) {
-    lines.push(info("Agents configures:"));
+function inspectAgents(config, discovery, lines, t) {
+    lines.push(info(t.doctor.configuredAgents, "agents"));
     for (const [name, agent] of Object.entries(config.agents)) {
-        inspectAgentShape(name, agent, lines);
-        if (agent.type === "cli") {
-            inspectCliAgent(name, agent, discovery, lines);
+        inspectAgentShape(name, agent, lines, t);
+        if (agent.type === "cli" || agent.type === "cli-pty") {
+            inspectCliAgent(name, agent, discovery, lines, t);
             continue;
         }
-        inspectOllamaAgent(name, agent, discovery, lines);
+        inspectOllamaAgent(name, agent, discovery, lines, t);
     }
 }
-function inspectAgentShape(name, agent, lines) {
+function inspectAgentShape(name, agent, lines, t) {
     if (!agent.role) {
-        lines.push(error(`${name}: role absent.`));
+        lines.push(error(t.doctor.roleMissing(name)));
     }
-    if (agent.type === "cli") {
+    if (agent.type === "cli" || agent.type === "cli-pty") {
         if (!agent.command || !agent.command.trim()) {
-            lines.push(error(`${name}: command CLI absent.`));
+            lines.push(error(t.doctor.cliCommandMissing(name)));
         }
         if (agent.promptMode && !["stdin", "argument"].includes(agent.promptMode)) {
-            lines.push(error(`${name}: promptMode invalide (${agent.promptMode}). Valeurs attendues: stdin ou argument.`));
+            lines.push(error(t.doctor.promptModeInvalid(name, agent.promptMode)));
         }
         if (agent.timeoutMs !== undefined && (!Number.isFinite(agent.timeoutMs) || agent.timeoutMs <= 0)) {
-            lines.push(error(`${name}: timeoutMs doit etre un nombre positif.`));
+            lines.push(error(t.doctor.positiveTimeout(name, "timeoutMs")));
         }
         if (agent.idleTimeoutMs !== undefined && (!Number.isFinite(agent.idleTimeoutMs) || agent.idleTimeoutMs <= 0)) {
-            lines.push(error(`${name}: idleTimeoutMs doit etre un nombre positif.`));
+            lines.push(error(t.doctor.positiveTimeout(name, "idleTimeoutMs")));
         }
         return;
     }
     if (!agent.model || !agent.model.trim()) {
-        lines.push(error(`${name}: modele Ollama absent.`));
+        lines.push(error(t.doctor.ollamaModelMissing(name)));
     }
     if (agent.baseUrl && !/^https?:\/\//.test(agent.baseUrl)) {
-        lines.push(error(`${name}: baseUrl Ollama invalide (${agent.baseUrl}). Attendu: http://... ou https://...`));
+        lines.push(error(t.doctor.ollamaBaseUrlInvalid(name, agent.baseUrl)));
     }
     if (agent.timeoutMs !== undefined && (!Number.isFinite(agent.timeoutMs) || agent.timeoutMs <= 0)) {
-        lines.push(error(`${name}: timeoutMs doit etre un nombre positif.`));
+        lines.push(error(t.doctor.positiveTimeout(name, "timeoutMs")));
     }
 }
-function inspectCliAgent(name, agent, discovery, lines) {
+function inspectCliAgent(name, agent, discovery, lines, t) {
     const known = knownCliDetection(agent.command, discovery);
     const prefix = `${name} [cli:${agent.role}] command=${agent.command}`;
     if (!known) {
-        lines.push(info(`${prefix} (commande custom non verifiee par doctor)`));
+        lines.push(info(t.doctor.customCommand(prefix)));
         return;
     }
     lines.push(known.available
-        ? ok(`${prefix} detectee (${known.path ?? known.command})`)
-        : warn(`${prefix} non detectee dans PATH. Action: installe/authentifie la CLI ou corrige command dans la config.`));
+        ? ok(t.doctor.cliDetected(prefix, known.path ?? known.command))
+        : warn(t.doctor.cliMissing(prefix)));
 }
-function inspectOllamaAgent(name, agent, discovery, lines) {
+function inspectOllamaAgent(name, agent, discovery, lines, t) {
     const prefix = `${name} [ollama:${agent.role}] model=${agent.model}`;
     if (!discovery.ollama.available) {
-        lines.push(warn(`${prefix} non verifiable: API Ollama non joignable. Action: demarre Ollama ou corrige baseUrl.`));
+        lines.push(warn(t.doctor.ollamaNotVerifiable(prefix)));
         return;
     }
     if (agent.validateModel === false) {
-        lines.push(info(`${prefix} non valide car validateModel=false.`));
+        lines.push(info(t.doctor.ollamaValidateFalse(prefix)));
         return;
     }
     const installed = discovery.ollama.models.includes(agent.model);
     lines.push(installed
-        ? ok(`${prefix} installe.`)
-        : warn(`${prefix} absent. Action: lance ` + "`ollama pull " + agent.model + "`" + " ou utilise `--pull-models`."));
+        ? ok(t.doctor.ollamaInstalled(prefix))
+        : warn(t.doctor.ollamaMissing(prefix, agent.model)));
 }
 function detectedAgentNames(discovery) {
     return [
         discovery.codex.available ? "codex" : undefined,
         discovery.claude.available ? "claude" : undefined,
         discovery.gemini.available ? "gemini" : undefined,
+        discovery.antigravity.available ? "antigravity" : undefined,
         discovery.opencode.available ? "opencode" : undefined,
         discovery.ollama.available ? "ollama-local" : undefined
     ].filter((name) => Boolean(name));
 }
-function formatCommand(label, available, command, resolvedPath) {
+function formatCommand(label, available, command, resolvedPath, t) {
     return available
-        ? ok(`${label}: detecte (${resolvedPath ?? command})`)
-        : warn(`${label}: non detecte dans PATH.`);
+        ? ok(t.doctor.commandDetected(label, resolvedPath ?? command))
+        : warn(t.doctor.commandMissing(label));
 }
 function knownCliDetection(command, discovery) {
     const normalized = path.basename(command).toLowerCase().replace(/\.(exe|cmd|bat)$/i, "");
@@ -222,21 +242,25 @@ function knownCliDetection(command, discovery) {
         return discovery.claude;
     if (normalized === "gemini")
         return discovery.gemini;
+    if (normalized === "agy")
+        return discovery.antigravity;
+    if (normalized === "antigravity")
+        return discovery.antigravity;
     if (normalized === "opencode")
         return discovery.opencode;
     return undefined;
 }
-function render(lines, plain) {
+function render(lines, plain, t) {
     const hasErrors = lines.some((line) => line.level === "error");
     return {
         ok: !hasErrors,
-        output: plain ? renderPlain(lines) : renderPretty(lines)
+        output: plain ? renderPlain(lines, t) : renderPretty(lines, t)
     };
 }
-function renderPlain(lines) {
-    return lines.map(formatLine).join("\n");
+function renderPlain(lines, t) {
+    return lines.map((line) => formatLine(line, t)).join("\n");
 }
-function renderPretty(lines) {
+function renderPretty(lines, t) {
     const configLines = [];
     const toolLines = [];
     const agentLines = [];
@@ -244,17 +268,17 @@ function renderPretty(lines) {
     let current = "config";
     let cwd = process.cwd();
     for (const line of lines) {
-        if (line.text === "PALABRE doctor")
+        if (line.marker === "title")
             continue;
-        if (line.text.startsWith("Dossier courant: ")) {
-            cwd = line.text.replace("Dossier courant: ", "");
+        if (line.marker === "cwd") {
+            cwd = line.text.replace(/^.*?: /, "");
             continue;
         }
-        if (line.text === "Outils locaux:") {
+        if (line.marker === "tools") {
             current = "tools";
             continue;
         }
-        if (line.text === "Agents configures:") {
+        if (line.marker === "agents") {
             current = "agents";
             continue;
         }
@@ -273,68 +297,54 @@ function renderPretty(lines) {
     }
     const errorCount = lines.filter((line) => line.level === "error").length;
     const warnCount = lines.filter((line) => line.level === "warn").length;
-    const status = errorCount > 0
-        ? `${errorCount} erreur(s), ${warnCount} avertissement(s)`
-        : warnCount > 0 ? `${warnCount} avertissement(s)` : "OK";
+    const status = t.doctor.status(errorCount, warnCount);
     return [
-        ...renderDoctorHeader(status),
+        ...renderDoctorHeader(status, t),
         "",
-        ...renderSection("Configuration", [info(`Dossier courant: ${cwd}`), ...configLines]),
+        ...renderSection(t.doctor.sections.configuration, [info(t.doctor.currentDirectory(cwd)), ...configLines], t),
         "",
-        ...renderSection("Outils locaux", toolLines),
+        ...renderSection(t.doctor.sections.tools, toolLines, t),
         "",
-        ...renderSection("Agents", agentLines),
-        ...(actionLines.length > 0 ? ["", ...renderSection("A verifier", actionLines)] : []),
+        ...renderSection(t.doctor.sections.agents, agentLines, t),
+        ...(actionLines.length > 0 ? ["", ...renderSection(t.doctor.sections.check, actionLines, t)] : []),
         ""
     ].join("\n");
 }
-function renderDoctorHeader(status) {
-    const title = "PALABRE doctor";
+function renderDoctorHeader(status, t) {
+    const title = t.doctor.title;
     return [
         `┌─ ${title} ${"─".repeat(Math.max(1, 58 - title.length))}`,
-        `│ Statut: ${status}`,
+        `│ ${t.doctor.statusLabel}: ${status}`,
         `└${"─".repeat(73)}`
     ];
 }
-function renderSection(title, lines) {
+function renderSection(title, lines, t) {
     if (lines.length === 0) {
-        return [title, "  INFO  Rien a afficher."];
+        return [title, `  ${t.doctor.prettyLevelLabels.info} ${t.doctor.nothingToDisplay}`];
     }
     return [
         title,
         "─".repeat(Math.max(16, title.length + 8)),
-        ...lines.map((line) => `  ${formatPrettyLine(line)}`)
+        ...lines.map((line) => `  ${formatPrettyLine(line, t)}`)
     ];
 }
-function formatPrettyLine(line) {
-    const labels = {
-        ok: "OK    ",
-        warn: "WARN  ",
-        error: "ERREUR",
-        info: "INFO  "
-    };
-    return `${labels[line.level]} ${line.text}`;
+function formatPrettyLine(line, t) {
+    return `${t.doctor.prettyLevelLabels[line.level]} ${line.text}`;
 }
-function formatLine(line) {
-    const labels = {
-        ok: "OK",
-        warn: "WARN",
-        error: "ERREUR",
-        info: "INFO"
-    };
-    return `[${labels[line.level]}] ${line.text}`;
+function formatLine(line, t) {
+    return `[${t.doctor.levelLabels[line.level]}] ${line.text}`;
 }
-function ok(text) {
-    return { level: "ok", text };
+function ok(text, marker) {
+    return { level: "ok", text, marker };
 }
-function warn(text) {
-    return { level: "warn", text };
+function warn(text, marker) {
+    return { level: "warn", text, marker };
 }
-function error(text) {
-    return { level: "error", text };
+function error(text, marker) {
+    return { level: "error", text, marker };
 }
-function info(text) {
-    return { level: "info", text };
+function info(text, marker) {
+    return { level: "info", text, marker };
 }
 function formatErrorSuffix(errorMessage) {
     return errorMessage ? ` (${errorMessage})` : "";

package/dist/errors.js

@@ -1,3 +1,4 @@
+import { createTranslator } from "./i18n.js";
 /**
  * Erreur typée levée par les adapters.
  * `kind` est stable et utilisé par l'orchestrateur pour classifier l'échec sans inspecter le message.
@@ -15,35 +16,7 @@ export class AdapterError extends Error {
     }
 }
 /** Formate le message d'erreur avec une suggestion actionnable selon `error.kind`. */
-export function formatAdapterError(error) {
-    const hint = hintForFailure(error.kind);
-    return hint ? `${error.message}\nSuggestion: ${hint}` : error.message;
-}
-function hintForFailure(kind) {
-    switch (kind) {
-        case "command-not-found":
-            return "Verifie que la CLI est installee, authentifiee et disponible dans le PATH.";
-        case "spawn-failed":
-            return "Sur Windows, essaye le wrapper .cmd ou active \"shell\": true dans la config agent.";
-        case "timeout":
-            return "Augmente timeoutMs ou teste la commande directement dans le terminal.";
-        case "idle-timeout":
-            return "Desactive idleTimeoutMs pour les CLIs IA qui restent silencieuses pendant la generation.";
-        case "empty-output":
-            return "Teste la commande en dehors de Palabre et verifie que le prompt est bien lu via stdin ou argument.";
-        case "usage-limit":
-            return "Attends la fenetre indiquee par la CLI, change de modele ou relance avec un autre agent/preset disponible.";
-        case "non-zero-exit":
-            return "Teste la commande directement, puis ajuste args, permissions, modele ou authentification de la CLI.";
-        case "model-unavailable":
-            return "Installe le modele Ollama ou relance avec --pull-models pour autoriser le telechargement.";
-        case "unsupported-model":
-            return "Verifie le nom du modele, ton abonnement, ou retire --model-a/--model-b/--summary-model pour laisser la CLI utiliser son modele par defaut.";
-        case "model-pull-failed":
-            return "Verifie le nom du modele, ta connexion et l'espace disque disponible.";
-        case "http-error":
-            return "Verifie que le service local est lance et que baseUrl est correct.";
-        default:
-            return undefined;
-    }
+export function formatAdapterError(error, messages = createTranslator("fr")) {
+    const hint = messages.adapterErrors.hint(error.kind);
+    return hint ? `${error.message}\n${messages.adapterErrors.suggestionPrefix}: ${hint}` : error.message;
 }