palabre 0.9.0 → 0.9.1

package/README.md

@@ -70,6 +70,7 @@ PALABRE does not list models: they change often and depend on each CLI or user a
 
 PALABRE exposes versioned JSON outputs for external clients:
 
+- `palabre agents --json` to read configured agents and CLI-owned availability;
 - `palabre presets --json` to read available agent pairs;
 - `palabre context scan --json` to preview the context `--context` would retain;
 - `--renderer ndjson` or `--json` to follow a debate event by event.
@@ -178,6 +179,7 @@ PALABRE ne liste pas les modèles : ils changent souvent et dépendent de chaque
 
 PALABRE expose des sorties JSON versionnées pour les clients externes :
 
+- `palabre agents --json` pour lire les agents configurés et leur disponibilité calculée par le CLI ;
 - `palabre presets --json` pour lire les paires d'agents disponibles ;
 - `palabre context scan --json` pour prévisualiser le contexte que `--context` retiendrait ;
 - `--renderer ndjson` ou `--json` pour suivre un débat événement par événement.

package/dist/commands/agents.js

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

package/dist/commands/context.js

@@ -0,0 +1,25 @@
+import { buildContextScan } from "../contextScan.js";
+import { createTranslator, resolveLanguage } from "../i18n.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre context scan` en sortie humaine ou JSON versionné. */
+export async function runContextCommand(flags, positionals) {
+    const messages = createTranslator(resolveLanguage({ explicitLanguage: optionalString(flags.language) }));
+    const subcommand = positionals[0] ?? "scan";
+    if (subcommand !== "scan") {
+        throw new Error(messages.common.unknownCommand(`context ${subcommand}`, "context scan"));
+    }
+    const result = await buildContextScan(positionals.slice(1), process.cwd(), messages);
+    if (flags.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    for (const folder of result.items.filter((item) => item.kind === "folder")) {
+        console.log(`[folder] ${folder.path}`);
+    }
+    for (const file of result.items.filter((item) => item.kind === "file")) {
+        console.log(`[file] ${file.path} (${file.sizeBytes} bytes)`);
+    }
+    for (const warning of result.warnings) {
+        console.error(`${messages.renderers.warningPrefix} ${warning}`);
+    }
+}

package/dist/commands/history.js

@@ -0,0 +1,28 @@
+import { configExists, loadConfig, resolveDefaultConfigPath, resolveOutputDir } from "../config.js";
+import { listHistoryEntries } from "../history.js";
+import { createTranslator, resolveLanguage } from "../i18n.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre history` en sortie humaine ou JSON versionné. */
+export async function runHistoryCommand(flags) {
+    const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    const config = await configExists(configPath) ? await loadConfig(configPath) : undefined;
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config?.language
+    }));
+    const entries = await listHistoryEntries(resolveOutputDir(config?.outputDir));
+    if (flags.json) {
+        process.stdout.write(JSON.stringify({ v: 1, history: entries }) + "\n");
+        return;
+    }
+    console.log(messages.tui.historyTitle);
+    console.log("");
+    if (entries.length === 0) {
+        console.log(messages.tui.historyEmpty);
+        return;
+    }
+    for (const entry of entries) {
+        console.log(`- ${entry.date || entry.fileName} | ${entry.mode} | ${entry.topic}`);
+        console.log(`  ${entry.path}`);
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,59 @@
+import { configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, writeExampleConfig } from "../config.js";
+import { discoverLocalTools } from "../discovery.js";
+import { detectedAgentNames } from "../agentRegistry.js";
+import { createTranslator, DEFAULT_LANGUAGE, resolveLanguage } from "../i18n.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre init` ou son alias `setup`. */
+export async function runInitCommand(flags) {
+    const configPath = optionalString(flags.config) ?? (flags.local ? DEFAULT_CONFIG_PATH : GLOBAL_CONFIG_PATH);
+    const startupMessages = createTranslator(resolveLanguage({ explicitLanguage: optionalString(flags.language) }));
+    if (await configExists(configPath)) {
+        console.log(startupMessages.init.configExists(configPath));
+        return;
+    }
+    const discovery = await discoverLocalTools({ ollamaUrl: optionalString(flags["ollama-url"]) });
+    const config = createConfigFromDiscovery(discovery);
+    config.language = resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config.language
+    });
+    const messages = createTranslator(config.language);
+    await writeExampleConfig(configPath, config);
+    console.log(messages.init.configCreated(configPath));
+    printInitDiscovery(discovery, config, messages);
+}
+function printInitDiscovery(discovery, config, messages) {
+    console.log("");
+    console.log(messages.init.localDetectionTitle);
+    console.log(`- Codex CLI: ${formatCommandDetection(discovery.codex, messages)}`);
+    console.log(`- Claude CLI: ${formatCommandDetection(discovery.claude, messages)}`);
+    console.log(`- Antigravity CLI: ${formatCommandDetection(discovery.antigravity, messages)}`);
+    console.log(`- OpenCode CLI: ${formatCommandDetection(discovery.opencode, messages)}`);
+    console.log(`- Mistral Vibe CLI: ${formatCommandDetection(discovery.vibe, messages)}`);
+    console.log(`- Ollama API: ${formatOllamaDetection(discovery.ollama, messages)}`);
+    console.log("");
+    console.log(config.defaults?.agentA && config.defaults.agentB
+        ? messages.init.defaults(config.defaults.agentA, config.defaults.agentB)
+        : messages.init.noDefaultPair(formatDetectedAgentSummary(discovery, config.language ?? DEFAULT_LANGUAGE)));
+    console.log(messages.init.languageHint(config.language ?? DEFAULT_LANGUAGE));
+}
+function formatDetectedAgentSummary(discovery, language) {
+    const names = detectedAgentNames(discovery);
+    if (names.length === 0)
+        return language === "en" ? "no agent detected" : "aucun agent détecté";
+    if (names.length === 1) {
+        return language === "en" ? `only one agent detected (${names[0]})` : `un seul agent détecté (${names[0]})`;
+    }
+    return language === "en"
+        ? `no usable pair detected among ${names.join(", ")}`
+        : `aucune paire utilisable détectée parmi ${names.join(", ")}`;
+}
+function formatCommandDetection(detection, messages) {
+    return detection.available ? messages.init.commandDetected(detection.command) : messages.init.commandMissing;
+}
+function formatOllamaDetection(detection, messages) {
+    if (!detection.available) {
+        return detection.commandAvailable ? messages.init.ollamaServerUnreachable(detection.baseUrl) : messages.init.ollamaMissing;
+    }
+    return messages.init.ollamaDetected(detection.models.length);
+}

package/dist/commands/presets.js

@@ -0,0 +1,34 @@
+import { configExists, createConfigFromDiscovery, loadConfig, resolveDefaultConfigPath } from "../config.js";
+import { discoverLocalTools, discoverLocalToolsForConfig } from "../discovery.js";
+import { createTranslator, resolveLanguage } from "../i18n.js";
+import { listPresetsWithAvailability } from "../presets.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre presets` en sortie humaine ou JSON versionné. */
+export async function runPresetsCommand(flags) {
+    const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    const ollamaUrl = optionalString(flags["ollama-url"]);
+    const config = await configExists(configPath) ? await loadConfig(configPath) : undefined;
+    const discovery = config
+        ? await discoverLocalToolsForConfig(config, ollamaUrl)
+        : await discoverLocalTools({ ollamaUrl });
+    const resolvedConfig = config ?? createConfigFromDiscovery(discovery);
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: resolvedConfig.language
+    }));
+    const presets = listPresetsWithAvailability(resolvedConfig, discovery, messages);
+    if (flags.json) {
+        process.stdout.write(JSON.stringify({ v: 1, presets }) + "\n");
+        return;
+    }
+    console.log(messages.presets.title);
+    console.log("");
+    for (const preset of presets) {
+        const status = preset.available
+            ? messages.presets.available
+            : messages.presets.unavailable(preset.unavailableReasons.join("; "));
+        console.log(`  ${preset.name.padEnd(20)} ${preset.agentA} <-> ${preset.agentB}  ${status}`);
+    }
+    console.log("");
+    console.log(messages.presets.total(presets.length));
+}

package/dist/commands/shared.js

@@ -0,0 +1,4 @@
+/** Extrait une chaîne non vide depuis une valeur de flag. */
+export function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}

package/dist/commands/update.js

@@ -0,0 +1,21 @@
+import { configExists, loadConfig, resolveDefaultConfigPath } from "../config.js";
+import { createTranslator, resolveLanguage } from "../i18n.js";
+import { applySourceUpdate, formatUpdateInstructions, getUpdateInfo } from "../update.js";
+import { getPackageVersion } from "../version.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre update`, avec application explicite pour un checkout source. */
+export async function runUpdateCommand(flags) {
+    const info = await getUpdateInfo(await getPackageVersion());
+    const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    const config = await configExists(configPath) ? await loadConfig(configPath) : undefined;
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config?.language
+    }));
+    if (flags.apply) {
+        await applySourceUpdate(info, messages);
+        console.log(messages.update.upToDate);
+        return;
+    }
+    console.log(formatUpdateInstructions(info, messages));
+}

package/dist/discovery.js

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