palabre 0.1.4

package/dist/context.js

@@ -0,0 +1,198 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+const MAX_FILE_BYTES = 64 * 1024;
+const MAX_TOTAL_BYTES = 192 * 1024;
+const DEFAULT_EXCLUDED_NAMES = new Set([
+    ".git",
+    ".gitignore",
+    ".tmp",
+    ".pnpm-store",
+    "node_modules",
+    "dist"
+]);
+const TEXT_EXTENSIONS = new Set([
+    ".cjs",
+    ".css",
+    ".cts",
+    ".html",
+    ".js",
+    ".json",
+    ".jsx",
+    ".md",
+    ".mjs",
+    ".mts",
+    ".toml",
+    ".ts",
+    ".tsx",
+    ".txt",
+    ".yaml",
+    ".yml"
+]);
+/**
+ * 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);
+    return result.files;
+}
+/**
+ * Combine le chargement strict (`--files`) et tolérant (`--context`).
+ * 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()) {
+    const state = {
+        files: [],
+        warnings: [],
+        seen: new Set(),
+        totalBytes: 0,
+        gitignoreRules: await loadGitignoreRules(cwd)
+    };
+    await addExplicitFiles(filePaths, cwd, state);
+    await addContextPaths(contextPaths, cwd, state);
+    return {
+        files: state.files,
+        warnings: state.warnings
+    };
+}
+async function addExplicitFiles(paths, cwd, state) {
+    const uniquePaths = [...new Set(paths.map((item) => item.trim()).filter(Boolean))];
+    for (const inputPath of uniquePaths) {
+        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}`);
+        }
+        if (fileStat.size > MAX_FILE_BYTES) {
+            throw new Error(`Fichier trop gros pour le contexte: ${inputPath} (${fileStat.size} bytes, max ${MAX_FILE_BYTES})`);
+        }
+        const content = await readFile(absolutePath, "utf8");
+        if (content.includes("\u0000")) {
+            throw new Error(`Fichier binaire ou non texte refuse: ${inputPath}`);
+        }
+        addFileToState(cwd, state, absolutePath, content, fileStat.size, "explicit");
+    }
+}
+async function addContextPaths(paths, cwd, state) {
+    const uniquePaths = [...new Set(paths.map((item) => item.trim()).filter(Boolean))];
+    for (const inputPath of uniquePaths) {
+        const absolutePath = path.resolve(cwd, inputPath);
+        const fileStat = await stat(absolutePath);
+        if (fileStat.isFile()) {
+            await addContextFile(absolutePath, cwd, state);
+            continue;
+        }
+        if (!fileStat.isDirectory()) {
+            state.warnings.push(`Contexte ignore (ni fichier ni dossier): ${inputPath}`);
+            continue;
+        }
+        await walkContextDirectory(absolutePath, cwd, state);
+    }
+}
+async function walkContextDirectory(dir, cwd, state) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        const absolutePath = path.join(dir, entry.name);
+        const relativePath = normalizePath(path.relative(cwd, absolutePath));
+        if (shouldIgnore(relativePath, entry.name, state.gitignoreRules)) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            await walkContextDirectory(absolutePath, cwd, state);
+            continue;
+        }
+        if (entry.isFile()) {
+            await addContextFile(absolutePath, cwd, state);
+        }
+    }
+}
+async function addContextFile(absolutePath, cwd, state) {
+    const relativePath = normalizePath(path.relative(cwd, absolutePath));
+    if (state.seen.has(absolutePath)) {
+        return;
+    }
+    if (!isLikelyTextFile(absolutePath)) {
+        state.warnings.push(`Contexte ignore (extension non texte): ${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)`);
+        return;
+    }
+    if (state.totalBytes + fileStat.size > MAX_TOTAL_BYTES) {
+        state.warnings.push(`Contexte ignore (limite totale atteinte): ${relativePath}`);
+        return;
+    }
+    const content = await readFile(absolutePath, "utf8");
+    if (content.includes("\u0000")) {
+        state.warnings.push(`Contexte ignore (binaire detecte): ${relativePath}`);
+        return;
+    }
+    addFileToState(cwd, state, absolutePath, content, fileStat.size, "context");
+}
+function addFileToState(cwd, state, absolutePath, content, sizeBytes, source) {
+    if (state.seen.has(absolutePath)) {
+        return;
+    }
+    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})`);
+        }
+        state.warnings.push(`Contexte ignore (limite totale atteinte): ${normalizePath(path.relative(cwd, absolutePath))}`);
+        return;
+    }
+    state.seen.add(absolutePath);
+    state.totalBytes += sizeBytes;
+    state.files.push({
+        path: normalizePath(path.relative(cwd, absolutePath)),
+        absolutePath,
+        content,
+        sizeBytes
+    });
+}
+async function loadGitignoreRules(cwd) {
+    try {
+        const content = await readFile(path.resolve(cwd, ".gitignore"), "utf8");
+        return content
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith("#") && !line.startsWith("!"));
+    }
+    catch {
+        return [];
+    }
+}
+function shouldIgnore(relativePath, basename, gitignoreRules) {
+    if (DEFAULT_EXCLUDED_NAMES.has(basename)) {
+        return true;
+    }
+    return gitignoreRules.some((rule) => matchesGitignoreRule(relativePath, basename, rule));
+}
+function matchesGitignoreRule(relativePath, basename, rule) {
+    const normalizedRule = normalizePath(rule).replace(/\/$/, "");
+    if (normalizedRule.includes("*")) {
+        const pattern = `^${globToRegex(normalizedRule)}$`;
+        return new RegExp(pattern).test(relativePath) || new RegExp(pattern).test(basename);
+    }
+    return relativePath === normalizedRule ||
+        relativePath.startsWith(`${normalizedRule}/`) ||
+        basename === normalizedRule;
+}
+function isLikelyTextFile(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    return TEXT_EXTENSIONS.has(extension);
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/");
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function globToRegex(value) {
+    return value
+        .split("*")
+        .map((part) => escapeRegex(part))
+        .join(".*");
+}

package/dist/discovery.js

@@ -0,0 +1,121 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+/**
+ * Détecte en parallèle toutes les CLIs supportées et le serveur Ollama local.
+ * Sur Windows, tente `claude.exe` avant `claude`.
+ */
+export async function discoverLocalTools() {
+    const [codex, claude, gemini, opencode, ollamaCommand] = await Promise.all([
+        detectCommand("codex"),
+        detectFirstCommand(process.platform === "win32" ? ["claude.exe", "claude"] : ["claude"]),
+        detectCommand("gemini"),
+        detectCommand("opencode"),
+        detectCommand("ollama")
+    ]);
+    const ollamaServer = await detectOllamaServer();
+    return {
+        codex,
+        claude,
+        gemini,
+        opencode,
+        ollama: {
+            ...ollamaServer,
+            commandAvailable: ollamaCommand.available
+        }
+    };
+}
+async function detectFirstCommand(commands) {
+    for (const command of commands) {
+        const detection = await detectCommand(command);
+        if (detection.available) {
+            return detection;
+        }
+    }
+    return {
+        available: false,
+        command: commands[0] ?? ""
+    };
+}
+async function detectCommand(command) {
+    const executablePath = await findExecutable(command);
+    return {
+        available: Boolean(executablePath),
+        command,
+        ...(executablePath ? { path: executablePath } : {})
+    };
+}
+async function detectOllamaServer(baseUrl = "http://localhost:11434") {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2_000);
+    try {
+        const response = await fetch(`${baseUrl}/api/tags`, {
+            signal: controller.signal
+        });
+        if (!response.ok) {
+            return {
+                available: false,
+                baseUrl,
+                models: [],
+                error: `HTTP ${response.status}`
+            };
+        }
+        const data = await response.json();
+        const models = data.models
+            ?.map((model) => model.name ?? model.model)
+            .filter((model) => Boolean(model))
+            .sort((a, b) => a.localeCompare(b)) ?? [];
+        return {
+            available: true,
+            baseUrl,
+            models
+        };
+    }
+    catch (error) {
+        return {
+            available: false,
+            baseUrl,
+            models: [],
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function findExecutable(command) {
+    const pathEntries = (process.env.PATH ?? "")
+        .split(path.delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    const extensions = executableExtensions(command);
+    for (const entry of pathEntries) {
+        for (const extension of extensions) {
+            const candidate = path.join(entry, `${command}${extension}`);
+            if (await isAccessible(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+function executableExtensions(command) {
+    if (path.extname(command)) {
+        return [""];
+    }
+    if (process.platform !== "win32") {
+        return [""];
+    }
+    return (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+        .split(";")
+        .map((extension) => extension.toLowerCase())
+        .concat(".ps1", "");
+}
+async function isAccessible(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/doctor.js

@@ -0,0 +1,341 @@
+import path from "node:path";
+import { stat } from "node:fs/promises";
+import { configExists, loadConfig, resolveDefaultConfigPath } from "./config.js";
+import { discoverLocalTools } from "./discovery.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) {
+    const lines = [];
+    const configPath = explicitConfigPath ?? await resolveDefaultConfigPath();
+    const hasConfig = await configExists(configPath);
+    lines.push(info("PALABRE doctor"));
+    lines.push(info(`Dossier courant: ${process.cwd()}`));
+    lines.push(hasConfig
+        ? ok(`Config trouvee: ${configPath}`)
+        : error(`Config absente: ${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);
+    }
+    const config = await loadConfigSafely(configPath, lines);
+    if (!config) {
+        return render(lines, plain);
+    }
+    await inspectConfig(config, lines);
+    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(discovery.ollama.available
+        ? ok(`Ollama API joignable: ${discovery.ollama.baseUrl} (${discovery.ollama.models.length} modele(s))`)
+        : 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);
+}
+async function loadConfigSafely(configPath, lines) {
+    try {
+        const config = await loadConfig(configPath);
+        lines.push(ok("Config JSON lisible."));
+        return config;
+    }
+    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."));
+        return undefined;
+    }
+}
+async function inspectConfig(config, lines) {
+    const agentNames = Object.keys(config.agents ?? {});
+    if (agentNames.length === 0) {
+        lines.push(error("Aucun agent configure."));
+    }
+    else if (agentNames.length === 1) {
+        lines.push(warn(`1 agent configure: ${agentNames[0]}. Palabre fonctionne mieux avec au moins deux agents.`));
+    }
+    else {
+        lines.push(ok(`${agentNames.length} agent(s) configure(s): ${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);
+    if (config.defaults?.summaryAgent) {
+        inspectDefaultAgent("defaults.summaryAgent", config.defaults.summaryAgent, config, lines);
+    }
+    else {
+        lines.push(warn("defaults.summaryAgent absent: la synthese utilisera agentB."));
+    }
+    await inspectOutputDir(config.outputDir, lines);
+}
+function inspectDefaultAgent(label, agentName, config, lines) {
+    if (!agentName) {
+        lines.push(warn(`${label} absent.`));
+        return;
+    }
+    if (!config.agents[agentName]) {
+        lines.push(error(`${label} pointe vers un agent inconnu: ${agentName}`));
+        return;
+    }
+    lines.push(ok(`${label}: ${agentName}`));
+}
+function inspectDefaultPair(config, lines) {
+    const { agentA, agentB } = config.defaults ?? {};
+    if (!agentA || !agentB) {
+        lines.push(warn("Paire par defaut incomplete. Action: `palabre config --set-defaults <agentA> <agentB>`."));
+        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.`));
+    }
+}
+function inspectDefaultTurns(turns, lines) {
+    const value = turns ?? DEFAULT_TURNS;
+    if (turns === undefined) {
+        lines.push(info(`defaults.turns absent: Palabre utilisera ${DEFAULT_TURNS} reponses.`));
+        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}.`));
+        return;
+    }
+    lines.push(ok(`defaults.turns: ${value}`));
+}
+async function inspectOutputDir(outputDir, lines) {
+    const resolved = path.resolve(outputDir ?? ".");
+    if (!outputDir) {
+        lines.push(info(`outputDir absent: les exports seront ecrits dans le dossier courant (${resolved}).`));
+        return;
+    }
+    try {
+        const stats = await stat(resolved);
+        if (!stats.isDirectory()) {
+            lines.push(error(`outputDir pointe vers un fichier, pas un dossier: ${resolved}`));
+            return;
+        }
+        lines.push(ok(`outputDir configure: ${resolved}`));
+    }
+    catch {
+        lines.push(warn(`outputDir n'existe pas encore: ${resolved}. Palabre tentera de le creer au moment de l'export.`));
+    }
+}
+function inspectDetectedMissingAgents(config, discovery, lines) {
+    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`."));
+}
+function inspectAgents(config, discovery, lines) {
+    lines.push(info("Agents configures:"));
+    for (const [name, agent] of Object.entries(config.agents)) {
+        inspectAgentShape(name, agent, lines);
+        if (agent.type === "cli") {
+            inspectCliAgent(name, agent, discovery, lines);
+            continue;
+        }
+        inspectOllamaAgent(name, agent, discovery, lines);
+    }
+}
+function inspectAgentShape(name, agent, lines) {
+    if (!agent.role) {
+        lines.push(error(`${name}: role absent.`));
+    }
+    if (agent.type === "cli") {
+        if (!agent.command || !agent.command.trim()) {
+            lines.push(error(`${name}: command CLI absent.`));
+        }
+        if (agent.promptMode && !["stdin", "argument"].includes(agent.promptMode)) {
+            lines.push(error(`${name}: promptMode invalide (${agent.promptMode}). Valeurs attendues: stdin ou argument.`));
+        }
+        if (agent.timeoutMs !== undefined && (!Number.isFinite(agent.timeoutMs) || agent.timeoutMs <= 0)) {
+            lines.push(error(`${name}: timeoutMs doit etre un nombre positif.`));
+        }
+        if (agent.idleTimeoutMs !== undefined && (!Number.isFinite(agent.idleTimeoutMs) || agent.idleTimeoutMs <= 0)) {
+            lines.push(error(`${name}: idleTimeoutMs doit etre un nombre positif.`));
+        }
+        return;
+    }
+    if (!agent.model || !agent.model.trim()) {
+        lines.push(error(`${name}: modele Ollama absent.`));
+    }
+    if (agent.baseUrl && !/^https?:\/\//.test(agent.baseUrl)) {
+        lines.push(error(`${name}: baseUrl Ollama invalide (${agent.baseUrl}). Attendu: http://... ou https://...`));
+    }
+    if (agent.timeoutMs !== undefined && (!Number.isFinite(agent.timeoutMs) || agent.timeoutMs <= 0)) {
+        lines.push(error(`${name}: timeoutMs doit etre un nombre positif.`));
+    }
+}
+function inspectCliAgent(name, agent, discovery, lines) {
+    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)`));
+        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.`));
+}
+function inspectOllamaAgent(name, agent, discovery, lines) {
+    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.`));
+        return;
+    }
+    if (agent.validateModel === false) {
+        lines.push(info(`${prefix} non valide car validateModel=false.`));
+        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`."));
+}
+function detectedAgentNames(discovery) {
+    return [
+        discovery.codex.available ? "codex" : undefined,
+        discovery.claude.available ? "claude" : undefined,
+        discovery.gemini.available ? "gemini" : undefined,
+        discovery.opencode.available ? "opencode" : undefined,
+        discovery.ollama.available ? "ollama-local" : undefined
+    ].filter((name) => Boolean(name));
+}
+function formatCommand(label, available, command, resolvedPath) {
+    return available
+        ? ok(`${label}: detecte (${resolvedPath ?? command})`)
+        : warn(`${label}: non detecte dans PATH.`);
+}
+function knownCliDetection(command, discovery) {
+    const normalized = path.basename(command).toLowerCase().replace(/\.(exe|cmd|bat)$/i, "");
+    if (normalized === "codex")
+        return discovery.codex;
+    if (normalized === "claude")
+        return discovery.claude;
+    if (normalized === "gemini")
+        return discovery.gemini;
+    if (normalized === "opencode")
+        return discovery.opencode;
+    return undefined;
+}
+function render(lines, plain) {
+    const hasErrors = lines.some((line) => line.level === "error");
+    return {
+        ok: !hasErrors,
+        output: plain ? renderPlain(lines) : renderPretty(lines)
+    };
+}
+function renderPlain(lines) {
+    return lines.map(formatLine).join("\n");
+}
+function renderPretty(lines) {
+    const configLines = [];
+    const toolLines = [];
+    const agentLines = [];
+    const actionLines = [];
+    let current = "config";
+    let cwd = process.cwd();
+    for (const line of lines) {
+        if (line.text === "PALABRE doctor")
+            continue;
+        if (line.text.startsWith("Dossier courant: ")) {
+            cwd = line.text.replace("Dossier courant: ", "");
+            continue;
+        }
+        if (line.text === "Outils locaux:") {
+            current = "tools";
+            continue;
+        }
+        if (line.text === "Agents configures:") {
+            current = "agents";
+            continue;
+        }
+        if (line.level === "error" || line.level === "warn") {
+            actionLines.push(line);
+        }
+        if (current === "tools") {
+            toolLines.push(line);
+        }
+        else if (current === "agents") {
+            agentLines.push(line);
+        }
+        else {
+            configLines.push(line);
+        }
+    }
+    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";
+    return [
+        ...renderDoctorHeader(status),
+        "",
+        ...renderSection("Configuration", [info(`Dossier courant: ${cwd}`), ...configLines]),
+        "",
+        ...renderSection("Outils locaux", toolLines),
+        "",
+        ...renderSection("Agents", agentLines),
+        ...(actionLines.length > 0 ? ["", ...renderSection("A verifier", actionLines)] : []),
+        ""
+    ].join("\n");
+}
+function renderDoctorHeader(status) {
+    const title = "PALABRE doctor";
+    return [
+        `┌─ ${title} ${"─".repeat(Math.max(1, 58 - title.length))}`,
+        `│ Statut: ${status}`,
+        `└${"─".repeat(73)}`
+    ];
+}
+function renderSection(title, lines) {
+    if (lines.length === 0) {
+        return [title, "  INFO  Rien a afficher."];
+    }
+    return [
+        title,
+        "─".repeat(Math.max(16, title.length + 8)),
+        ...lines.map((line) => `  ${formatPrettyLine(line)}`)
+    ];
+}
+function formatPrettyLine(line) {
+    const labels = {
+        ok: "OK    ",
+        warn: "WARN  ",
+        error: "ERREUR",
+        info: "INFO  "
+    };
+    return `${labels[line.level]} ${line.text}`;
+}
+function formatLine(line) {
+    const labels = {
+        ok: "OK",
+        warn: "WARN",
+        error: "ERREUR",
+        info: "INFO"
+    };
+    return `[${labels[line.level]}] ${line.text}`;
+}
+function ok(text) {
+    return { level: "ok", text };
+}
+function warn(text) {
+    return { level: "warn", text };
+}
+function error(text) {
+    return { level: "error", text };
+}
+function info(text) {
+    return { level: "info", text };
+}
+function formatErrorSuffix(errorMessage) {
+    return errorMessage ? ` (${errorMessage})` : "";
+}