palabre 0.1.4

package/dist/limits.js

@@ -0,0 +1,41 @@
+export const DEFAULT_TURNS = 4;
+export const MAX_TURNS = 20;
+/** Convertit `value` en nombre et valide la plage [1, `MAX_TURNS`]. Lève une erreur si invalide. */
+export function parseTurns(value, label = "--turns") {
+    const parsed = typeof value === "number" ? value : Number(value ?? DEFAULT_TURNS);
+    validateTurns(parsed, label);
+    return parsed;
+}
+/**
+ * Variante pour les flags CLI : gère les types polymorphes retournés par les parsers d'arguments
+ * (`boolean` pour un flag sans valeur, `string[]` si fourni plusieurs fois).
+ * Lève une erreur si `value` est un booléen ou un tableau de longueur ≠ 1.
+ */
+export function parseTurnsFlag(value, fallback = DEFAULT_TURNS, label = "--turns") {
+    if (value === undefined) {
+        return parseTurns(fallback, label);
+    }
+    if (typeof value === "boolean") {
+        throw new Error(`${label} attend un nombre entier entre 1 et ${MAX_TURNS}.`);
+    }
+    if (Array.isArray(value)) {
+        if (value.length !== 1) {
+            throw new Error(`${label} doit être fourni une seule fois.`);
+        }
+        return parseTurns(value[0], label);
+    }
+    return parseTurns(value, label);
+}
+/** Valide que `value` est un entier dans [1, `MAX_TURNS`]. Lève une erreur descriptive sinon. */
+export function validateTurns(value, label = "--turns") {
+    if (!Number.isInteger(value) || value < 1 || value > MAX_TURNS) {
+        throw new Error(`${label} doit être un nombre entier entre 1 et ${MAX_TURNS}.`);
+    }
+}
+/** Retourne `value` s'il est valide, sinon `DEFAULT_TURNS`. Silencieux : ne lève pas d'erreur. */
+export function turnsOrDefault(value) {
+    if (value !== undefined && Number.isInteger(value) && value >= 1 && value <= MAX_TURNS) {
+        return value;
+    }
+    return DEFAULT_TURNS;
+}

package/dist/new.js

@@ -0,0 +1,312 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { discoverLocalTools } from "./discovery.js";
+import { findPresetNameForPair } from "./presets.js";
+import { MAX_TURNS, turnsOrDefault, validateTurns } from "./limits.js";
+/**
+ * Lance le wizard interactif `palabre new`.
+ * Détecte les outils locaux, liste les agents de la config et guide la composition du débat.
+ * Retourne `undefined` si l'utilisateur annule (q/quit/exit ou Ctrl+C).
+ */
+export async function runNewWizard(config) {
+    const discovery = await discoverLocalTools();
+    const choices = buildAgentChoices(config, discovery);
+    if (choices.length < 2) {
+        throw new Error("palabre new a besoin d'au moins deux agents dans la config. Lance `palabre init` ou edite ta config.");
+    }
+    const rl = await createQuestioner();
+    try {
+        console.log("PALABRE - ASSISTANT DE CONFIGURATION");
+        console.log("À tout moment: Ctrl+C pour interrompre, ou tape q, quit ou exit dans un prompt pour quitter.");
+        console.log("Appuie sur Entrée pour accepter un choix par défaut (*).");
+        console.log("");
+        const agentA = await askAgent(rl, choices, "Agent A", config.defaults?.agentA);
+        if (!agentA)
+            return undefined;
+        const agentB = await askAgent(rl, choices.filter((choice) => choice.name !== agentA), "Agent B", config.defaults?.agentB === agentA ? undefined : config.defaults?.agentB);
+        if (!agentB)
+            return undefined;
+        const topic = await askRequiredText(rl, "Sujet");
+        if (!topic)
+            return undefined;
+        printCommandPreview({ agentA, agentB, topic, turns: turnsOrDefault(config.defaults?.turns) });
+        console.log("Réponds non pour choisir le nombre de réponses, les modèles, la synthèse et le contexte.");
+        const launchMinimal = await askYesNo(rl, "Lancer maintenant avec les options par défaut ?", true);
+        if (launchMinimal === undefined)
+            return undefined;
+        if (launchMinimal) {
+            return {
+                agentA,
+                agentB,
+                topic,
+                files: [],
+                context: [],
+                showPrompt: false,
+                plainOutput: false
+            };
+        }
+        const turns = await askNumber(rl, "Nombre de réponses", turnsOrDefault(config.defaults?.turns));
+        if (turns === undefined)
+            return undefined;
+        const modelA = await askOptionalText(rl, `Modèle pour ${agentA} (optionnel)`);
+        if (modelA === undefined)
+            return undefined;
+        const modelB = await askOptionalText(rl, `Modèle pour ${agentB} (optionnel)`);
+        if (modelB === undefined)
+            return undefined;
+        const summaryEnabled = await askYesNo(rl, "Synthèse finale ?", true);
+        if (summaryEnabled === undefined)
+            return undefined;
+        let summaryAgent;
+        let summaryModel;
+        if (summaryEnabled) {
+            summaryAgent = await askAgent(rl, choices, "Agent de synthèse", config.defaults?.summaryAgent ?? agentB);
+            if (!summaryAgent)
+                return undefined;
+            summaryModel = await askOptionalText(rl, `Modèle de synthèse pour ${summaryAgent} (optionnel)`);
+            if (summaryModel === undefined)
+                return undefined;
+        }
+        const context = splitPaths(await askOptionalText(rl, "Contexte dossier/fichier via --context (optionnel)"));
+        const files = splitPaths(await askOptionalText(rl, "Fichiers stricts via --files (optionnel)"));
+        const showPrompt = await askYesNo(rl, "Afficher seulement le prompt ?", false);
+        if (showPrompt === undefined)
+            return undefined;
+        const plainOutput = await askYesNo(rl, "Rendu plain ?", false);
+        if (plainOutput === undefined)
+            return undefined;
+        const selection = {
+            agentA,
+            agentB,
+            topic,
+            modelA,
+            modelB,
+            turns,
+            summaryAgent,
+            summaryModel,
+            summaryEnabled,
+            files,
+            context,
+            showPrompt,
+            plainOutput
+        };
+        printCommandPreview(selection);
+        return selection;
+    }
+    finally {
+        rl.close();
+    }
+}
+async function createQuestioner() {
+    if (input.isTTY) {
+        return createInterface({ input, output });
+    }
+    const lines = await readPipedLines();
+    let index = 0;
+    return {
+        async question(prompt) {
+            output.write(prompt);
+            const value = lines[index];
+            index += 1;
+            output.write(`${value ?? "q"}\n`);
+            return value ?? "q";
+        },
+        close() {
+            // Nothing to close for scripted stdin.
+        }
+    };
+}
+async function readPipedLines() {
+    let raw = "";
+    for await (const chunk of input) {
+        raw += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+    }
+    return raw.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+}
+function buildAgentChoices(config, discovery) {
+    return Object.entries(config.agents)
+        .map(([name, agentConfig]) => {
+        const detected = isAgentDetected(name, agentConfig, discovery);
+        return {
+            name,
+            config: agentConfig,
+            detected,
+            status: agentStatus(name, agentConfig, discovery, detected)
+        };
+    })
+        .sort((left, right) => Number(right.detected) - Number(left.detected) || left.name.localeCompare(right.name));
+}
+function isAgentDetected(name, config, discovery) {
+    if (config.type === "ollama") {
+        return discovery.ollama.available;
+    }
+    const normalized = normalizeCommandName(config.command || name);
+    if (normalized === "codex")
+        return discovery.codex.available;
+    if (normalized === "claude")
+        return discovery.claude.available;
+    if (normalized === "gemini")
+        return discovery.gemini.available;
+    if (normalized === "opencode")
+        return discovery.opencode.available;
+    return true;
+}
+function agentStatus(_name, config, discovery, detected) {
+    if (config.type === "ollama") {
+        return detected
+            ? `ollama/${config.role} détecté (${discovery.ollama.models.length} modèle(s))`
+            : `ollama/${config.role} non joignable`;
+    }
+    return detected
+        ? `cli/${config.role} détecté`
+        : `cli/${config.role} non détecté`;
+}
+async function askAgent(rl, choices, label, defaultName) {
+    const fallback = choices.find((choice) => choice.name === defaultName)?.name ?? choices[0]?.name;
+    console.log(label);
+    choices.forEach((choice, index) => {
+        const marker = choice.name === fallback ? "(*)" : "   ";
+        console.log(`  ${index + 1}) ${marker} ${choice.name} - ${choice.status}`);
+    });
+    while (true) {
+        const answer = await rl.question(`${label} [${fallback}]: `);
+        const value = answer.trim();
+        if (isQuit(value))
+            return undefined;
+        if (!value)
+            return fallback;
+        const number = Number(value);
+        if (Number.isInteger(number) && number >= 1 && number <= choices.length) {
+            return choices[number - 1]?.name;
+        }
+        if (choices.some((choice) => choice.name === value)) {
+            return value;
+        }
+        console.log("Choix invalide. Tape un numéro, un nom d'agent, Entrée ou q.");
+    }
+}
+async function askRequiredText(rl, label) {
+    while (true) {
+        const answer = await rl.question(`${label}: `);
+        const value = answer.trim();
+        if (isQuit(value))
+            return undefined;
+        if (value)
+            return value;
+        console.log("Ce champ est requis pour lancer un débat.");
+    }
+}
+async function askOptionalText(rl, label) {
+    const answer = await rl.question(`${label}: `);
+    const value = answer.trim();
+    return isQuit(value) ? undefined : value;
+}
+async function askNumber(rl, label, defaultValue) {
+    while (true) {
+        const answer = await rl.question(`${label} [${defaultValue}]: `);
+        const value = answer.trim();
+        if (isQuit(value))
+            return undefined;
+        if (!value)
+            return defaultValue;
+        const parsed = Number(value);
+        if (Number.isInteger(parsed)) {
+            try {
+                validateTurns(parsed, "Le nombre de réponses");
+                return parsed;
+            }
+            catch {
+                // Show the user-facing wizard hint below.
+            }
+        }
+        console.log(`Entre un nombre entier entre 1 et ${MAX_TURNS}, Entrée ou q.`);
+    }
+}
+async function askYesNo(rl, label, defaultValue) {
+    const suffix = defaultValue ? "Y/n" : "y/N";
+    while (true) {
+        const answer = await rl.question(`${label} [${suffix}]: `);
+        const value = answer.trim().toLowerCase();
+        if (isQuit(value))
+            return undefined;
+        if (!value)
+            return defaultValue;
+        if (["y", "yes", "o", "oui"].includes(value))
+            return true;
+        if (["n", "no", "non"].includes(value))
+            return false;
+        console.log("Réponds par oui, non, Entrée ou q.");
+    }
+}
+function splitPaths(value) {
+    return value
+        ?.split(/\s+/)
+        .map((entry) => entry.trim())
+        .filter(Boolean) ?? [];
+}
+function normalizeCommandName(command) {
+    return command
+        .split(/[\\/]/)
+        .pop()
+        ?.toLowerCase()
+        .replace(/\.(exe|cmd|bat|ps1)$/i, "") ?? command.toLowerCase();
+}
+function isQuit(value) {
+    return ["q", "quit", "exit"].includes(value.toLowerCase());
+}
+function printCommandPreview(selection) {
+    const explicitCommand = buildExplicitCommand(selection);
+    const shortCommand = buildShortCommand(selection);
+    console.log("");
+    console.log("Commandes équivalentes:");
+    console.log(`  ${explicitCommand}`);
+    if (shortCommand) {
+        console.log(`  ${shortCommand}`);
+    }
+    console.log("");
+}
+function buildExplicitCommand(selection) {
+    const args = ["palabre"];
+    args.push("--agent-a", selection.agentA);
+    args.push("--agent-b", selection.agentB);
+    args.push(quoteShellArg(selection.topic));
+    appendOptionalArgs(args, selection);
+    return args.join(" ");
+}
+function buildShortCommand(selection) {
+    const presetName = findPresetNameForPair(selection.agentA, selection.agentB);
+    if (!presetName) {
+        return undefined;
+    }
+    const args = ["palabre", presetName, quoteShellArg(selection.topic)];
+    appendOptionalArgs(args, selection);
+    return args.join(" ");
+}
+function appendOptionalArgs(args, selection) {
+    if (selection.turns)
+        args.push("-t", String(selection.turns));
+    if (selection.modelA)
+        args.push("--model-a", quoteShellArg(selection.modelA));
+    if (selection.modelB)
+        args.push("--model-b", quoteShellArg(selection.modelB));
+    if (selection.summaryEnabled === false)
+        args.push("--no-summary");
+    if (selection.summaryAgent)
+        args.push("--summary-agent", selection.summaryAgent);
+    if (selection.summaryModel)
+        args.push("--summary-model", quoteShellArg(selection.summaryModel));
+    if (selection.context && selection.context.length > 0)
+        args.push("--context", ...selection.context.map(quoteShellArg));
+    if (selection.files && selection.files.length > 0)
+        args.push("--files", ...selection.files.map(quoteShellArg));
+    if (selection.showPrompt)
+        args.push("--show-prompt");
+    if (selection.plainOutput)
+        args.push("--plain");
+}
+function quoteShellArg(value) {
+    if (/^[A-Za-z0-9._/:\\-]+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/(["`$\\])/g, "\\$1")}"`;
+}

package/dist/orchestrator.js

@@ -0,0 +1,195 @@
+import { createAgent } from "./adapters/index.js";
+/**
+ * Point d'entrée de l'orchestration.
+ * Lance le ping-pong entre `agentA` et `agentB` pendant `options.turns` tours,
+ * applique l'arrêt anticipé si activé, puis génère la synthèse si `summaryEnabled` est vrai.
+ *
+ * @throws {Error} si un agent référencé dans `options` est absent de `config.agents`.
+ */
+export async function runDebate(config, options, renderer) {
+    const agentAConfig = withRuntimeOverrides(config.agents[options.agentA], options.modelA, options.pullModels);
+    const agentBConfig = withRuntimeOverrides(config.agents[options.agentB], options.modelB, options.pullModels);
+    if (!agentAConfig) {
+        throw new Error(`Agent inconnu: ${options.agentA}`);
+    }
+    if (!agentBConfig) {
+        throw new Error(`Agent inconnu: ${options.agentB}`);
+    }
+    warnIfOllamaHasNoContext(options, [
+        [options.agentA, agentAConfig],
+        [options.agentB, agentBConfig]
+    ], renderer);
+    renderer?.start(options, [
+        { name: options.agentA, role: agentAConfig.role, type: agentAConfig.type },
+        { name: options.agentB, role: agentBConfig.role, type: agentBConfig.type }
+    ]);
+    const agents = [
+        createAgent(options.agentA, agentAConfig),
+        createAgent(options.agentB, agentBConfig)
+    ];
+    const messages = [];
+    let stopReason;
+    for (let index = 0; index < options.turns; index += 1) {
+        const current = agents[index % agents.length];
+        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);
+        const response = await current.generate({
+            topic: options.topic,
+            turn,
+            selfName: current.name,
+            peerName: peer.name,
+            selfRole: current.role,
+            session: options.session,
+            files: options.files,
+            transcript: messages
+        }).finally(() => renderer?.thinkingEnd());
+        const message = {
+            agent: current.name,
+            role: current.role,
+            content: response.content,
+            createdAt: new Date().toISOString()
+        };
+        messages.push(message);
+        renderer?.message(message.content);
+        if (shouldStopOnAgreement(options, messages)) {
+            stopReason = "Accord clair detecte apres un tour complet.";
+            renderer?.notice(`Arret anticipe: ${stopReason}`);
+            break;
+        }
+    }
+    const summary = options.summaryEnabled
+        ? await generateSummary(config, options, messages, renderer)
+        : undefined;
+    return {
+        options,
+        messages,
+        summary,
+        stopReason
+    };
+}
+/**
+ * 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.
+ * Intentionnellement prudente : ne remplace pas une évaluation sémantique réelle.
+ */
+function shouldStopOnAgreement(options, messages) {
+    if (!options.earlyStopOnAgreement || messages.length < 2 || messages.length % 2 !== 0) {
+        return false;
+    }
+    const latest = normalizeForAgreement(messages[messages.length - 1]?.content ?? "");
+    if (!latest) {
+        return false;
+    }
+    const positivePatterns = [
+        "accord complet",
+        "accord total",
+        "aucun desaccord",
+        "aucune incertitude",
+        "rien a trancher",
+        "rien a ajouter",
+        "question factuelle resolue"
+    ];
+    if (positivePatterns.some((pattern) => latest.includes(pattern))) {
+        return true;
+    }
+    return (latest.includes("confirme") || latest.includes("acte")) &&
+        (latest.includes("aucun") || latest.includes("rien a trancher") || latest.includes("rien a ajouter"));
+}
+/** Normalise le texte pour la détection d'accord : minuscules, sans diacritiques, espaces unifiés. */
+function normalizeForAgreement(value) {
+    return value
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
+        .replace(/[’']/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/**
+ * Émet un avertissement si un agent Ollama participe sans contexte fichier.
+ * L'adapter Ollama ne lit pas le filesystem : sans `--files` ou `--context`, il ne voit pas le projet.
+ */
+function warnIfOllamaHasNoContext(options, agents, renderer) {
+    if (options.files.length > 0) {
+        return;
+    }
+    const ollamaAgents = agents
+        .filter(([, config]) => config.type === "ollama")
+        .map(([name]) => name)
+        .filter((name, index, names) => names.indexOf(name) === index);
+    if (ollamaAgents.length === 0) {
+        return;
+    }
+    renderer?.warning(`${ollamaAgents.join(", ")} ne lit pas le filesystem. Ajoute --files ou --context pour fournir un contexte projet.`);
+}
+/**
+ * Phase de synthèse post-débat. Utilise `options.summaryAgent` quand il est défini, sinon `agentB`.
+ *
+ * @throws {Error} si l'agent de synthèse est absent de `config.agents`.
+ */
+async function generateSummary(config, options, messages, renderer) {
+    const summaryAgentName = options.summaryAgent ?? options.agentB;
+    const summaryModel = options.summaryModel ?? modelForAgent(options, summaryAgentName);
+    const summaryConfig = withRuntimeOverrides(config.agents[summaryAgentName], summaryModel, options.pullModels);
+    if (!summaryConfig) {
+        throw new Error(`Agent de synthese inconnu: ${summaryAgentName}`);
+    }
+    const summaryAgent = createAgent(summaryAgentName, summaryConfig);
+    renderer?.summaryStart(summaryAgent.name, summaryAgent.role);
+    renderer?.thinkingStart(summaryAgent.name, summaryAgent.role);
+    const response = await summaryAgent.generate({
+        topic: options.topic,
+        turn: messages.length + 1,
+        selfName: summaryAgent.name,
+        peerName: "transcript",
+        selfRole: summaryAgent.role,
+        mode: "summary",
+        session: options.session,
+        files: options.files,
+        transcript: messages
+    }).finally(() => renderer?.thinkingEnd());
+    const summary = {
+        agent: summaryAgent.name,
+        role: summaryAgent.role,
+        content: response.content,
+        createdAt: new Date().toISOString()
+    };
+    renderer?.message(summary.content);
+    return summary;
+}
+/** Résout le model override pour un agent donné. Retourne `undefined` si l'agent n'est ni A ni B. */
+function modelForAgent(options, agent) {
+    if (agent === options.agentA) {
+        return options.modelA;
+    }
+    if (agent === options.agentB) {
+        return options.modelB;
+    }
+    return undefined;
+}
+/**
+ * Fusionne les overrides runtime dans la config agent.
+ * Pour l'adapter `ollama`, applique aussi `autoPullModel` si `pullModels` est vrai.
+ * Retourne `undefined` si `config` est `undefined`.
+ */
+function withRuntimeOverrides(config, model, pullModels) {
+    if (!config) {
+        return config;
+    }
+    if (config.type === "ollama") {
+        return {
+            ...config,
+            ...(model ? { model } : {}),
+            ...(pullModels ? { autoPullModel: true } : {})
+        };
+    }
+    if (!model) {
+        return config;
+    }
+    return {
+        ...config,
+        model
+    };
+}

package/dist/output.js

@@ -0,0 +1,100 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+/**
+ * Écrit le débat au format Markdown dans `outputDir`.
+ * Crée le répertoire si absent. Retourne le chemin absolu du fichier créé.
+ */
+export async function writeDebateMarkdown(outputDir, options, messages, summary, stopReason) {
+    const safeDate = new Date().toISOString().replace(/[:.]/g, "-");
+    const fileName = `palabre-${slugifyTopic(options.topic)}-${safeDate}.debate.md`;
+    const filePath = path.resolve(outputDir, fileName);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, renderDebateMarkdown(options, messages, summary, stopReason), "utf8");
+    return filePath;
+}
+function slugifyTopic(topic) {
+    const slug = topic
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64)
+        .replace(/-+$/g, "");
+    return slug || "debat";
+}
+/**
+ * Produit la représentation Markdown complète du débat.
+ * Fonction pure : aucun effet de bord sur le filesystem.
+ */
+export function renderDebateMarkdown(options, messages, summary, stopReason) {
+    const lines = [
+        "# PALABRE Debate",
+        "",
+        ...renderSessionHeader(options, messages, stopReason),
+        "",
+        "## Contexte",
+        "",
+        ...renderFileList(options.files),
+        "",
+        "## Echanges",
+        ""
+    ];
+    for (const message of messages) {
+        lines.push(`### ${message.agent} (${message.role})`, "", normalizeMarkdownForWindowsPreview(message.content.trim()), "");
+    }
+    lines.push("---", "", "## Synthese finale", "", ...renderSummaryBlock(options, summary));
+    return `${lines.join("\n")}\n`;
+}
+function renderSummaryBlock(options, summary) {
+    if (summary) {
+        return [
+            "| Champ | Valeur |",
+            "| --- | --- |",
+            `| Agent | ${escapeTableCell(summary.agent)} |`,
+            `| Role | ${escapeTableCell(summary.role)} |`,
+            `| Date | ${escapeTableCell(summary.createdAt)} |`,
+            "",
+            normalizeMarkdownForWindowsPreview(summary.content.trim()),
+            ""
+        ];
+    }
+    return [
+        options.summaryEnabled
+            ? "_Synthese finale demandee mais non disponible._"
+            : "_Synthese desactivee._",
+        ""
+    ];
+}
+function normalizeMarkdownForWindowsPreview(content) {
+    return content.replace(/:\*\*/g, ":**");
+}
+function renderSessionHeader(options, messages, stopReason) {
+    const rows = [
+        ["Sujet", options.topic],
+        ["Agents", `${options.agentA} <-> ${options.agentB}`],
+        ["Auto-pull Ollama", options.pullModels ? "yes" : "no"],
+        ["Synthese", options.summaryEnabled ? options.summaryAgent ?? options.agentB : "disabled"],
+        ["Tours demandes", String(options.turns)],
+        ["Tours joues", String(messages.length)],
+        ["Arret anticipe", stopReason ?? "no"],
+        ["Date locale", options.session.localDate],
+        ["Fuseau horaire", options.session.timeZone],
+        ["Dossier courant", options.session.cwd],
+        ["Session demarree a", options.session.startedAt]
+    ];
+    return [
+        "| Champ | Valeur |",
+        "| --- | --- |",
+        ...rows.map(([label, value]) => `| ${escapeTableCell(label)} | ${escapeTableCell(value)} |`)
+    ];
+}
+function escapeTableCell(value) {
+    return value.replace(/\|/g, "\\|").replace(/\r?\n/g, "<br>");
+}
+function renderFileList(files) {
+    if (files.length === 0) {
+        return ["Aucun contexte fichier injecte."];
+    }
+    return files.map((file) => `- \`${file.path}\` (${file.sizeBytes} bytes)`);
+}