palabre 0.1.4

package/dist/adapters/ollama.js

@@ -0,0 +1,218 @@
+import { AdapterError } from "../errors.js";
+import { formatAgentPrompt } from "../prompt.js";
+/**
+ * Adapter pour Ollama via l'API HTTP locale (`POST /api/chat`).
+ * N'accède jamais au filesystem : ne voit que le prompt et le transcript fournis par l'orchestrateur.
+ * Garantit : rejection des sorties vides et des timeouts.
+ */
+export class OllamaAdapter {
+    name;
+    config;
+    role;
+    contract;
+    constructor(name, config) {
+        this.name = name;
+        this.config = config;
+        this.role = config.role;
+        this.contract = {
+            name,
+            kind: "ollama",
+            capabilities: {
+                mode: "http",
+                supportsModelOverride: true,
+                supportsFilesystemAccess: false,
+                supportsStreaming: false,
+                supportsProcessExitCode: false,
+                supportsStderr: false
+            },
+            guarantees: {
+                rejectsEmptyOutput: true,
+                rejectsNonZeroExit: false,
+                rejectsTimeout: true,
+                returnsRawOutput: false
+            }
+        };
+    }
+    async generate(prompt) {
+        const baseUrl = normalizeBaseUrl(this.config.baseUrl ?? "http://localhost:11434");
+        if (this.config.validateModel !== false) {
+            await this.ensureModelAvailable(baseUrl);
+        }
+        if (this.config.unloadOtherModels !== false) {
+            await this.unloadOtherRunningModels(baseUrl);
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 120_000);
+        try {
+            const response = await fetch(`${baseUrl}/api/chat`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json"
+                },
+                body: JSON.stringify({
+                    model: this.config.model,
+                    stream: false,
+                    ...(this.config.keepAlive !== undefined ? { keep_alive: this.config.keepAlive } : {}),
+                    messages: [
+                        {
+                            role: "system",
+                            content: this.config.systemPrompt ??
+                                "Tu participes a un debat technique orchestre. Reste precis, utile et honnete sur tes limites."
+                        },
+                        {
+                            role: "user",
+                            content: formatAgentPrompt(prompt)
+                        }
+                    ],
+                    options: {
+                        temperature: this.config.temperature ?? 0.2
+                    }
+                }),
+                signal: controller.signal
+            });
+            const data = (await response.json());
+            if (!response.ok || data.error) {
+                throw new AdapterError("http-error", this.name, data.error ?? `Ollama HTTP ${response.status}`, {
+                    status: response.status
+                });
+            }
+            const content = data.message?.content?.trim() ?? "";
+            if (!content) {
+                throw new AdapterError("empty-output", this.name, `${this.name} produced empty output.`);
+            }
+            return {
+                content
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    /**
+     * Vérifie que le modèle est disponible avant de générer.
+     * 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);
+        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 });
+        }
+        process.stdout.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.`);
+        }
+    }
+    async isModelAvailable(baseUrl) {
+        const models = await this.listAvailableModels(baseUrl);
+        return models.includes(this.config.model);
+    }
+    async listAvailableModels(baseUrl) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 120_000);
+        try {
+            return await this.fetchAvailableModels(baseUrl, controller.signal);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async fetchAvailableModels(baseUrl, signal) {
+        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`, {
+                status: response.status
+            });
+        }
+        const data = (await response.json());
+        return data.models
+            ?.map((model) => model.name ?? model.model)
+            .filter((modelName) => Boolean(modelName)) ?? [];
+    }
+    async pullModel(baseUrl) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.pullTimeoutMs ?? 1_800_000);
+        try {
+            const response = await fetch(`${baseUrl}/api/pull`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json"
+                },
+                body: JSON.stringify({
+                    model: this.config.model,
+                    stream: false
+                }),
+                signal: controller.signal
+            });
+            const data = (await response.json());
+            if (!response.ok || data.error) {
+                throw new AdapterError("model-pull-failed", this.name, data.error ?? `Ollama HTTP ${response.status}`, {
+                    status: response.status
+                });
+            }
+        }
+        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}`);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async unloadOtherRunningModels(baseUrl) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 120_000);
+        try {
+            await this.unloadOtherRunningModelsWithSignal(baseUrl, controller.signal);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async unloadOtherRunningModelsWithSignal(baseUrl, signal) {
+        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`, {
+                status: response.status
+            });
+        }
+        const data = (await response.json());
+        const runningModels = data.models
+            ?.map((model) => model.name ?? model.model)
+            .filter((modelName) => Boolean(modelName))
+            .filter((modelName) => modelName !== this.config.model) ?? [];
+        for (const model of runningModels) {
+            await unloadModel(baseUrl, model, signal);
+        }
+    }
+}
+/** 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) {
+    const response = await fetch(`${baseUrl}/api/generate`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json"
+        },
+        body: JSON.stringify({
+            model,
+            keep_alive: 0
+        }),
+        signal
+    });
+    if (!response.ok) {
+        throw new AdapterError("http-error", "ollama", `Impossible de decharger le modele Ollama ${model}: HTTP ${response.status}`, {
+            status: response.status,
+            model
+        });
+    }
+}
+/** Supprime le slash final de `baseUrl` pour éviter les doubles slashs dans les URLs construites. */
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/$/, "");
+}

package/dist/config.js

@@ -0,0 +1,199 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export const DEFAULT_CONFIG_PATH = "palabre.config.json";
+export const LEGACY_CONFIG_PATH = "chicane.config.json";
+export const CONFIG_DIR_NAME = ".palabre";
+export const GLOBAL_CONFIG_PATH = path.join(os.homedir(), CONFIG_DIR_NAME, DEFAULT_CONFIG_PATH);
+export const GLOBAL_LEGACY_CONFIG_PATH = path.join(os.homedir(), CONFIG_DIR_NAME, LEGACY_CONFIG_PATH);
+export const exampleConfig = {
+    outputDir: ".",
+    defaults: {
+        agentA: "codex",
+        agentB: "claude",
+        summaryAgent: "claude",
+        turns: 4
+    },
+    agents: {
+        codex: {
+            type: "cli",
+            command: "codex",
+            args: [
+                "exec",
+                "--skip-git-repo-check",
+                "--color",
+                "never",
+                "--sandbox",
+                "read-only",
+                "-"
+            ],
+            promptMode: "stdin",
+            shell: process.platform === "win32",
+            role: "implementer",
+            tier: "primary"
+        },
+        claude: {
+            type: "cli",
+            command: process.platform === "win32" ? "claude.exe" : "claude",
+            args: [
+                "--print",
+                "--output-format",
+                "text",
+                "--no-session-persistence"
+            ],
+            promptMode: "stdin",
+            shell: false,
+            role: "reviewer",
+            tier: "primary"
+        },
+        gemini: {
+            type: "cli",
+            command: "gemini",
+            args: [
+                "--output-format",
+                "text",
+                "--approval-mode",
+                "plan",
+                "--skip-trust",
+                "--prompt",
+                "-"
+            ],
+            promptMode: "stdin",
+            shell: process.platform === "win32",
+            role: "reviewer",
+            tier: "primary"
+        },
+        opencode: {
+            type: "cli",
+            command: "opencode",
+            args: [
+                "run"
+            ],
+            promptMode: "stdin",
+            modelArg: "--model",
+            shell: process.platform === "win32",
+            role: "reviewer",
+            tier: "primary"
+        },
+        "ollama-local": {
+            type: "ollama",
+            baseUrl: "http://localhost:11434",
+            model: "nemotron-3-nano:4b",
+            role: "critic",
+            tier: "local",
+            temperature: 0.2,
+            validateModel: true,
+            unloadOtherModels: true
+        }
+    }
+};
+/** Charge et parse la config depuis `configPath`. Lance une erreur si le fichier est absent ou invalide. */
+export async function loadConfig(configPath = DEFAULT_CONFIG_PATH) {
+    const resolved = path.resolve(configPath);
+    const raw = await readFile(resolved, "utf8");
+    return JSON.parse(raw);
+}
+/** Retourne `true` si le fichier de config est accessible en lecture. Silencieux sur toute erreur filesystem. */
+export async function configExists(configPath = DEFAULT_CONFIG_PATH) {
+    try {
+        await access(path.resolve(configPath));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Résout le chemin de config à utiliser selon l'ordre de priorité :
+ * local (`palabre.config.json`) → legacy local → global → legacy global.
+ * Retourne le chemin global même s'il n'existe pas encore (cas d'un premier `init`).
+ */
+export async function resolveDefaultConfigPath() {
+    if (await configExists(DEFAULT_CONFIG_PATH)) {
+        return DEFAULT_CONFIG_PATH;
+    }
+    if (await configExists(LEGACY_CONFIG_PATH)) {
+        return LEGACY_CONFIG_PATH;
+    }
+    if (await configExists(GLOBAL_CONFIG_PATH)) {
+        return GLOBAL_CONFIG_PATH;
+    }
+    if (await configExists(GLOBAL_LEGACY_CONFIG_PATH)) {
+        return GLOBAL_LEGACY_CONFIG_PATH;
+    }
+    return GLOBAL_CONFIG_PATH;
+}
+/**
+ * Construit une `PalabreConfig` complète à partir des outils détectés localement.
+ * Ajuste `defaults.agentA/agentB/summaryAgent` en fonction de la paire disponible.
+ * Si aucune paire n'est détectée, `defaults` reste celui de `exampleConfig`.
+ */
+export function createConfigFromDiscovery(discovery) {
+    const config = cloneConfig(exampleConfig);
+    const pair = chooseDefaultPair(discovery);
+    config.agents.codex = {
+        ...config.agents.codex,
+        ...(discovery.codex.available ? { command: discovery.codex.command } : {})
+    };
+    config.agents.claude = {
+        ...config.agents.claude,
+        ...(discovery.claude.available ? { command: discovery.claude.command } : {})
+    };
+    config.agents.gemini = {
+        ...config.agents.gemini,
+        ...(discovery.gemini.available ? { command: discovery.gemini.command } : {})
+    };
+    config.agents.opencode = {
+        ...config.agents.opencode,
+        ...(discovery.opencode.available ? { command: discovery.opencode.command } : {})
+    };
+    config.defaults = {
+        ...config.defaults,
+        ...(pair ? { agentA: pair[0], agentB: pair[1], summaryAgent: chooseDefaultSummaryAgent(pair) } : {})
+    };
+    return config;
+}
+/** É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) {
+    const resolved = path.resolve(configPath);
+    await mkdir(path.dirname(resolved), { recursive: true });
+    await writeFile(resolved, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+function chooseDefaultSummaryAgent(pair) {
+    for (const preferred of ["claude", "codex", "gemini"]) {
+        if (pair.includes(preferred)) {
+            return preferred;
+        }
+    }
+    return pair[1];
+}
+function chooseDefaultPair(discovery) {
+    if (discovery.codex.available && discovery.claude.available) {
+        return ["codex", "claude"];
+    }
+    if (discovery.codex.available && discovery.ollama.available) {
+        return ["codex", "ollama-local"];
+    }
+    if (discovery.claude.available && discovery.ollama.available) {
+        return ["claude", "ollama-local"];
+    }
+    if (discovery.opencode.available && discovery.ollama.available) {
+        return ["opencode", "ollama-local"];
+    }
+    if (discovery.gemini.available && discovery.ollama.available) {
+        return ["gemini", "ollama-local"];
+    }
+    const cliAgents = [
+        discovery.codex.available ? "codex" : undefined,
+        discovery.claude.available ? "claude" : undefined,
+        discovery.opencode.available ? "opencode" : undefined,
+        discovery.gemini.available ? "gemini" : undefined
+    ].filter((agent) => Boolean(agent));
+    if (cliAgents.length >= 2) {
+        return [cliAgents[0], cliAgents[1]];
+    }
+    return undefined;
+}
+function cloneConfig(config) {
+    return JSON.parse(JSON.stringify(config));
+}

package/dist/configWizard.js

@@ -0,0 +1,196 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { writeExampleConfig } from "./config.js";
+import { DEFAULT_TURNS, MAX_TURNS, turnsOrDefault, validateTurns } from "./limits.js";
+/**
+ * Lance le wizard interactif de configuration des defaults.
+ * Fonctionne en mode TTY (readline) et en mode piped (stdin lu en avance).
+ * Écrit la config sur disque si l'utilisateur confirme ; sort sans modifier si l'utilisateur quitte.
+ */
+export async function runConfigWizard(configPath, config) {
+    const choices = Object.entries(config.agents).map(([name, agentConfig]) => ({ name, config: agentConfig }));
+    if (choices.length < 2) {
+        throw new Error("La config doit contenir au moins deux agents pour définir des paramètres par défaut.");
+    }
+    const rl = await createQuestioner();
+    try {
+        console.log("PALABRE - Configuration");
+        console.log("À tout moment: Ctrl+C pour interrompre, ou tape q, quit ou exit dans un prompt pour quitter.");
+        console.log("");
+        console.log("Fichier de configuration :");
+        console.log(`  ${configPath}`);
+        console.log("");
+        console.log("Paramètres par défaut actuels :");
+        console.log(`  ${config.defaults ? formatDefaults(config.defaults) : "Aucun"}`);
+        console.log("");
+        console.log("Que veux-tu faire ?");
+        console.log("  1) Définir des paramètres par défaut");
+        console.log("  2) Supprimer les paramètres par défaut");
+        console.log("  3) Quitter sans modifier");
+        const action = await askChoice(rl, "Tape le numéro de ton choix", "1", ["1", "2", "3"]);
+        if (!action || action === "3") {
+            console.log("Config inchangée.");
+            return;
+        }
+        if (action === "2") {
+            delete config.defaults;
+            await writeExampleConfig(configPath, config);
+            console.log(`Paramètres par défaut supprimés dans ${configPath}.`);
+            return;
+        }
+        const agentA = await askAgent(rl, choices, "Agent A", "Choisis l'agent A, celui qui répondra en premier.", config.defaults?.agentA);
+        if (!agentA)
+            return;
+        const agentB = await askAgent(rl, choices.filter((choice) => choice.name !== agentA), "Agent B", "Choisis l'agent B, celui qui répondra en second.", config.defaults?.agentB === agentA ? undefined : config.defaults?.agentB);
+        if (!agentB)
+            return;
+        const turns = await askNumber(rl, "Nombre de réponses par défaut", turnsOrDefault(config.defaults?.turns), Boolean(config.defaults?.turns));
+        if (turns === undefined)
+            return;
+        const summaryAgent = await askSummaryAgent(rl, choices, config.defaults?.summaryAgent ?? agentB, Boolean(config.defaults?.summaryAgent), agentB);
+        if (summaryAgent === undefined)
+            return;
+        config.defaults = {
+            agentA,
+            agentB,
+            ...(summaryAgent ? { summaryAgent } : {}),
+            turns
+        };
+        await writeExampleConfig(configPath, config);
+        console.log(`Paramètres par défaut définis dans ${configPath}: ${formatDefaults(config.defaults)}.`);
+    }
+    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 ?? "3"}\n`);
+            return value ?? "3";
+        },
+        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 ? raw.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n") : [];
+}
+async function askAgent(rl, choices, _label, description, defaultName) {
+    const fallback = choices.find((choice) => choice.name === defaultName)?.name ?? choices[0]?.name;
+    const fallbackLabel = defaultName ? "Actuel" : "Suggestion";
+    console.log("");
+    console.log(description);
+    console.log(`${fallbackLabel} : ${fallback}`);
+    console.log("");
+    choices.forEach((choice, index) => {
+        console.log(`  ${index + 1}) ${formatAgentLine(choice)}`);
+    });
+    while (true) {
+        const answer = await rl.question(`Tape un numéro ou un nom d'agent (Entrée = ${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 askSummaryAgent(rl, choices, defaultName, hasCurrentDefault, agentB) {
+    const fallback = choices.some((choice) => choice.name === defaultName) ? defaultName : choices[0]?.name;
+    const fallbackLabel = hasCurrentDefault ? "Actuel" : "Suggestion";
+    console.log("");
+    console.log("Agent de synthèse par défaut");
+    console.log(`${fallbackLabel} : ${fallback}${!hasCurrentDefault && fallback === agentB ? " (agent B)" : ""}`);
+    console.log("");
+    console.log("  0) Aucun agent de synthèse par défaut");
+    choices.forEach((choice, index) => {
+        console.log(`  ${index + 1}) ${formatAgentLine(choice)}`);
+    });
+    while (true) {
+        const answer = await rl.question(`Tape un numéro, un nom d'agent, ou 0 pour aucun (Entrée = ${fallback}) : `);
+        const value = answer.trim();
+        if (isQuit(value))
+            return undefined;
+        if (!value)
+            return fallback;
+        if (value === "0" || value.toLowerCase() === "none" || value.toLowerCase() === "aucun")
+            return "";
+        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, 0, Entrée ou q.");
+    }
+}
+async function askChoice(rl, label, defaultValue, allowed) {
+    while (true) {
+        const answer = await rl.question(`${label} (Entrée = ${defaultValue}) : `);
+        const value = answer.trim();
+        if (isQuit(value))
+            return undefined;
+        if (!value)
+            return defaultValue;
+        if (allowed.includes(value))
+            return value;
+        console.log(`Choix invalide. Valeurs: ${allowed.join(", ")}, Entrée ou q.`);
+    }
+}
+async function askNumber(rl, label, defaultValue, hasCurrentDefault) {
+    const fallbackLabel = hasCurrentDefault ? "Actuel" : "Suggestion";
+    console.log("");
+    console.log(label);
+    console.log(`${fallbackLabel} : ${defaultValue}`);
+    console.log("");
+    while (true) {
+        const answer = await rl.question(`Tape le nombre total de réponses du débat (Entrée = ${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.`);
+    }
+}
+function formatAgentLine(choice) {
+    return `${choice.name.padEnd(12)} ${choice.config.type} / ${choice.config.role}`;
+}
+function formatDefaults(defaults) {
+    return `${defaults.agentA ?? "?"} <-> ${defaults.agentB ?? "?"}, réponses: ${turnsOrDefault(defaults.turns ?? DEFAULT_TURNS)}${defaults.summaryAgent ? `, synthèse: ${defaults.summaryAgent}` : ""}`;
+}
+function isQuit(value) {
+    return ["q", "quit", "exit"].includes(value.toLowerCase());
+}