palabre 0.9.1 → 0.10.0

package/dist/renderers/tui-prompts.js

@@ -0,0 +1,339 @@
+/**
+ * @file Entrées interactives du TUI : prompt d'accueil, commandes `/config`,
+ * assistants agents/rôles et composer visuel. Toute la lecture readline vit ici,
+ * avec la gestion du double Ctrl+C (retour puis quit) partagée par tous les prompts.
+ */
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { renderTuiAgentsHelp, renderTuiRolesHelp } from "./tui-screens.js";
+import { accent, bold, composerCard, dim, glyphs, labeledRule, padBlock, surfacePadding, surfaceWidth, violet, wrapLine } from "./tui-theme.js";
+/** Parse `/ollama-url <url>` : renvoie `unknown` avec le message d'usage si l'argument est absent. */
+export function parseTuiOllamaUrlCommand(parts, messages) {
+    const value = parts[1];
+    return value ? { kind: "ollama-url", url: value } : { kind: "unknown", message: messages.tui.ollamaUrlUsage };
+}
+/**
+ * Extrait les options de contexte inline (`--context <chemins...>`, `--files <chemins...>`)
+ * d'un sujet tapé dans le composer, comme le suggère le tip de l'accueil. Les chemins
+ * suivent leur flag jusqu'au prochain token commençant par `--`. Limite assumée du MVP :
+ * les chemins contenant des espaces ne sont pas supportés dans cette syntaxe inline.
+ */
+export function parseComposerTopic(value) {
+    const topicTokens = [];
+    const files = [];
+    const context = [];
+    let collector;
+    for (const token of value.split(/\s+/).filter(Boolean)) {
+        if (token === "--context") {
+            collector = context;
+            continue;
+        }
+        if (token === "--files" || token === "--file") {
+            collector = files;
+            continue;
+        }
+        if (token.startsWith("--")) {
+            // Flag inconnu : rendu au sujet tel quel pour rester visible et sans surprise.
+            collector = undefined;
+            topicTokens.push(token);
+            continue;
+        }
+        (collector ?? topicTokens).push(token);
+    }
+    return { topic: topicTokens.join(" "), files, context };
+}
+let lastTuiInterruptAt = 0;
+const doubleInterruptMs = 1200;
+function nextInterruptKind() {
+    const now = Date.now();
+    const kind = now - lastTuiInterruptAt <= doubleInterruptMs ? "quit" : "back";
+    lastTuiInterruptAt = now;
+    return kind;
+}
+function questionWithInterrupt(rl, prompt) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => rl.off("SIGINT", onSigint);
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(result);
+        };
+        const onSigint = () => {
+            const kind = nextInterruptKind();
+            rl.close();
+            settle({ kind });
+        };
+        rl.once("SIGINT", onSigint);
+        rl.question(prompt).then((value) => settle({ kind: "answer", value }), (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        });
+    });
+}
+/** Lit une demande depuis l'accueil TUI. Retourne undefined si l'utilisateur quitte. */
+export async function promptTuiHomeTopic(mode = "debate", messages, options = {}) {
+    if (!input.isTTY) {
+        return undefined;
+    }
+    const rl = createInterface({ input, output });
+    try {
+        const result = await questionWithInterrupt(rl, tuiPrompt(mode, messages.tui.subject, messages, options.notice));
+        if (result.kind !== "answer") {
+            return undefined;
+        }
+        const answer = result.value;
+        const value = answer.trim();
+        const parts = value.split(/\s+/).filter(Boolean);
+        const command = parts[0]?.toLowerCase() ?? "";
+        if (!value || command === "/quit" || command === "/q" || command === "/exit") {
+            return undefined;
+        }
+        if (command === "/new") {
+            return { kind: "new" };
+        }
+        if (command === "/retry") {
+            return { kind: "retry" };
+        }
+        if (command === "/update") {
+            return { kind: "update" };
+        }
+        if (command === "/historique" || command === "/history") {
+            return { kind: "history" };
+        }
+        if (command === "/home" || command === "/back" || command === "/b") {
+            return { kind: "home" };
+        }
+        if (command === "/config") {
+            return { kind: "config" };
+        }
+        if (command === "/agents") {
+            return { kind: "agents", agents: parts.slice(1) };
+        }
+        if (command === "/ask") {
+            return { kind: "mode", mode: "ask" };
+        }
+        if (command === "/debat" || command === "/débat" || command === "/debate") {
+            return { kind: "mode", mode: "debate" };
+        }
+        if (command === "/help" || command === "/h" || command === "/?") {
+            return { kind: "help" };
+        }
+        if (command === "/roles" || command === "/role") {
+            return { kind: "roles", roles: parts.slice(1) };
+        }
+        if (value.startsWith("/")) {
+            return { kind: "help" };
+        }
+        const composerInput = parseComposerTopic(value);
+        return {
+            kind: "topic",
+            topic: composerInput.topic,
+            ...(composerInput.files.length > 0 ? { files: composerInput.files } : {}),
+            ...(composerInput.context.length > 0 ? { context: composerInput.context } : {})
+        };
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Lit une commande depuis l'ecran de config TUI. */
+export async function promptTuiConfigCommand(mode, messages) {
+    if (!input.isTTY) {
+        return { kind: "back" };
+    }
+    const rl = createInterface({ input, output });
+    try {
+        const result = await questionWithInterrupt(rl, tuiPrompt(mode, messages.tui.configPrompt, messages));
+        if (result.kind === "quit") {
+            return { kind: "quit" };
+        }
+        if (result.kind === "back") {
+            return { kind: "back" };
+        }
+        const answer = result.value;
+        const parts = answer.trim().split(/\s+/).filter(Boolean);
+        const command = parts[0]?.toLowerCase();
+        if (!command || command === "/home" || command === "/back" || command === "/b") {
+            return { kind: "back" };
+        }
+        if (command === "/quit" || command === "/q" || command === "/exit") {
+            return { kind: "quit" };
+        }
+        if (command === "/mode") {
+            return { kind: "mode" };
+        }
+        if (command === "/default") {
+            return { kind: "default-mode" };
+        }
+        if (command === "/interface") {
+            const value = parts[1];
+            if (value === "tui" || value === "terminal") {
+                return { kind: "interface", interfaceName: value };
+            }
+            return { kind: "unknown", message: "Usage: /interface <tui|terminal>" };
+        }
+        if (command === "/language" || command === "/langue" || command === "/lang") {
+            const value = parts[1];
+            if (value === "fr" || value === "en") {
+                return { kind: "language", language: value };
+            }
+            return { kind: "unknown", message: "Usage: /language <fr|en>" };
+        }
+        if (command === "/agents") {
+            return parts.length > 1
+                ? { kind: "agents", agents: parts.slice(1) }
+                : { kind: "agents", agents: [] };
+        }
+        if (command === "/roles" || command === "/role") {
+            return { kind: "roles", roles: parts.slice(1) };
+        }
+        if (command === "/turns") {
+            const turns = Number(parts[1]);
+            return Number.isInteger(turns)
+                ? { kind: "turns", turns }
+                : { kind: "unknown", message: messages.tui.turnsUsage };
+        }
+        if (command === "/summary") {
+            const value = parts[1];
+            if (!value) {
+                return { kind: "unknown", message: messages.tui.summaryUsage };
+            }
+            return { kind: "summary", agent: isNoneValue(value) ? undefined : value };
+        }
+        if (command === "/ollama") {
+            const value = parts[1];
+            return value ? { kind: "ollama-model", model: value } : { kind: "ollama-info" };
+        }
+        if (command === "/ollama-url" || command === "/ollama-host") {
+            return parseTuiOllamaUrlCommand(parts, messages);
+        }
+        if (command === "/ollama-model") {
+            const value = parts[1];
+            return value ? { kind: "ollama-model", model: value } : { kind: "unknown", message: messages.tui.ollamaModelUsage };
+        }
+        if (command === "/model") {
+            const [first, second] = parts.slice(1);
+            const value = first === "ollama-local" ? second : first;
+            return value ? { kind: "ollama-model", model: value } : { kind: "unknown", message: messages.tui.ollamaModelUsage };
+        }
+        if (command === "/ollama-sync") {
+            return { kind: "ollama-sync" };
+        }
+        return { kind: "unknown", message: messages.tui.unknownCommand };
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Assistant minimal pour modifier les agents du mode courant. */
+export async function promptTuiAgentsWizard(config, mode, messages) {
+    if (!input.isTTY) {
+        return { kind: "back" };
+    }
+    renderTuiAgentsHelp(config, mode, messages);
+    const rl = createInterface({ input, output });
+    try {
+        const result = await questionWithInterrupt(rl, tuiPrompt(mode, messages.tui.agentsPrompt, messages));
+        if (result.kind === "quit") {
+            return { kind: "quit" };
+        }
+        if (result.kind === "back") {
+            return { kind: "back" };
+        }
+        const value = result.value.trim();
+        if (!value || value === "/home" || value === "/back") {
+            return { kind: "back" };
+        }
+        if (value === "/quit" || value === "/q") {
+            return { kind: "quit" };
+        }
+        return { kind: "agents", agents: value.split(/\s+/).filter(Boolean) };
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Assistant minimal pour modifier les roles du mode courant. */
+export async function promptTuiRolesWizard(config, mode, messages) {
+    if (!input.isTTY) {
+        return { kind: "back" };
+    }
+    renderTuiRolesHelp(mode, messages, config);
+    const rl = createInterface({ input, output });
+    try {
+        const result = await questionWithInterrupt(rl, tuiPrompt(mode, messages.tui.rolesPrompt, messages));
+        if (result.kind === "quit") {
+            return { kind: "quit" };
+        }
+        if (result.kind === "back") {
+            return { kind: "back" };
+        }
+        const answer = result.value;
+        const value = answer.trim();
+        if (!value || value === "/home" || value === "/back") {
+            return { kind: "back" };
+        }
+        if (value === "/quit" || value === "/q") {
+            return { kind: "quit" };
+        }
+        return { kind: "roles", roles: value.split(/\s+/).filter(Boolean) };
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Affiche un composer visuel juste avant la vraie ligne readline. */
+export function renderTuiComposer(mode, messages, labelPrefix = messages.tui.subject, options = {}) {
+    if (!options.force && !input.isTTY) {
+        return;
+    }
+    const width = surfaceWidth();
+    process.stdout.write([
+        "",
+        ...padBlock(composerInputBox(mode, labelPrefix, width, messages)),
+        ""
+    ].join("\n"));
+}
+/**
+ * Zone de saisie : fil d'Ariane intégré à la règle violette, puis ligne de saisie
+ * réduite au marqueur `❯` — le contexte vit dans la règle, pas devant le curseur.
+ */
+function tuiPrompt(mode, labelPrefix, messages, notice) {
+    const padding = surfacePadding();
+    const promptLine = `${padding}${accent(glyphs().prompt)} `;
+    return [
+        "",
+        `${padding}${labeledRule(promptTrail(mode, labelPrefix, messages), violet)}`,
+        ...(notice ? promptNoticeLines(notice) : []),
+        promptLine,
+    ].join("\n");
+}
+function promptNoticeLines(notice) {
+    const padding = surfacePadding();
+    const contentWidth = surfaceWidth();
+    return wrapLine(notice, contentWidth).map((line) => `${padding}${line}`);
+}
+function promptModeLabel(mode, messages) {
+    return `Mode ${messages.tui.modeValue(mode).toLowerCase()}`;
+}
+function promptTrail(mode, labelPrefix, messages) {
+    const parts = [bold("Palabre"), accent(promptModeLabel(mode, messages))];
+    if (labelPrefix !== messages.tui.subject) {
+        parts.push(bold(labelPrefix));
+    }
+    return parts.join(` ${dim(glyphs().pointer)} `);
+}
+function composerInputBox(mode, labelPrefix, width, messages) {
+    return composerCard([
+        `${promptTrail(mode, labelPrefix, messages)} ${accent(glyphs().prompt)}`
+    ], width);
+}
+function isNoneValue(value) {
+    return ["none", "aucun", "off", "non", "0", "disabled"].includes(value.toLowerCase());
+}

package/dist/renderers/tui-renderer.js

@@ -0,0 +1,224 @@
+/**
+ * @file Renderer TUI des événements de débat/ask : en-tête de session, statut
+ * "agent en cours" avec spinner, messages encadrés à la couleur de l'agent,
+ * synthèse structurée et panneau de fin avec liens vers l'export.
+ */
+import path from "node:path";
+import { accent, accentBar, agentColor, agentLabel, bold, brandHeader, card, clearScreen, codes, compactFileName, compactPath, danger, dim, glyphs, padBlock, panel, row, success, supportsColor, supportsInteractiveOutput, surfacePadding, surfaceWidth, terminalLink, underlineFor, warning } from "./tui-theme.js";
+/** Cree le premier renderer TUI leger, sans dependance UI externe. */
+export function createTuiRenderer(messages) {
+    return new TuiRenderer(messages, supportsColor, supportsInteractiveOutput);
+}
+/**
+ * Renderer TUI V0.
+ *
+ * Il ne tente pas encore de faire du scrolling controle ou des panes interactives :
+ * il fournit un tableau de bord plein terminal, un statut d'agent en cours et des
+ * sections lisibles tout en conservant la sortie complete dans le flux terminal.
+ */
+class TuiRenderer {
+    messages;
+    color;
+    interactive;
+    spinner;
+    spinnerFrame = 0;
+    currentSection = "debate";
+    currentAgent;
+    /** Titre du tour en attente, rendu en tête du prochain bloc `message`. */
+    pendingHeader;
+    constructor(messages, color, interactive) {
+        this.messages = messages;
+        this.color = color;
+        this.interactive = interactive;
+    }
+    start(options, agents = []) {
+        if (this.interactive) {
+            clearScreen();
+        }
+        process.stdout.write(this.renderSessionHeader(options, agents).join("\n") + "\n");
+    }
+    notice(message) {
+        const width = this.width();
+        process.stdout.write(`\n${padBlock(card([
+            `${success(this.messages.renderers.infoPrefix)} ${message}`
+        ], width)).join("\n")}\n`);
+    }
+    warning(message) {
+        process.stderr.write(`${warning(this.messages.renderers.warningPrefix)} ${message}\n`);
+    }
+    turnStart(turn, totalTurns, agent, role) {
+        this.currentSection = "debate";
+        this.currentAgent = agent;
+        this.pendingHeader = `${agentLabel(agent)} (${role}) - ${this.messages.renderers.turn(turn, totalTurns)}`;
+    }
+    askResponseStart(response, totalResponses, agent, role) {
+        this.currentSection = "ask";
+        this.currentAgent = agent;
+        this.pendingHeader = `${agentLabel(agent)} (${role}) - ${this.messages.tui.askResponse(response, totalResponses)}`;
+    }
+    thinkingStart(agent, role) {
+        this.thinkingEnd();
+        const text = this.messages.renderers.thinking(agent, role);
+        if (!this.interactive) {
+            process.stdout.write(`${text}...\n`);
+            return;
+        }
+        process.stdout.write("\u001b[?25l");
+        const frames = glyphs().spinner;
+        const render = () => {
+            const frame = frames[this.spinnerFrame % frames.length];
+            this.spinnerFrame += 1;
+            process.stdout.write(`\r\u001b[2K${surfacePadding()}${agentColor(agent, frame)} ${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\u001b[?25h");
+        }
+    }
+    message(content) {
+        const trimmed = content.trim();
+        process.stdout.write(`${this.formatMessage(this.currentSection === "summary" ? this.formatSummary(trimmed) : trimmed)}\n`);
+    }
+    askResponseMessage(content) {
+        this.message(content);
+    }
+    summaryStart(agent, role) {
+        this.currentSection = "summary";
+        this.currentAgent = agent;
+        this.pendingHeader = `${this.messages.renderers.summaryTitle} - ${agentLabel(agent)} (${role})`;
+    }
+    error(failure) {
+        this.thinkingEnd();
+        const width = this.width();
+        const hint = this.messages.adapterErrors.hint(failure.kind);
+        process.stderr.write(`\n${padBlock(card([
+            danger(`${glyphs().cross} ${this.messages.common.errorPrefix}`),
+            `${formatFailureLocation(failure, this.messages)}: ${failure.message}`,
+            ...(hint ? ["", dim(`${this.messages.adapterErrors.suggestionPrefix}: ${hint}`)] : [])
+        ], width)).join("\n")}\n`);
+    }
+    done(outputPath) {
+        this.thinkingEnd();
+        const width = this.width();
+        const folderPath = path.dirname(outputPath);
+        const fileName = path.basename(outputPath);
+        process.stdout.write(`\n${padBlock(panel([
+            `${success(glyphs().check)} ${bold(this.messages.tui.sessionDone)}`,
+            "",
+            row(this.messages.tui.exportedFile, terminalLink(outputPath, compactFileName(fileName, width - 24))),
+            row(this.messages.tui.exportedFolder, terminalLink(folderPath, compactPath(folderPath, width - 24))),
+            "",
+            dim(this.messages.tui.sessionHistoryHint)
+        ], width)).join("\n")}\n\n`);
+    }
+    renderSessionHeader(options, agents) {
+        const width = this.width();
+        const mode = messagesModeLabel(this.messages, options.mode).toUpperCase();
+        const main = panel([
+            accent(mode),
+            this.messages.renderers.subject(options.topic),
+            this.messages.renderers.agents(formatAgents(options, agents)),
+            formatSessionProgress(options, this.messages),
+            this.messages.renderers.context(formatContext(options, this.messages)),
+            this.messages.renderers.workingFolder(compactPath(options.session.cwd, Math.max(24, width - 14)))
+        ], width);
+        return [
+            "",
+            ...padBlock([brandHeader()]),
+            "",
+            ...padBlock(main),
+            ""
+        ];
+    }
+    /**
+     * Bloc de message unique : en-tête du tour (titre souligné) et contenu dans le même
+     * bloc, délimité par la seule barre latérale gauche à la couleur de l'agent.
+     */
+    formatMessage(content) {
+        const width = this.width();
+        const header = this.pendingHeader
+            ? [bold(this.pendingHeader), underlineFor(this.pendingHeader, width, this.currentAgent), ""]
+            : [];
+        this.pendingHeader = undefined;
+        const body = content.split(/\r?\n/);
+        return `\n${padBlock(accentBar([...header, ...body], width, this.currentAgent)).join("\n")}\n`;
+    }
+    formatSummary(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(Math.min(48, this.width())))
+            ].join("\n");
+        })
+            .join("\n")
+            .trimStart();
+    }
+    width() {
+        return surfaceWidth();
+    }
+    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}`;
+    }
+}
+function formatAgents(options, agents) {
+    if (options.mode === "ask") {
+        return agents.length > 0
+            ? agents.map(formatAgent).join(", ")
+            : (options.askAgents ?? [options.agentA, options.agentB]).join(", ");
+    }
+    if (agents.length >= 2) {
+        return `${formatAgent(agents[0])} <-> ${formatAgent(agents[1])}`;
+    }
+    return `${options.agentA} <-> ${options.agentB}`;
+}
+function formatAgent(agent) {
+    return agent ? `${agentLabel(agent.name)} (${agent.role})` : "?";
+}
+function formatSummary(options, messages) {
+    if (!options.summaryEnabled) {
+        return messages.renderers.disabled;
+    }
+    return options.summaryAgent;
+}
+function formatResponseCount(options) {
+    return options.mode === "ask" ? options.askAgents?.length ?? 2 : options.turns;
+}
+function formatSessionProgress(options, messages) {
+    return `${messages.tui.historyCount(options.mode)}: ${formatResponseCount(options)} | ${messages.tui.summary}: ${formatSummary(options, messages)}`;
+}
+function formatContext(options, messages) {
+    return options.files.length === 0
+        ? messages.renderers.noInjectedFiles
+        : messages.renderers.injectedFiles(options.files.length, options.files.map((file) => file.path));
+}
+function formatFailureLocation(failure, messages) {
+    if (failure.phase === "summary") {
+        return messages.renderers.summaryTitle;
+    }
+    const turn = failure.turn === undefined ? "" : `, ${messages.tui.turnLabel(failure.turn)}`;
+    return `${failure.agent ?? "?"} (${failure.role ?? "?"}${turn})`;
+}
+function messagesModeLabel(messages, mode) {
+    return messages.tui.modeValue(mode);
+}