palabre 0.1.4

package/dist/presets.js

@@ -0,0 +1,98 @@
+const presets = {
+    "codex-claude": {
+        agentA: "codex",
+        agentB: "claude"
+    },
+    "claude-codex": {
+        agentA: "claude",
+        agentB: "codex"
+    },
+    "codex-opencode": {
+        agentA: "codex",
+        agentB: "opencode"
+    },
+    "opencode-codex": {
+        agentA: "opencode",
+        agentB: "codex"
+    },
+    "claude-opencode": {
+        agentA: "claude",
+        agentB: "opencode"
+    },
+    "opencode-claude": {
+        agentA: "opencode",
+        agentB: "claude"
+    },
+    "gemini-opencode": {
+        agentA: "gemini",
+        agentB: "opencode"
+    },
+    "opencode-gemini": {
+        agentA: "opencode",
+        agentB: "gemini"
+    },
+    "opencode-ollama": {
+        agentA: "opencode",
+        agentB: "ollama-local"
+    },
+    "ollama-opencode": {
+        agentA: "ollama-local",
+        agentB: "opencode"
+    },
+    "codex-ollama": {
+        agentA: "codex",
+        agentB: "ollama-local"
+    },
+    "ollama-codex": {
+        agentA: "ollama-local",
+        agentB: "codex"
+    },
+    "claude-ollama": {
+        agentA: "claude",
+        agentB: "ollama-local"
+    },
+    "ollama-claude": {
+        agentA: "ollama-local",
+        agentB: "claude"
+    },
+    "gemini-ollama": {
+        agentA: "gemini",
+        agentB: "ollama-local"
+    },
+    "ollama-gemini": {
+        agentA: "ollama-local",
+        agentB: "gemini"
+    },
+    "codex-gemini": {
+        agentA: "codex",
+        agentB: "gemini"
+    },
+    "gemini-codex": {
+        agentA: "gemini",
+        agentB: "codex"
+    },
+    "claude-gemini": {
+        agentA: "claude",
+        agentB: "gemini"
+    },
+    "gemini-claude": {
+        agentA: "gemini",
+        agentB: "claude"
+    }
+};
+/** Retourne la paire d'agents pour `name`. Lève une erreur avec la liste des presets disponibles si inconnu. */
+export function resolvePreset(name) {
+    const preset = presets[name];
+    if (!preset) {
+        throw new Error(`Preset inconnu: ${name}. Presets disponibles: ${Object.keys(presets).join(", ")}`);
+    }
+    return preset;
+}
+/** Retourne la liste de tous les noms de presets disponibles, dans l'ordre de déclaration. */
+export function listPresetNames() {
+    return Object.keys(presets);
+}
+/** Recherche inverse : retourne le nom du preset correspondant à une paire `(agentA, agentB)`, ou `undefined`. */
+export function findPresetNameForPair(agentA, agentB) {
+    return Object.entries(presets).find(([, preset]) => preset.agentA === agentA && preset.agentB === agentB)?.[0];
+}

package/dist/prompt.js

@@ -0,0 +1,122 @@
+/**
+ * Formate le prompt complet transmis à l'adapter.
+ * Dispatche vers le format de synthèse si `input.mode === "summary"`, sinon construit le prompt de débat standard.
+ */
+export function formatAgentPrompt(input) {
+    if (input.mode === "summary") {
+        return formatSummaryPrompt(input);
+    }
+    const transcript = formatTranscript(input.transcript);
+    return [
+        `Sujet: ${input.topic}`,
+        "",
+        `Tu es ${input.selfName}. Tu reponds au tour ${input.turn}.`,
+        `Ton interlocuteur est ${input.peerName}.`,
+        `Role de ${input.selfName}: ${input.selfRole}.`,
+        roleInstruction(input.selfRole),
+        "",
+        "Contexte de session PALABRE:",
+        "- Source: fourni par PALABRE et visible par tous les agents de ce debat.",
+        `- Date locale: ${input.session.localDate}`,
+        `- Fuseau horaire: ${input.session.timeZone}`,
+        `- Dossier courant: ${input.session.cwd}`,
+        `- Session demarree a: ${input.session.startedAt}`,
+        "",
+        "Objectif:",
+        "- Apporte une reponse utile, concrete et courte.",
+        "- Reagis aux arguments precedents au lieu de repartir de zero.",
+        "- Signale les incertitudes ou les points a trancher.",
+        "- Respecte ton role sans ignorer les faits du transcript.",
+        "",
+        input.files.length > 0 ? "Contexte fichiers:" : "",
+        formatFileContext(input.files),
+        input.files.length > 0 ? "" : "",
+        transcript.length > 0 ? "Historique:" : "Historique: aucun message pour le moment.",
+        transcript,
+        "",
+        "Ta reponse:"
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+/** Formate le prompt de synthèse finale. Impose un format structuré : Consensus / Désaccords / Actions / Conclusion. */
+function formatSummaryPrompt(input) {
+    const transcript = formatTranscript(input.transcript);
+    return [
+        `Sujet: ${input.topic}`,
+        "",
+        `Tu es ${input.selfName}. Tu produis la synthese finale du debat.`,
+        `Role de ${input.selfName}: ${input.selfRole}.`,
+        roleInstruction("summarizer"),
+        "",
+        "Contexte de session PALABRE:",
+        "- Source: fourni par PALABRE et visible par tous les agents de ce debat.",
+        `- Date locale: ${input.session.localDate}`,
+        `- Fuseau horaire: ${input.session.timeZone}`,
+        `- Dossier courant: ${input.session.cwd}`,
+        `- Session demarree a: ${input.session.startedAt}`,
+        "",
+        "Objectif:",
+        "- Resume le consensus en points concrets.",
+        "- Liste les desaccords ou incertitudes qui restent.",
+        "- Propose les prochaines actions techniques.",
+        "- Termine par une conclusion courte en prose, bien ecrite, qui explique rapidement ce qu'il faut retenir.",
+        "- Reste concis et exploitable.",
+        "",
+        input.files.length > 0 ? "Contexte fichiers:" : "",
+        formatFileContext(input.files),
+        input.files.length > 0 ? "" : "",
+        "Transcript du debat:",
+        transcript || "Aucun message.",
+        "",
+        "Format attendu:",
+        "### Consensus",
+        "",
+        "### Desaccords / incertitudes",
+        "",
+        "### Actions proposees",
+        "",
+        "### Conclusion",
+        "",
+        "Un court paragraphe de synthese en prose, sans liste, qui resume le sens general du debat et la decision ou direction la plus raisonnable.",
+        "",
+        "Synthese:"
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function roleInstruction(role) {
+    const instructions = {
+        implementer: "Consigne de role: propose une solution concrete, executable et sobrement justifiee.",
+        reviewer: "Consigne de role: cherche les risques, regressions, angles morts et tests manquants.",
+        architect: "Consigne de role: structure les options techniques, compromis et frontieres du systeme.",
+        scout: "Consigne de role: explore rapidement le terrain, releve les pistes utiles et les inconnues.",
+        critic: "Consigne de role: challenge les hypotheses, pointe les faiblesses et demande les preuves utiles.",
+        summarizer: "Consigne de role: synthetise fidelement le transcript sans ajouter de nouvelles hypotheses non signalees."
+    };
+    return instructions[role];
+}
+/** Formate les fichiers projet en blocs de code annotés pour l'injection dans le prompt. */
+function formatFileContext(files) {
+    return files
+        .map((file) => {
+        return [
+            `--- ${file.path} (${file.sizeBytes} bytes)`,
+            "```",
+            file.content.trimEnd(),
+            "```"
+        ].join("\n");
+    })
+        .join("\n\n");
+}
+/** Formate le transcript en sections lisibles. Retourne une chaîne vide si aucun message. */
+export function formatTranscript(messages) {
+    return messages
+        .map((message) => {
+        return [
+            `--- ${message.agent} (${message.role})`,
+            message.content.trim()
+        ].join("\n");
+    })
+        .join("\n\n");
+}

package/dist/renderers/console.js

@@ -0,0 +1,171 @@
+const supportsColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+const supportsInteractiveOutput = Boolean(process.stdout.isTTY);
+/** Instancie le renderer adapté : pretty (spinner, couleurs ANSI, sections) ou plain (logs bruts). */
+export function createConsoleRenderer(plain) {
+    return plain ? new PlainConsoleRenderer() : new PrettyConsoleRenderer(supportsColor, supportsInteractiveOutput);
+}
+class PrettyConsoleRenderer {
+    color;
+    interactive;
+    spinner;
+    spinnerFrame = 0;
+    renderingSummary = false;
+    frames = ["-", "\\", "|", "/"];
+    constructor(color, interactive) {
+        this.color = color;
+        this.interactive = interactive;
+    }
+    start(options, agents = []) {
+        const title = "PALABRE";
+        process.stdout.write([
+            "",
+            this.c("cyan", `┌─ ${title} ${"─".repeat(Math.max(1, 54 - title.length))}`),
+            this.c("cyan", `│`) + ` Sujet: ${options.topic}`,
+            this.c("cyan", `│`) + ` Agents: ${formatAgentPair(options, agents)}`,
+            this.c("cyan", `│`) + ` Réponses: ${options.turns} | Synthèse: ${formatSummary(options)}`,
+            this.c("cyan", `│`) + ` Contexte: ${formatContext(options)}`,
+            this.c("cyan", `│`) + ` Options: arrêt anticipé ${options.earlyStopOnAgreement ? "activé" : "désactivé"}, auto-pull Ollama ${options.pullModels ? "activé" : "désactivé"}`,
+            this.c("cyan", `└${"─".repeat(57)}`),
+            ""
+        ].join("\n"));
+    }
+    warning(message) {
+        process.stderr.write(`${this.c("yellow", "Warning:")} ${message}\n`);
+    }
+    notice(message) {
+        process.stdout.write(`${this.c("green", "Info:")} ${message}\n`);
+    }
+    turnStart(turn, totalTurns, agent, role) {
+        this.renderingSummary = false;
+        process.stdout.write([
+            "",
+            this.c("blue", `◆ ${agent}`) + this.dim(` · ${role} · tour ${turn}/${totalTurns}`),
+            this.dim("─".repeat(60)),
+            ""
+        ].join("\n"));
+    }
+    thinkingStart(agent, role) {
+        this.thinkingEnd();
+        const text = `${agent} (${role}) reflechit`;
+        if (!this.interactive) {
+            process.stdout.write(`${this.dim(`${text}...`)}\n`);
+            return;
+        }
+        const render = () => {
+            const frame = this.frames[this.spinnerFrame % this.frames.length];
+            this.spinnerFrame += 1;
+            process.stdout.write(`\r${this.c("cyan", frame)} ${this.dim(`${text}...`)}`);
+        };
+        render();
+        this.spinner = setInterval(render, 120);
+    }
+    thinkingEnd() {
+        if (this.spinner) {
+            clearInterval(this.spinner);
+            this.spinner = undefined;
+        }
+        if (this.interactive) {
+            process.stdout.write("\r\u001b[2K");
+        }
+    }
+    message(content) {
+        const trimmed = content.trim();
+        process.stdout.write(`${this.renderingSummary ? this.formatSummaryMessage(trimmed) : trimmed}\n`);
+    }
+    summaryStart(agent, role) {
+        this.renderingSummary = true;
+        process.stdout.write([
+            "",
+            this.c("magenta", `◆ Synthese`) + this.dim(` · ${agent} · ${role}`),
+            this.dim("─".repeat(60)),
+            ""
+        ].join("\n"));
+    }
+    done(outputPath) {
+        process.stdout.write(`\n${this.c("green", "Debat exporte:")} ${outputPath}\n`);
+    }
+    formatSummaryMessage(content) {
+        return content
+            .split(/\r?\n/)
+            .map((line) => {
+            const heading = line.match(/^###\s+(.+)$/);
+            if (!heading)
+                return line;
+            return [
+                "",
+                this.c("magenta", heading[1] ?? line),
+                this.dim("─".repeat(40))
+            ].join("\n");
+        })
+            .join("\n")
+            .trimStart();
+    }
+    c(color, value) {
+        if (!this.color)
+            return value;
+        return `${codes[color]}${value}${codes.reset}`;
+    }
+    dim(value) {
+        if (!this.color)
+            return value;
+        return `${codes.dim}${value}${codes.reset}`;
+    }
+}
+class PlainConsoleRenderer {
+    start(options, agents = []) {
+        process.stdout.write(`Sujet: ${options.topic}` + "\n");
+        process.stdout.write(`Agents: ${formatAgentPair(options, agents)}` + "\n");
+        process.stdout.write(`Réponses: ${options.turns} | Synthèse: ${formatSummary(options)} | Contexte: ${formatContext(options)}` + "\n");
+    }
+    warning(message) {
+        process.stderr.write(`Warning: ${message}\n`);
+    }
+    notice(message) {
+        process.stdout.write(`Info: ${message}\n`);
+    }
+    turnStart(turn, totalTurns, agent, role) {
+        process.stdout.write(`\n[${turn}/${totalTurns}] ${agent} (${role})...\n`);
+    }
+    thinkingStart(_agent, _role) { }
+    thinkingEnd() { }
+    message(content) {
+        process.stdout.write(`${content.trim()}\n`);
+    }
+    summaryStart(agent, role) {
+        process.stdout.write(`\n[Synthese] ${agent} (${role})...\n`);
+    }
+    done(outputPath) {
+        process.stdout.write(`\nDebat exporte: ${outputPath}\n`);
+    }
+}
+function formatAgentPair(options, agents) {
+    if (agents.length >= 2) {
+        return `${formatAgentLabel(agents[0])} <-> ${formatAgentLabel(agents[1])}`;
+    }
+    return `${options.agentA} <-> ${options.agentB}`;
+}
+function formatAgentLabel(agent) {
+    if (!agent) {
+        return "?";
+    }
+    return `${agent.name} (${agent.role}, ${agent.type})`;
+}
+function formatSummary(options) {
+    return options.summaryEnabled ? options.summaryAgent ?? options.agentB : "désactivée";
+}
+function formatContext(options) {
+    const count = options.files.length;
+    if (count === 0) {
+        return "aucun fichier injecté";
+    }
+    return `${count} fichier${count > 1 ? "s" : ""} injecté${count > 1 ? "s" : ""}`;
+}
+const codes = {
+    reset: "\u001b[0m",
+    dim: "\u001b[2m",
+    blue: "\u001b[34m",
+    cyan: "\u001b[36m",
+    green: "\u001b[32m",
+    magenta: "\u001b[35m",
+    yellow: "\u001b[33m"
+};

package/dist/session.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+/**
+ * Construit le contexte de session partagé par tous les agents pour la durée du débat.
+ * `cwd` et `now` sont injectables pour la testabilité.
+ */
+export function createSessionContext(cwd = process.cwd(), now = new Date()) {
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "unknown";
+    return {
+        startedAt: now.toISOString(),
+        localDate: formatDateInTimeZone(now, timeZone),
+        timeZone,
+        cwd: path.resolve(cwd)
+    };
+}
+/** Formate une date dans le fuseau local via `Intl.DateTimeFormat`. Retombe sur la date UTC ISO si le runtime ne supporte pas le fuseau. */
+function formatDateInTimeZone(date, timeZone) {
+    try {
+        const parts = new Intl.DateTimeFormat("en-CA", {
+            timeZone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit"
+        }).formatToParts(date);
+        const year = parts.find((part) => part.type === "year")?.value;
+        const month = parts.find((part) => part.type === "month")?.value;
+        const day = parts.find((part) => part.type === "day")?.value;
+        if (year && month && day) {
+            return `${year}-${month}-${day}`;
+        }
+    }
+    catch {
+        // Fall back to UTC ISO date if the runtime cannot format the local timezone.
+    }
+    return date.toISOString().slice(0, 10);
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/update.js

@@ -0,0 +1,68 @@
+import { spawn } from "node:child_process";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Détecte le mode d'installation (source ou package) à partir de la présence d'un dossier `.git`. */
+export async function getUpdateInfo(version) {
+    const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+    return {
+        version,
+        projectRoot,
+        sourceCheckout: await exists(path.join(projectRoot, ".git"))
+    };
+}
+/** Génère les instructions de mise à jour adaptées au mode d'installation détecté dans `info`. */
+export function formatUpdateInstructions(info) {
+    const lines = [
+        `PALABRE ${info.version}`,
+        "",
+        "Mise a jour recommandee:"
+    ];
+    if (info.sourceCheckout) {
+        lines.push("", "Installation depuis le repo source detectee.", "", `  cd "${info.projectRoot}"`, "  git pull --ff-only", "  pnpm install", "  pnpm build", "  pnpm link --global", "", "Pour executer ces etapes automatiquement:", "", "  palabre update --apply");
+    }
+    else {
+        lines.push("", "Installation package detectee.", "", "  pnpm add --global palabre@latest", "", "Si tu utilises npm:", "", "  npm install --global palabre@latest");
+    }
+    return lines.join("\n");
+}
+/**
+ * Exécute `git pull`, `pnpm install`, `pnpm build`, `pnpm link --global` dans le répertoire du projet.
+ * @throws {Error} si `info.sourceCheckout` est faux — la mise à jour automatique ne s'applique qu'aux checkouts git.
+ */
+export async function applySourceUpdate(info) {
+    if (!info.sourceCheckout) {
+        throw new Error("Mise a jour automatique disponible seulement depuis un checkout git. Utilise pnpm add --global palabre@latest.");
+    }
+    await runStep("git", ["pull", "--ff-only"], info.projectRoot);
+    await runStep("pnpm", ["install"], info.projectRoot);
+    await runStep("pnpm", ["build"], info.projectRoot);
+    await runStep("pnpm", ["link", "--global"], info.projectRoot);
+}
+async function exists(targetPath) {
+    try {
+        await access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function runStep(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            shell: process.platform === "win32",
+            stdio: "inherit",
+            windowsHide: true
+        });
+        child.on("error", reject);
+        child.on("close", (exitCode) => {
+            if (exitCode === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${command} ${args.join(" ")} a echoue avec le code ${exitCode ?? "inconnu"}.`));
+        });
+    });
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "palabre",
+  "version": "0.1.4",
+  "description": "Orchestrateur de debat entre agents IA locaux, CLIs et Ollama.",
+  "type": "module",
+  "homepage": "https://github.com/JuReyms/Palabre#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JuReyms/Palabre.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JuReyms/Palabre/issues"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "agents",
+    "ollama",
+    "codex",
+    "claude",
+    "gemini",
+    "opencode"
+  ],
+  "bin": {
+    "palabre": "./dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "palabre.config.example.json"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.0",
+    "typescript": "^5.4.0"
+  },
+  "scripts": {
+    "build": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "start": "node ./dist/index.js",
+    "test": "pnpm build:test && node --test .tmp/test-dist/tests/*.test.js",
+    "build:test": "node -e \"fs.rmSync('.tmp/test-dist',{recursive:true,force:true})\" && tsc -p tsconfig.test.json"
+  }
+}

package/palabre.config.example.json

@@ -0,0 +1,81 @@
+{
+  "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": true,
+      "role": "implementer",
+      "tier": "primary"
+    },
+    "claude": {
+      "type": "cli",
+      "command": "claude.exe",
+      "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": true,
+      "role": "reviewer",
+      "tier": "primary"
+    },
+    "opencode": {
+      "type": "cli",
+      "command": "opencode",
+      "args": [
+        "run"
+      ],
+      "promptMode": "stdin",
+      "modelArg": "--model",
+      "shell": true,
+      "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
+    }
+  }
+}