palabre 0.9.1 → 0.10.0

package/dist/adapters/cli-pty.js

@@ -1,9 +1,11 @@
+/** @file Adapter pseudo-terminal (`node-pty`) pour les CLIs qui exigent une vraie console (ex. Antigravity `agy`). */
 import { existsSync } from "node:fs";
 import path from "node:path";
-import { AdapterError } from "../errors.js";
+import { AdapterError, cancelledError } from "../errors.js";
+import { createTranslator } from "../i18n.js";
 import { executableExtensions } from "../exec.js";
 import { formatAgentPrompt } from "../prompt.js";
-import { DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS, withModelArgs } from "./cli-shared.js";
+import { DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS, extractPtyUsageLimitMessage, withModelArgs } from "./cli-shared.js";
 import { cleanTerminalOutput } from "./terminal.js";
 /**
  * Adapter pour les CLIs qui exigent un vrai terminal.
@@ -42,6 +44,7 @@ export class CliPtyAdapter {
             throw cancelledError(this.name);
         }
         const renderedPrompt = formatAgentPrompt(prompt);
+        const errorMessages = createTranslator(prompt.language ?? "fr").adapterErrors;
         const promptMode = this.config.promptMode ?? "stdin";
         const baseArgs = withModelArgs(this.config.args ?? [], this.config.model, this.config.modelArg ?? "--model");
         const args = promptMode === "argument"
@@ -82,8 +85,18 @@ export class CliPtyAdapter {
                     return;
                 }
                 const content = cleanTerminalOutput(output);
+                // Le PTY fusionne stdout/stderr : seuls les diagnostics autonomes ou machine
+                // sont acceptés pour éviter de rejeter une réponse normale parlant de rate-limit.
+                const usageLimitMessage = extractPtyUsageLimitMessage(content);
+                if (usageLimitMessage) {
+                    reject(new AdapterError("usage-limit", this.name, errorMessages.usageLimit(this.name, usageLimitMessage), {
+                        ...(exitCode === undefined || exitCode === 0 ? {} : { exitCode }),
+                        raw: output
+                    }));
+                    return;
+                }
                 if (exitCode && exitCode !== 0) {
-                    reject(createPtyExitError(this.name, exitCode, output));
+                    reject(createPtyExitError(this.name, exitCode, output, errorMessages));
                     return;
                 }
                 if (!content && !this.config.allowEmptyOutput) {
@@ -143,6 +156,10 @@ export class CliPtyAdapter {
         });
     }
 }
+/**
+ * Résout le chemin absolu de l'exécutable dans le `PATH`, requis par `node-pty` qui ne fait pas
+ * lui-même cette résolution comme `child_process.spawn`. Retourne `command` tel quel si rien n'est trouvé.
+ */
 function resolveExecutable(command) {
     if (path.isAbsolute(command) || command.includes("\\") || command.includes("/")) {
         return command;
@@ -160,6 +177,11 @@ function resolveExecutable(command) {
     }
     return command;
 }
+/**
+ * Force la libération des ressources internes ConPTY sur Windows après `term.kill()`, qui ne les
+ * relâche pas toujours. Accède à des champs privés non documentés de `node-pty` : purement
+ * best-effort, toute erreur est avalée sans remonter à l'appelant.
+ */
 function cleanupPty(term) {
     const maybeTerm = term;
     try {
@@ -170,16 +192,14 @@ function cleanupPty(term) {
         // Best-effort cleanup for Windows ConPTY internals.
     }
 }
-function createPtyExitError(adapterName, exitCode, raw) {
-    return new AdapterError("non-zero-exit", adapterName, `${adapterName} exited with code ${exitCode}: ${summarizePtyOutput(raw)}`, {
+/** Construit une `AdapterError` `non-zero-exit` à partir de la sortie brute fusionnée du PTY. */
+function createPtyExitError(adapterName, exitCode, raw, messages) {
+    return new AdapterError("non-zero-exit", adapterName, `${adapterName} exited with code ${exitCode}: ${summarizePtyOutput(raw, messages)}`, {
         exitCode,
         raw
     });
 }
-function cancelledError(adapterName) {
-    return new AdapterError("cancelled", adapterName, `${adapterName} cancelled by user.`);
-}
-function summarizePtyOutput(output) {
+function summarizePtyOutput(output, messages) {
     const cleaned = cleanTerminalOutput(output);
-    return cleaned ? cleaned.slice(-1_200) : "aucune sortie PTY capturee.";
+    return cleaned ? cleaned.slice(-1_200) : messages.noPtyOutputCaptured;
 }

package/dist/adapters/cli-shared.js

@@ -1,7 +1,80 @@
+/** @file Constantes et utilitaires partagés entre les adapters `cli` et `cli-pty`. */
 /** Limite de sortie par défaut des adapters CLI/PTY : 50 Mio avant `output-too-large`. */
 export const DEFAULT_MAX_OUTPUT_BYTES = 50 * 1024 * 1024;
 /** Timeout dur par défaut d'un appel d'agent CLI/PTY (3 minutes). */
 export const DEFAULT_TIMEOUT_MS = 180_000;
+/**
+ * Cherche dans un texte (stderr ou flux PTY) une ligne signalant un quota ou un
+ * rate-limit connu, pour classer l'erreur en `usage-limit`.
+ * @returns La ligne fautive nettoyée et tronquée, ou `undefined` si rien ne matche.
+ */
+export function extractUsageLimitMessage(text) {
+    const match = uniqueNonEmptyLines(text).find((line) => isUsageLimitLine(line));
+    if (!match) {
+        return undefined;
+    }
+    return clipLine(stripLogPrefix(match), 500);
+}
+/**
+ * Détecte un diagnostic de quota dans un flux PTY fusionné sans interpréter une
+ * réponse normale qui mentionnerait simplement les notions de quota ou rate-limit.
+ * Les motifs acceptés sont des erreurs machine ou des messages de quota autonomes.
+ */
+export function extractPtyUsageLimitMessage(text) {
+    const match = uniqueNonEmptyLines(text).find((line) => {
+        const cleaned = stripLogPrefix(line);
+        const normalized = cleaned.toLowerCase();
+        const hasErrorPrefix = /^(error|fatal|warning)\s*:/i.test(line.trim());
+        return /^individual quota reached(?:[.!:]|$)/i.test(cleaned)
+            || /\b(resource_exhausted|insufficient_quota)\b/i.test(cleaned)
+            || /\bhttp\s*429\b/i.test(cleaned)
+            || /^too many requests(?:[.!:]|$)/i.test(cleaned)
+            || (hasErrorPrefix && isUsageLimitLine(normalized));
+    });
+    return match ? clipLine(stripLogPrefix(match), 500) : undefined;
+}
+function isUsageLimitLine(line) {
+    const normalized = line.toLowerCase();
+    return [
+        "usage limit",
+        "rate limit",
+        "quota exceeded",
+        "quota reached",
+        "resource_exhausted",
+        "too many requests",
+        "insufficient_quota",
+        "exceeded your current quota",
+        "credit balance is too low",
+        "billing hard limit"
+    ].some((pattern) => normalized.includes(pattern));
+}
+/** Déduplique les lignes non vides d'un texte, en préservant l'ordre d'apparition. */
+export function uniqueNonEmptyLines(value) {
+    const seen = new Set();
+    const lines = [];
+    for (const line of value.split(/\r?\n/)) {
+        const cleaned = line.trim();
+        if (!cleaned || seen.has(cleaned)) {
+            continue;
+        }
+        seen.add(cleaned);
+        lines.push(cleaned);
+    }
+    return lines;
+}
+/** Retire un éventuel préfixe de log (`2026-01-01T... ERROR module:` ou `ERROR:`) d'une ligne. */
+export function stripLogPrefix(line) {
+    return line
+        .replace(/^\d{4}-\d{2}-\d{2}T\S+\s+(ERROR|WARN|INFO|DEBUG)\s+[^:]+:\s*/i, "")
+        .replace(/^ERROR:\s*/i, "")
+        .trim();
+}
+/** Tronque une ligne à `maxLength` caractères avec une ellipse. */
+export function clipLine(value, maxLength) {
+    return value.length <= maxLength
+        ? value
+        : `${value.slice(0, maxLength - 1)}…`;
+}
 /**
  * Insère `modelArg model` dans la liste d'arguments d'une commande CLI.
  * Si le dernier argument est `-` (marqueur stdin), insère avant lui pour

package/dist/adapters/cli.js

@@ -1,7 +1,9 @@
+/** @file Adapter CLI batch minimal : spawn, injection du prompt, capture stdout, classement des erreurs connues. */
 import { spawn } from "node:child_process";
-import { AdapterError } from "../errors.js";
+import { AdapterError, cancelledError } from "../errors.js";
+import { createTranslator } from "../i18n.js";
 import { formatAgentPrompt } from "../prompt.js";
-import { DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS, withModelArgs } from "./cli-shared.js";
+import { clipLine, DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS, extractUsageLimitMessage, stripLogPrefix, uniqueNonEmptyLines, withModelArgs } from "./cli-shared.js";
 import { cleanTerminalOutput } from "./terminal.js";
 /**
  * Adapter pour les CLIs batch (Codex, Claude, OpenCode, Vibe...).
@@ -41,6 +43,7 @@ export class CliAdapter {
             throw cancelledError(this.name);
         }
         const renderedPrompt = formatAgentPrompt(prompt);
+        const errorMessages = createTranslator(prompt.language ?? "fr").adapterErrors;
         const promptMode = this.config.promptMode ?? "stdin";
         const baseArgs = withModelArgs(this.config.args ?? [], this.config.model, this.config.modelArg ?? "--model");
         const args = promptMode === "argument"
@@ -76,7 +79,7 @@ export class CliAdapter {
                 }
                 const content = cleanCliOutput(stdout);
                 if (!content && !this.config.allowEmptyOutput) {
-                    const knownError = createKnownCliError(this.name, undefined, stderr);
+                    const knownError = createKnownCliError(this.name, undefined, stderr, errorMessages);
                     if (knownError) {
                         reject(knownError);
                         return;
@@ -114,7 +117,8 @@ export class CliAdapter {
                 }, this.config.idleTimeoutMs);
             };
             bumpIdleTimer();
-            child.stdout.on("data", (chunk) => {
+            // stdout et stderr partagent le même budget `maxOutputBytes`.
+            const createDataHandler = (append) => (chunk) => {
                 outputBytes += chunk.length;
                 if (outputBytes > maxOutputBytes) {
                     killChildProcess(child);
@@ -124,22 +128,15 @@ export class CliAdapter {
                     }));
                     return;
                 }
-                stdout += chunk.toString("utf8");
+                append(chunk.toString("utf8"));
                 bumpIdleTimer();
-            });
-            child.stderr.on("data", (chunk) => {
-                outputBytes += chunk.length;
-                if (outputBytes > maxOutputBytes) {
-                    killChildProcess(child);
-                    finish(new AdapterError("output-too-large", this.name, `${this.name} produced more than ${maxOutputBytes} bytes of output`, {
-                        maxOutputBytes,
-                        outputBytes
-                    }));
-                    return;
-                }
-                stderr += chunk.toString("utf8");
-                bumpIdleTimer();
-            });
+            };
+            child.stdout.on("data", createDataHandler((text) => {
+                stdout += text;
+            }));
+            child.stderr.on("data", createDataHandler((text) => {
+                stderr += text;
+            }));
             child.on("error", (error) => {
                 const kind = error.code === "ENOENT" ? "command-not-found" : "spawn-failed";
                 finish(new AdapterError(kind, this.name, `${this.name} failed to start command "${this.config.command}": ${error.message}`, {
@@ -149,7 +146,7 @@ export class CliAdapter {
             });
             const finishFromExitCode = (code) => {
                 if (code && code !== 0) {
-                    finish(createCliExitError(this.name, code, stderr));
+                    finish(createCliExitError(this.name, code, stderr, errorMessages));
                     return;
                 }
                 finish();
@@ -166,6 +163,11 @@ export class CliAdapter {
 function cleanCliOutput(output) {
     return stripWindowsTaskkillNoise(cleanTerminalOutput(output));
 }
+/**
+ * Retire les lignes de statut `taskkill` (FR/EN) que Windows peut mélanger à la sortie
+ * d'une CLI tuée après timeout ou annulation. Sans ce filtre, ce bruit contaminerait
+ * la réponse agent capturée sur stdout.
+ */
 function stripWindowsTaskkillNoise(output) {
     const lines = output.split("\n");
     const kept = [];
@@ -206,31 +208,32 @@ function normalizeForWindowsStatus(line) {
  * Construit une `AdapterError` typée depuis un exit code non nul.
  * Élève en `usage-limit` si le stderr contient un signal de quota/rate-limit connu.
  */
-function createCliExitError(adapterName, exitCode, stderr) {
-    return createKnownCliError(adapterName, exitCode, stderr)
-        ?? new AdapterError("non-zero-exit", adapterName, `${adapterName} exited with code ${exitCode}: ${summarizeCliError(cleanCliOutput(stderr))}`, {
+function createCliExitError(adapterName, exitCode, stderr, messages) {
+    return createKnownCliError(adapterName, exitCode, stderr, messages)
+        ?? new AdapterError("non-zero-exit", adapterName, `${adapterName} exited with code ${exitCode}: ${summarizeCliError(cleanCliOutput(stderr), messages)}`, {
             exitCode,
             stderr: cleanCliOutput(stderr)
         });
 }
-function createKnownCliError(adapterName, exitCode, stderr) {
+function createKnownCliError(adapterName, exitCode, stderr, messages) {
     const cleanedStderr = cleanCliOutput(stderr);
     const usageLimitMessage = extractUsageLimitMessage(cleanedStderr);
     const unsupportedModelMessage = extractUnsupportedModelMessage(cleanedStderr);
     if (usageLimitMessage) {
-        return new AdapterError("usage-limit", adapterName, `${adapterName} a atteint une limite d'utilisation: ${usageLimitMessage}`, {
+        return new AdapterError("usage-limit", adapterName, messages.usageLimit(adapterName, usageLimitMessage), {
             ...(exitCode === undefined ? {} : { exitCode }),
             stderr: cleanedStderr
         });
     }
     if (unsupportedModelMessage) {
-        return new AdapterError("unsupported-model", adapterName, `${adapterName} ne peut pas utiliser ce modèle: ${unsupportedModelMessage}`, {
+        return new AdapterError("unsupported-model", adapterName, messages.unsupportedModel(adapterName, unsupportedModelMessage), {
             ...(exitCode === undefined ? {} : { exitCode }),
             stderr: cleanedStderr
         });
     }
     return undefined;
 }
+/** Cherche dans stderr une ligne signalant un modèle non supporté, pour classer l'erreur en `unsupported-model`. */
 function extractUnsupportedModelMessage(stderr) {
     const lines = uniqueNonEmptyLines(stderr);
     const match = lines.find((line) => isUnsupportedModelLine(line));
@@ -255,59 +258,17 @@ function extractJsonErrorMessage(line) {
     const match = line.match(/"message"\s*:\s*"([^"]+)"/);
     return match?.[1];
 }
-function extractUsageLimitMessage(stderr) {
-    const lines = uniqueNonEmptyLines(stderr);
-    const match = lines.find((line) => isUsageLimitLine(line));
-    if (!match) {
-        return undefined;
-    }
-    return clipLine(stripLogPrefix(match), 500);
-}
-function isUsageLimitLine(line) {
-    const normalized = line.toLowerCase();
-    return [
-        "usage limit",
-        "rate limit",
-        "quota exceeded",
-        "resource_exhausted",
-        "too many requests",
-        "insufficient_quota",
-        "exceeded your current quota",
-        "credit balance is too low",
-        "billing hard limit"
-    ].some((pattern) => normalized.includes(pattern));
-}
-function summarizeCliError(stderr) {
+function summarizeCliError(stderr, messages) {
     const lines = uniqueNonEmptyLines(stderr).map(stripLogPrefix);
     if (lines.length === 0) {
-        return "aucun stderr capture.";
+        return messages.noStderrCaptured;
     }
     return clipLine(lines.slice(-8).join("\n"), 1_200);
 }
-function uniqueNonEmptyLines(value) {
-    const seen = new Set();
-    const lines = [];
-    for (const line of value.split(/\r?\n/)) {
-        const cleaned = line.trim();
-        if (!cleaned || seen.has(cleaned)) {
-            continue;
-        }
-        seen.add(cleaned);
-        lines.push(cleaned);
-    }
-    return lines;
-}
-function stripLogPrefix(line) {
-    return line
-        .replace(/^\d{4}-\d{2}-\d{2}T\S+\s+(ERROR|WARN|INFO|DEBUG)\s+[^:]+:\s*/i, "")
-        .replace(/^ERROR:\s*/i, "")
-        .trim();
-}
-function clipLine(value, maxLength) {
-    return value.length <= maxLength
-        ? value
-        : `${value.slice(0, maxLength - 1)}…`;
-}
+/**
+ * Recompose `command`/`args` en une seule ligne de commande quotée quand `shell: true` est requis
+ * (ex. wrappers npm shimmés sur Windows où `spawn` direct renvoie `EPERM`/`EINVAL`).
+ */
 function shellCommandForSpawn(command, args, shell) {
     if (!shell) {
         return { command, args };
@@ -337,9 +298,11 @@ function quotePosixShellArg(value) {
     }
     return `'${value.replace(/'/g, "'\\''")}'`;
 }
-function cancelledError(adapterName) {
-    return new AdapterError("cancelled", adapterName, `${adapterName} cancelled by user.`);
-}
+/**
+ * Termine le process et ses enfants (`/T`) sur Windows via `taskkill.exe`, car `child.kill()` seul
+ * ne tue pas les sous-processus d'un wrapper npm/shim. `taskkill` est lancé en fire-and-forget :
+ * seul son échec de spawn déclenche un `child.kill()` de repli, sans attendre sa fin.
+ */
 function killChildProcess(child) {
     if (process.platform === "win32" && child.pid) {
         const killer = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {

package/dist/adapters/index.js

@@ -1,3 +1,4 @@
+/** @file Factory d'adapters : mappe un `AgentConfig` vers l'implémentation `cli`/`cli-pty`/`ollama` correspondante. */
 import { CliAdapter } from "./cli.js";
 import { CliPtyAdapter } from "./cli-pty.js";
 import { OllamaAdapter } from "./ollama.js";

package/dist/adapters/ollama.js

@@ -1,4 +1,5 @@
-import { AdapterError } from "../errors.js";
+/** @file Adapter Ollama HTTP : validation/pull de modèle, déchargement des autres modèles chargés, appel `/api/chat`. */
+import { AdapterError, cancelledError } from "../errors.js";
 import { createTranslator } from "../i18n.js";
 import { formatAgentPrompt } from "../prompt.js";
 import { resolveOllamaBaseUrl } from "../ollamaUrl.js";
@@ -41,15 +42,17 @@ export class OllamaAdapter {
         if (prompt.signal?.aborted) {
             throw cancelledError(this.name);
         }
+        const translator = createTranslator(prompt.language ?? "fr");
+        const errorMessages = translator.adapterErrors;
         const baseUrl = resolveOllamaBaseUrl({
             cliUrl: this.runtime.ollamaUrl,
             configUrl: this.config.baseUrl
         });
         if (this.config.validateModel !== false) {
-            await this.ensureModelAvailable(baseUrl);
+            await this.ensureModelAvailable(baseUrl, errorMessages);
         }
         if (this.config.unloadOtherModels !== false) {
-            await this.unloadOtherRunningModels(baseUrl);
+            await this.unloadOtherRunningModels(baseUrl, errorMessages);
         }
         const controller = new AbortController();
         const abortListener = () => controller.abort();
@@ -68,8 +71,7 @@ export class OllamaAdapter {
                     messages: [
                         {
                             role: "system",
-                            content: this.config.systemPrompt ??
-                                createTranslator(prompt.language ?? "fr").prompt.ollamaSystemPrompt
+                            content: this.config.systemPrompt ?? translator.prompt.ollamaSystemPrompt
                         },
                         {
                             role: "user",
@@ -112,40 +114,39 @@ export class OllamaAdapter {
      * Si absent et `autoPullModel` est faux, lève `model-unavailable` avec la liste des modèles détectés.
      * Si absent et `autoPullModel` est vrai, déclenche le pull puis re-vérifie.
      */
-    async ensureModelAvailable(baseUrl) {
-        const available = await this.isModelAvailable(baseUrl);
+    async ensureModelAvailable(baseUrl, messages) {
+        const available = await this.isModelAvailable(baseUrl, messages);
         if (available) {
             return;
         }
         if (!this.config.autoPullModel) {
-            const models = await this.listAvailableModels(baseUrl);
-            throw new AdapterError("model-unavailable", this.name, `Modele Ollama indisponible: ${this.config.model}. Modeles detectes: ${models.join(", ") || "aucun"}. ` +
-                "Utilise --pull-models ou autoPullModel: true pour autoriser le telechargement.", { model: this.config.model, availableModels: models });
+            const models = await this.listAvailableModels(baseUrl, messages);
+            throw new AdapterError("model-unavailable", this.name, messages.ollamaModelUnavailable(this.config.model, models), { model: this.config.model, availableModels: models });
         }
-        process.stderr.write(`\n[ollama] Modele absent, telechargement: ${this.config.model}\n`);
-        await this.pullModel(baseUrl);
-        if (!(await this.isModelAvailable(baseUrl))) {
-            throw new AdapterError("model-pull-failed", this.name, `Le modele Ollama ${this.config.model} reste indisponible apres telechargement.`);
+        process.stderr.write(`\n${messages.ollamaPullProgress(this.config.model)}\n`);
+        await this.pullModel(baseUrl, messages);
+        if (!(await this.isModelAvailable(baseUrl, messages))) {
+            throw new AdapterError("model-pull-failed", this.name, messages.ollamaModelStillUnavailable(this.config.model));
         }
     }
-    async isModelAvailable(baseUrl) {
-        const models = await this.listAvailableModels(baseUrl);
+    async isModelAvailable(baseUrl, messages) {
+        const models = await this.listAvailableModels(baseUrl, messages);
         return models.includes(this.config.model);
     }
-    async listAvailableModels(baseUrl) {
+    async listAvailableModels(baseUrl, messages) {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 120_000);
         try {
-            return await this.fetchAvailableModels(baseUrl, controller.signal);
+            return await this.fetchAvailableModels(baseUrl, controller.signal, messages);
         }
         finally {
             clearTimeout(timeout);
         }
     }
-    async fetchAvailableModels(baseUrl, signal) {
+    async fetchAvailableModels(baseUrl, signal, messages) {
         const response = await fetch(`${baseUrl}/api/tags`, { signal });
         if (!response.ok) {
-            throw new AdapterError("http-error", this.name, `Ollama HTTP ${response.status} pendant la detection des modeles`, {
+            throw new AdapterError("http-error", this.name, messages.ollamaTagsHttpError(response.status), {
                 status: response.status
             });
         }
@@ -154,7 +155,8 @@ export class OllamaAdapter {
             ?.map((model) => model.name ?? model.model)
             .filter((modelName) => Boolean(modelName)) ?? [];
     }
-    async pullModel(baseUrl) {
+    /** Déclenche `POST /api/pull` et attend sa fin ; timeout dédié `pullTimeoutMs` (30 min par défaut). */
+    async pullModel(baseUrl, messages) {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.config.pullTimeoutMs ?? 1_800_000);
         try {
@@ -178,26 +180,27 @@ export class OllamaAdapter {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            throw new AdapterError("model-pull-failed", this.name, `Echec du telechargement Ollama ${this.config.model}: ${message}`);
+            throw new AdapterError("model-pull-failed", this.name, messages.ollamaPullFailed(this.config.model, message));
         }
         finally {
             clearTimeout(timeout);
         }
     }
-    async unloadOtherRunningModels(baseUrl) {
+    /** Décharge séquentiellement, via `GET /api/ps`, tout modèle chargé autre que celui de cet agent. */
+    async unloadOtherRunningModels(baseUrl, messages) {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 120_000);
         try {
-            await this.unloadOtherRunningModelsWithSignal(baseUrl, controller.signal);
+            await this.unloadOtherRunningModelsWithSignal(baseUrl, controller.signal, messages);
         }
         finally {
             clearTimeout(timeout);
         }
     }
-    async unloadOtherRunningModelsWithSignal(baseUrl, signal) {
+    async unloadOtherRunningModelsWithSignal(baseUrl, signal, messages) {
         const response = await fetch(`${baseUrl}/api/ps`, { signal });
         if (!response.ok) {
-            throw new AdapterError("http-error", this.name, `Ollama HTTP ${response.status} pendant la detection des modeles charges`, {
+            throw new AdapterError("http-error", this.name, messages.ollamaPsHttpError(response.status), {
                 status: response.status
             });
         }
@@ -207,12 +210,12 @@ export class OllamaAdapter {
             .filter((modelName) => Boolean(modelName))
             .filter((modelName) => modelName !== this.config.model) ?? [];
         for (const model of runningModels) {
-            await unloadModel(baseUrl, model, signal);
+            await unloadModel(baseUrl, model, signal, messages);
         }
     }
 }
 /** Décharge un modèle Ollama en mémoire GPU/CPU via `POST /api/generate` avec `keep_alive: 0`. */
-async function unloadModel(baseUrl, model, signal) {
+async function unloadModel(baseUrl, model, signal, messages) {
     const response = await fetch(`${baseUrl}/api/generate`, {
         method: "POST",
         headers: {
@@ -225,12 +228,9 @@ async function unloadModel(baseUrl, model, signal) {
         signal
     });
     if (!response.ok) {
-        throw new AdapterError("http-error", "ollama", `Impossible de decharger le modele Ollama ${model}: HTTP ${response.status}`, {
+        throw new AdapterError("http-error", "ollama", messages.ollamaUnloadFailed(model, response.status), {
             status: response.status,
             model
         });
     }
 }
-function cancelledError(adapterName) {
-    return new AdapterError("cancelled", adapterName, `${adapterName} cancelled by user.`);
-}

package/dist/adapters/terminal.js

@@ -1,3 +1,4 @@
+/** @file Nettoyage des séquences ANSI/OSC partagé par les adapters CLI et PTY. */
 /** Retire les séquences de contrôle ANSI/OSC et normalise les retours ligne d'une sortie terminal. */
 export function cleanTerminalOutput(output) {
     return output

package/dist/args.js

@@ -1,3 +1,4 @@
+/** @file Parseur d'arguments CLI : table d'arité des flags, syntaxe courte preset/sujet, alias `-s`/`--topic`. */
 import { listPresetNames } from "./presets.js";
 /**
  * Table centrale décrivant l'arité de chaque flag long canonique.

package/dist/commands/agents.js

@@ -1,3 +1,4 @@
+/** @file Commande palabre agents et contrat JSON v1 pour les integrations. */
 import { configExists, loadConfig, resolveDefaultConfigPath } from "../config.js";
 import { discoverLocalToolsForConfig } from "../discovery.js";
 import { createTranslator, resolveLanguage } from "../i18n.js";
@@ -5,7 +6,12 @@ import { turnsOrDefault } from "../limits.js";
 import { listAgentsWithAvailability } from "../presets.js";
 import { detectionForCommand, isRetiredAgentName } from "../agentRegistry.js";
 import { optionalString } from "./shared.js";
-/** Exécute `palabre agents` en sortie humaine ou JSON versionné. */
+/**
+ * Liste les agents configurés avec leur disponibilité calculée par le CLI.
+ * @param flags - Flags de langue, config, URL Ollama et format JSON.
+ * @returns Une promesse résolue après écriture de la sortie.
+ * @throws {Error} Si aucune configuration n'est disponible.
+ */
 export async function runAgentsCommand(flags) {
     const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
     if (!(await configExists(configPath))) {

package/dist/commands/context.js

@@ -1,7 +1,13 @@
+/** @file Commande palabre context scan et rendu de son contrat versionne. */
 import { buildContextScan } from "../contextScan.js";
 import { createTranslator, resolveLanguage } from "../i18n.js";
 import { optionalString } from "./shared.js";
-/** Exécute `palabre context scan` en sortie humaine ou JSON versionné. */
+/**
+ * Scanne les chemins demandés avec les mêmes règles que `--context`.
+ * @param flags - Flags de langue et de format JSON.
+ * @param positionals - Sous-commande puis chemins à scanner.
+ * @returns Une promesse résolue après écriture du résultat et des warnings.
+ */
 export async function runContextCommand(flags, positionals) {
     const messages = createTranslator(resolveLanguage({ explicitLanguage: optionalString(flags.language) }));
     const subcommand = positionals[0] ?? "scan";

package/dist/commands/history.js

@@ -1,8 +1,13 @@
+/** @file Commande de consultation des exports Markdown recents. */
 import { configExists, loadConfig, resolveDefaultConfigPath, resolveOutputDir } from "../config.js";
 import { listHistoryEntries } from "../history.js";
 import { createTranslator, resolveLanguage } from "../i18n.js";
 import { optionalString } from "./shared.js";
-/** Exécute `palabre history` en sortie humaine ou JSON versionné. */
+/**
+ * Liste les exports du dossier de sortie configuré.
+ * @param flags - Flags de config, langue et format JSON.
+ * @returns Une promesse résolue après écriture de l'historique.
+ */
 export async function runHistoryCommand(flags) {
     const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
     const config = await configExists(configPath) ? await loadConfig(configPath) : undefined;

package/dist/commands/init.js

@@ -1,9 +1,14 @@
-import { configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, writeExampleConfig } from "../config.js";
+/** @file Initialisation explicite de configuration globale ou locale. */
+import { configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, writeConfig } from "../config.js";
 import { discoverLocalTools } from "../discovery.js";
 import { detectedAgentNames } from "../agentRegistry.js";
 import { createTranslator, DEFAULT_LANGUAGE, resolveLanguage } from "../i18n.js";
 import { optionalString } from "./shared.js";
-/** Exécute `palabre init` ou son alias `setup`. */
+/**
+ * Crée une configuration à partir des outils détectés localement.
+ * @param flags - Flags de chemin, portée locale, langue et URL Ollama.
+ * @returns Une promesse résolue après création et affichage du récapitulatif.
+ */
 export async function runInitCommand(flags) {
     const configPath = optionalString(flags.config) ?? (flags.local ? DEFAULT_CONFIG_PATH : GLOBAL_CONFIG_PATH);
     const startupMessages = createTranslator(resolveLanguage({ explicitLanguage: optionalString(flags.language) }));
@@ -18,7 +23,7 @@ export async function runInitCommand(flags) {
         configLanguage: config.language
     });
     const messages = createTranslator(config.language);
-    await writeExampleConfig(configPath, config);
+    await writeConfig(configPath, config);
     console.log(messages.init.configCreated(configPath));
     printInitDiscovery(discovery, config, messages);
 }

package/dist/commands/presets.js

@@ -1,9 +1,14 @@
+/** @file Commande de decouverte des presets et de leur disponibilite. */
 import { configExists, createConfigFromDiscovery, loadConfig, resolveDefaultConfigPath } from "../config.js";
 import { discoverLocalTools, discoverLocalToolsForConfig } from "../discovery.js";
 import { createTranslator, resolveLanguage } from "../i18n.js";
 import { listPresetsWithAvailability } from "../presets.js";
 import { optionalString } from "./shared.js";
-/** Exécute `palabre presets` en sortie humaine ou JSON versionné. */
+/**
+ * Liste les presets enrichis avec la disponibilité issue de la config et de la discovery.
+ * @param flags - Flags de config, langue, URL Ollama et format JSON.
+ * @returns Une promesse résolue après écriture de la liste.
+ */
 export async function runPresetsCommand(flags) {
     const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
     const ollamaUrl = optionalString(flags["ollama-url"]);