palabre 0.9.0 → 0.10.0

package/dist/commands/agents.js

@@ -0,0 +1,91 @@
+/** @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";
+import { turnsOrDefault } from "../limits.js";
+import { listAgentsWithAvailability } from "../presets.js";
+import { detectionForCommand, isRetiredAgentName } from "../agentRegistry.js";
+import { optionalString } from "./shared.js";
+/**
+ * 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))) {
+        const messages = createTranslator(resolveLanguage({ explicitLanguage: optionalString(flags.language) }));
+        throw new Error(messages.agents.noConfig);
+    }
+    const config = await loadConfig(configPath);
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config.language
+    }));
+    const discovery = await discoverLocalToolsForConfig(config, optionalString(flags["ollama-url"]));
+    if (flags.json) {
+        const fallbackAskAgents = [config.defaults?.agentA, config.defaults?.agentB]
+            .filter((name) => typeof name === "string" && !isRetiredAgentName(name));
+        process.stdout.write(JSON.stringify({
+            v: 1,
+            agents: listAgentsWithAvailability(config, discovery, messages),
+            defaults: {
+                askAgents: config.defaults?.askAgents?.length
+                    ? config.defaults.askAgents.filter((name) => !isRetiredAgentName(name))
+                    : fallbackAskAgents
+            }
+        }) + "\n");
+        return;
+    }
+    printAgents(configPath, config, discovery, messages);
+}
+function printAgents(configPath, config, discovery, messages) {
+    const entries = Object.entries(config.agents)
+        .filter(([name]) => !isRetiredAgentName(name))
+        .sort(([left], [right]) => left.localeCompare(right));
+    console.log(messages.agents.config(configPath));
+    console.log("");
+    console.log(messages.agents.title);
+    for (const [name, agentConfig] of entries) {
+        const status = formatAgentDetection(name, agentConfig, discovery, messages);
+        const defaults = formatAgentDefaults(name, config, messages);
+        const details = formatAgentDetails(agentConfig, messages);
+        console.log(`- ${name.padEnd(13)} ${`${agentConfig.type}/${agentConfig.role}`.padEnd(18)} ${status}${defaults ? ` | ${defaults}` : ""}`);
+        if (details)
+            console.log(`  ${details}`);
+    }
+    console.log("");
+    console.log(messages.agents.defaults(config.defaults?.agentA ?? messages.agents.none, config.defaults?.agentB ?? messages.agents.none, turnsOrDefault(config.defaults?.turns), config.defaults?.summaryAgent ?? messages.agents.summaryAgentB, config.defaults?.askSummaryAgent));
+}
+function formatAgentDefaults(name, config, messages) {
+    const labels = [];
+    if (config.defaults?.agentA === name)
+        labels.push(messages.agents.defaultAgentA);
+    if (config.defaults?.agentB === name)
+        labels.push(messages.agents.defaultAgentB);
+    if (config.defaults?.summaryAgent === name)
+        labels.push(messages.agents.defaultSummary);
+    if (config.defaults?.askSummaryAgent === name)
+        labels.push(messages.agents.defaultAskSummary);
+    return labels.join(", ");
+}
+function formatAgentDetails(agentConfig, messages) {
+    return agentConfig.type === "ollama"
+        ? messages.agents.model(agentConfig.model)
+        : messages.agents.command(agentConfig.command, agentConfig.model);
+}
+function formatAgentDetection(name, agentConfig, discovery, messages) {
+    if (agentConfig.type === "ollama") {
+        const ollama = discovery.ollama;
+        if (!ollama.available)
+            return ollama.commandAvailable ? messages.agents.ollamaUnreachable : messages.agents.ollamaNotDetected;
+        return ollama.models.includes(agentConfig.model) ? messages.agents.detected() : messages.agents.missingModel(agentConfig.model);
+    }
+    const detection = cliDetectionForAgent(name, agentConfig, discovery);
+    return detection.available ? messages.agents.detected(detection.command) : messages.agents.notDetected;
+}
+function cliDetectionForAgent(name, agentConfig, discovery) {
+    const command = agentConfig.type === "cli" || agentConfig.type === "cli-pty" ? agentConfig.command : name;
+    return detectionForCommand(command, discovery) ?? { available: true, command };
+}

package/dist/commands/context.js

@@ -0,0 +1,31 @@
+/** @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";
+/**
+ * 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";
+    if (subcommand !== "scan") {
+        throw new Error(messages.common.unknownCommand(`context ${subcommand}`, "context scan"));
+    }
+    const result = await buildContextScan(positionals.slice(1), process.cwd(), messages);
+    if (flags.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    for (const folder of result.items.filter((item) => item.kind === "folder")) {
+        console.log(`[folder] ${folder.path}`);
+    }
+    for (const file of result.items.filter((item) => item.kind === "file")) {
+        console.log(`[file] ${file.path} (${file.sizeBytes} bytes)`);
+    }
+    for (const warning of result.warnings) {
+        console.error(`${messages.renderers.warningPrefix} ${warning}`);
+    }
+}

package/dist/commands/history.js

@@ -0,0 +1,33 @@
+/** @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";
+/**
+ * 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;
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config?.language
+    }));
+    const entries = await listHistoryEntries(resolveOutputDir(config?.outputDir));
+    if (flags.json) {
+        process.stdout.write(JSON.stringify({ v: 1, history: entries }) + "\n");
+        return;
+    }
+    console.log(messages.tui.historyTitle);
+    console.log("");
+    if (entries.length === 0) {
+        console.log(messages.tui.historyEmpty);
+        return;
+    }
+    for (const entry of entries) {
+        console.log(`- ${entry.date || entry.fileName} | ${entry.mode} | ${entry.topic}`);
+        console.log(`  ${entry.path}`);
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,64 @@
+/** @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";
+/**
+ * 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) }));
+    if (await configExists(configPath)) {
+        console.log(startupMessages.init.configExists(configPath));
+        return;
+    }
+    const discovery = await discoverLocalTools({ ollamaUrl: optionalString(flags["ollama-url"]) });
+    const config = createConfigFromDiscovery(discovery);
+    config.language = resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config.language
+    });
+    const messages = createTranslator(config.language);
+    await writeConfig(configPath, config);
+    console.log(messages.init.configCreated(configPath));
+    printInitDiscovery(discovery, config, messages);
+}
+function printInitDiscovery(discovery, config, messages) {
+    console.log("");
+    console.log(messages.init.localDetectionTitle);
+    console.log(`- Codex CLI: ${formatCommandDetection(discovery.codex, messages)}`);
+    console.log(`- Claude CLI: ${formatCommandDetection(discovery.claude, messages)}`);
+    console.log(`- Antigravity CLI: ${formatCommandDetection(discovery.antigravity, messages)}`);
+    console.log(`- OpenCode CLI: ${formatCommandDetection(discovery.opencode, messages)}`);
+    console.log(`- Mistral Vibe CLI: ${formatCommandDetection(discovery.vibe, messages)}`);
+    console.log(`- Ollama API: ${formatOllamaDetection(discovery.ollama, messages)}`);
+    console.log("");
+    console.log(config.defaults?.agentA && config.defaults.agentB
+        ? messages.init.defaults(config.defaults.agentA, config.defaults.agentB)
+        : messages.init.noDefaultPair(formatDetectedAgentSummary(discovery, config.language ?? DEFAULT_LANGUAGE)));
+    console.log(messages.init.languageHint(config.language ?? DEFAULT_LANGUAGE));
+}
+function formatDetectedAgentSummary(discovery, language) {
+    const names = detectedAgentNames(discovery);
+    if (names.length === 0)
+        return language === "en" ? "no agent detected" : "aucun agent détecté";
+    if (names.length === 1) {
+        return language === "en" ? `only one agent detected (${names[0]})` : `un seul agent détecté (${names[0]})`;
+    }
+    return language === "en"
+        ? `no usable pair detected among ${names.join(", ")}`
+        : `aucune paire utilisable détectée parmi ${names.join(", ")}`;
+}
+function formatCommandDetection(detection, messages) {
+    return detection.available ? messages.init.commandDetected(detection.command) : messages.init.commandMissing;
+}
+function formatOllamaDetection(detection, messages) {
+    if (!detection.available) {
+        return detection.commandAvailable ? messages.init.ollamaServerUnreachable(detection.baseUrl) : messages.init.ollamaMissing;
+    }
+    return messages.init.ollamaDetected(detection.models.length);
+}

package/dist/commands/presets.js

@@ -0,0 +1,39 @@
+/** @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";
+/**
+ * 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"]);
+    const config = await configExists(configPath) ? await loadConfig(configPath) : undefined;
+    const discovery = config
+        ? await discoverLocalToolsForConfig(config, ollamaUrl)
+        : await discoverLocalTools({ ollamaUrl });
+    const resolvedConfig = config ?? createConfigFromDiscovery(discovery);
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: resolvedConfig.language
+    }));
+    const presets = listPresetsWithAvailability(resolvedConfig, discovery, messages);
+    if (flags.json) {
+        process.stdout.write(JSON.stringify({ v: 1, presets }) + "\n");
+        return;
+    }
+    console.log(messages.presets.title);
+    console.log("");
+    for (const preset of presets) {
+        const status = preset.available
+            ? messages.presets.available
+            : messages.presets.unavailable(preset.unavailableReasons.join("; "));
+        console.log(`  ${preset.name.padEnd(20)} ${preset.agentA} <-> ${preset.agentB}  ${status}`);
+    }
+    console.log("");
+    console.log(messages.presets.total(presets.length));
+}

package/dist/commands/shared.js

@@ -0,0 +1,8 @@
+/**
+ * Extrait une chaîne non vide depuis une valeur de flag.
+ * @param value - Valeur brute produite par le parseur CLI.
+ * @returns La chaîne non vide, sinon `undefined`.
+ */
+export function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}

package/dist/commands/update.js

@@ -0,0 +1,26 @@
+/** @file Commande de diagnostic et application des mises a jour Palabre. */
+import { configExists, loadConfig, resolveDefaultConfigPath } from "../config.js";
+import { createTranslator, resolveLanguage } from "../i18n.js";
+import { applySourceUpdate, formatUpdateInstructions, getUpdateInfo } from "../update.js";
+import { getPackageVersion } from "../version.js";
+import { optionalString } from "./shared.js";
+/**
+ * Affiche les instructions de mise à jour ou applique le workflow d'un checkout source.
+ * @param flags - Flags de config, langue et application explicite.
+ * @returns Une promesse résolue après affichage ou mise à jour.
+ */
+export async function runUpdateCommand(flags) {
+    const info = await getUpdateInfo(await getPackageVersion());
+    const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    const config = await configExists(configPath) ? await loadConfig(configPath) : undefined;
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config?.language
+    }));
+    if (flags.apply) {
+        await applySourceUpdate(info, messages);
+        console.log(messages.update.upToDate);
+        return;
+    }
+    console.log(formatUpdateInstructions(info, messages));
+}

package/dist/config.js

@@ -1,3 +1,4 @@
+/** @file Chargement, génération et validation de la config Palabre, ainsi que la synchronisation des agents/modèles Ollama détectés. */
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -234,6 +235,10 @@ function migrateVibePlanAgent(config) {
 function isLegacyVibePlanArgs(args) {
     return JSON.stringify(args) === JSON.stringify(["--output", "text", "--agent", "plan", "--trust", "--prompt"]);
 }
+/**
+ * Variante de `syncDetectedAgents` qui indique aussi si la config a changé,
+ * même quand aucun agent n'a été ajouté (ex. migration d'arguments legacy).
+ */
 export function syncDetectedAgentsDetailed(config, discovery) {
     const before = JSON.stringify(config.agents);
     const addedAgents = syncDetectedAgents(config, discovery);
@@ -243,6 +248,12 @@ export function syncDetectedAgentsDetailed(config, discovery) {
         changed
     };
 }
+/**
+ * Bascule le modèle de l'agent `ollama-local` vers un modèle installé si celui configuré
+ * ne l'est pas. Mute `config` directement.
+ * @returns `undefined` si l'agent n'est pas de type `ollama`, si aucun modèle n'est installé,
+ * ou si le modèle configuré est déjà installé.
+ */
 export function syncOllamaModel(config, discovery) {
     const agent = config.agents["ollama-local"];
     if (agent?.type !== "ollama" || discovery.ollama.models.length === 0) {
@@ -258,6 +269,11 @@ export function syncOllamaModel(config, discovery) {
         nextModel: agent.model
     };
 }
+/**
+ * Force le modèle de l'agent `ollama-local` à `model`, sans vérifier qu'il est installé.
+ * Mute `config` directement.
+ * @returns `undefined` si l'agent n'est pas de type `ollama`.
+ */
 export function setOllamaModel(config, model) {
     const agent = config.agents["ollama-local"];
     if (agent?.type !== "ollama") {
@@ -279,7 +295,7 @@ export function setOllamaBaseUrl(config, baseUrl) {
     return agents.length;
 }
 /** Écrit `config` sérialisé en JSON dans `configPath`. Crée le répertoire parent si nécessaire. */
-export async function writeExampleConfig(configPath = DEFAULT_CONFIG_PATH, config = exampleConfig) {
+export async function writeConfig(configPath = DEFAULT_CONFIG_PATH, config = exampleConfig) {
     const resolved = path.resolve(configPath);
     await mkdir(path.dirname(resolved), { recursive: true });
     await writeFile(resolved, `${JSON.stringify(config, null, 2)}\n`, "utf8");

package/dist/configWizard.js

@@ -1,6 +1,7 @@
+/** @file Wizard interactif `palabre config` (sans sous-commande) pour éditer les defaults au clavier. */
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import { syncDetectedAgents, writeExampleConfig } from "./config.js";
+import { syncDetectedAgents, writeConfig } from "./config.js";
 import { discoverLocalTools } from "./discovery.js";
 import { DEFAULT_TURNS, MAX_TURNS, turnsOrDefault, validateTurns } from "./limits.js";
 /**
@@ -36,7 +37,7 @@ export async function runConfigWizard(configPath, config, messages) {
         }
         if (action === "2") {
             delete config.defaults;
-            await writeExampleConfig(configPath, config);
+            await writeConfig(configPath, config);
             console.log(messages.config.wizardCleared(configPath));
             return;
         }
@@ -47,7 +48,7 @@ export async function runConfigWizard(configPath, config, messages) {
                 console.log(messages.config.syncNoMissing(configPath));
                 return;
             }
-            await writeExampleConfig(configPath, config);
+            await writeConfig(configPath, config);
             console.log(messages.config.syncAdded(configPath, addedAgents.join(", ")));
             return;
         }
@@ -75,7 +76,7 @@ export async function runConfigWizard(configPath, config, messages) {
         else {
             delete config.defaults.summaryAgent;
         }
-        await writeExampleConfig(configPath, config);
+        await writeConfig(configPath, config);
         console.log(messages.config.wizardDefaultsSet(configPath, formatDefaults(config.defaults, messages)));
     }
     finally {

package/dist/context.js

@@ -1,3 +1,4 @@
+/** @file Chargement du contexte projet : `--files` strict et `--context` tolérant avec règles `.gitignore` simplifiées. */
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { createTranslator } from "./i18n.js";

package/dist/contextScan.js

@@ -1,11 +1,12 @@
+/** @file Contrat JSON v1 de `palabre context scan --json`, consommé par les intégrations. */
 import path from "node:path";
 import { loadProjectInputs } from "./context.js";
 import { createTranslator } from "./i18n.js";
 /**
- * Builds the machine-readable context preview used by integrations.
+ * Construit l'aperçu de contexte lisible par une machine, utilisé par les intégrations.
  *
- * The scan intentionally reuses the same tolerant loader as `--context`, so
- * the returned files are the files Palabre would actually inject into a debate.
+ * Le scan réutilise volontairement le même chargeur tolérant que `--context`, afin que
+ * les fichiers renvoyés soient exactement ceux que Palabre injecterait dans un débat.
  */
 export async function buildContextScan(scanPaths, cwd = process.cwd(), messages = createTranslator("fr")) {
     const effectiveScanPaths = scanPaths.length > 0 ? scanPaths : ["."];

package/dist/discovery.js

@@ -1,7 +1,8 @@
+/** @file Détection locale des CLIs agents et d'Ollama, utilisée par `init`, `doctor`, `presets` et l'accueil TUI. */
 import { access } from "node:fs/promises";
 import path from "node:path";
 import { executableExtensions } from "./exec.js";
-import { resolveOllamaBaseUrl } from "./ollamaUrl.js";
+import { configuredOllamaTargets, resolveOllamaBaseUrl } from "./ollamaUrl.js";
 /**
  * Détecte en parallèle toutes les CLIs supportées et le serveur Ollama local.
  * Sur Windows, tente `claude.exe` avant `claude`.
@@ -134,3 +135,10 @@ async function isAccessible(filePath) {
         return false;
     }
 }
+/** Détecte les outils en tenant compte de tous les serveurs Ollama configurés. */
+export function discoverLocalToolsForConfig(config, ollamaUrl) {
+    return discoverLocalTools({
+        ollamaUrl,
+        ollamaTargets: configuredOllamaTargets(config)
+    });
+}

package/dist/doctor.js

@@ -1,3 +1,4 @@
+/** @file Diagnostic `palabre doctor` : vérifie config, agents détectés et connectivité Ollama. */
 import path from "node:path";
 import { stat } from "node:fs/promises";
 import { configExists, loadConfig, resolveDefaultConfigPath, resolveOutputDir } from "./config.js";

package/dist/errors.js

@@ -20,3 +20,7 @@ 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;
 }
+/** Construit l'`AdapterError` standard d'annulation utilisateur, partagée par tous les adapters. */
+export function cancelledError(adapterName) {
+    return new AdapterError("cancelled", adapterName, `${adapterName} cancelled by user.`);
+}

package/dist/exec.js

@@ -1,3 +1,4 @@
+/** @file Résolution d'extensions exécutables partagée entre discovery et l'adapter PTY. */
 import path from "node:path";
 /**
  * Extensions exécutables candidates pour résoudre une commande dans le PATH.

package/dist/history.js

@@ -1,6 +1,12 @@
+/** @file Liste les exports Markdown récents en reparsant leur table de métadonnées, pour `palabre history` et la TUI. */
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
+/** Limite de lecture par fichier : la table de métadonnées est toujours en tête de l'export. */
 const maxHeaderBytes = 12_000;
+/**
+ * Liste les exports les plus récents d'un dossier de sortie, triés par date de modification.
+ * Silencieux si `outputDir` est absent ou inaccessible : retourne `[]` sans lever.
+ */
 export async function listHistoryEntries(outputDir, limit = 10) {
     const resolved = path.resolve(outputDir);
     let entries;
@@ -19,6 +25,7 @@ export async function listHistoryEntries(outputDir, limit = 10) {
         .sort((left, right) => right.mtimeMs - left.mtimeMs)
         .slice(0, limit);
 }
+/** Lit et parse un fichier d'export. Retourne `undefined` sur toute erreur filesystem/parsing plutôt que de lever. */
 async function readHistoryFile(filePath) {
     try {
         const [metadata, raw] = await Promise.all([
@@ -44,6 +51,7 @@ async function readHistoryFile(filePath) {
         return undefined;
     }
 }
+/** Formate le compteur `x/y` adapté au mode, en tolérant les clés FR/EN de la table de métadonnées. */
 function countFromTable(mode, table) {
     if (mode === "ask") {
         const received = table["Reponses recues"] ?? table["Received responses"];
@@ -54,6 +62,7 @@ function countFromTable(mode, table) {
     const requested = table["Tours demandes"] ?? table["Requested turns"];
     return played && requested ? `${played}/${requested}` : played ?? requested ?? "";
 }
+/** Extrait les paires clé/valeur de la table Markdown `| Champ | Valeur |` générée par l'export. */
 function parseMetadataTable(markdown) {
     const fields = {};
     const lines = markdown.split(/\r?\n/);
@@ -75,6 +84,7 @@ function stripMarkdown(value) {
         .replace(/`/g, "")
         .trim();
 }
+/** Reconstruit un sujet lisible depuis le nom de fichier quand la table de métadonnées ne l'indique pas. */
 function topicFromFileName(fileName) {
     return fileName
         .replace(/^palabre-/, "")

package/dist/i18n.js

@@ -1,5 +1,7 @@
 import { createTranslator } from "./messages/index.js";
+/** Langue utilisée quand aucune source explicite (flag, env, config) n'en fournit une valide. */
 export const DEFAULT_LANGUAGE = "fr";
+/** Langues acceptées par `parseLanguage`/`resolveLanguage`. */
 export const SUPPORTED_LANGUAGES = ["fr", "en"];
 /**
  * Valide une langue Palabre.