nemoris 0.1.0

package/src/tui/chat.js

@@ -0,0 +1,835 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline/promises";
+import { PassThrough } from "node:stream";
+import packageJson from "../../package.json" with { type: "json" };
+import { parseToml } from "../config/toml-lite.js";
+import {
+  ANSI,
+  renderAgentResponse,
+  renderApprovalPrompt,
+  renderStatusBar,
+  renderThinking,
+  renderToolCard,
+  renderWordmark,
+  stripAnsi,
+} from "./renderer.js";
+import { TuiSocketClient } from "./socket-client.js";
+
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+const CTRL_U = { ctrl: true, name: "u" };
+
+export const CHAT_SLASH_COMMANDS = new Set([
+  "/",
+  "/status",
+  "/model",
+  "/cost",
+  "/clear",
+  "/help",
+  "/who",
+  "/think",
+  "/compact",
+  "/exec_approve",
+  "/exec_deny",
+  "/stop",
+]);
+
+function colorsEnabled(options = {}) {
+  return !(options.noColor || process.env.NO_COLOR);
+}
+
+function promptText(options = {}) {
+  const label = "You › ";
+  if (!colorsEnabled(options)) {
+    return label;
+  }
+  return `${ANSI.primary}${label}${ANSI.reset}`;
+}
+
+function infoText(text, color, options = {}) {
+  if (!colorsEnabled(options)) {
+    return stripAnsi(text);
+  }
+  return `${color}${text}${ANSI.reset}`;
+}
+
+function normaliseWhitespace(text) {
+  return String(text || "").replace(/\s+/g, " ").trim();
+}
+
+function parseBooleanApproval(text) {
+  const value = String(text || "").trim().toLowerCase();
+  if (value === "" || value === "y" || value === "yes") {
+    return true;
+  }
+  if (value === "n" || value === "no") {
+    return false;
+  }
+  return null;
+}
+
+function keyForTool(jobId, name) {
+  return `${jobId || "no-job"}:${name || "tool"}`;
+}
+
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return JSON.stringify({ error: "Unable to serialize event." });
+  }
+}
+
+function loadAgentName(projectRoot, agentId) {
+  const filePath = path.join(projectRoot, "config", "agents", `${agentId}.toml`);
+  try {
+    const parsed = parseToml(fs.readFileSync(filePath, "utf8"));
+    return parsed.name || parsed.id || agentId;
+  } catch {
+    return agentId;
+  }
+}
+
+function clampHistory(entries, maxEntries) {
+  return entries.slice(0, maxEntries);
+}
+
+function trailingMarkerPrefixLength(input, marker) {
+  const maxLength = Math.min(input.length, marker.length - 1);
+  for (let length = maxLength; length > 0; length -= 1) {
+    if (marker.startsWith(input.slice(-length))) {
+      return length;
+    }
+  }
+  return 0;
+}
+
+export function parseChatFlags(args = []) {
+  const flags = {
+    agent: "main",
+    model: null,
+    noColor: false,
+    json: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--agent") {
+      flags.agent = args[index + 1] || flags.agent;
+      index += 1;
+      continue;
+    }
+    if (arg === "--model") {
+      flags.model = args[index + 1] || null;
+      index += 1;
+      continue;
+    }
+    if (arg === "--no-color") {
+      flags.noColor = true;
+      continue;
+    }
+    if (arg === "--json") {
+      flags.json = true;
+    }
+  }
+
+  return flags;
+}
+
+export function isSlashCommand(input) {
+  const trimmed = String(input || "").trim();
+  if (!trimmed.startsWith("/")) {
+    return false;
+  }
+  if (trimmed === "/") {
+    return true;
+  }
+  const [command] = trimmed.split(/\s+/, 1);
+  return CHAT_SLASH_COMMANDS.has(command) || command.startsWith("/");
+}
+
+export function buildOutboundPayload(input, { agent, model } = {}) {
+  const text = String(input || "").trim();
+  if (!text) {
+    return null;
+  }
+
+  if (isSlashCommand(text)) {
+    const payload = {
+      type: "slash_command",
+      command: text,
+      text,
+      agent,
+    };
+    if (model) {
+      payload.model = model;
+    }
+    return payload;
+  }
+
+  const payload = {
+    type: "user_message",
+    text,
+    agent,
+  };
+  if (model) {
+    payload.model = model;
+  }
+  return payload;
+}
+
+export class CommandHistory {
+  constructor(maxEntries = 100) {
+    this.maxEntries = maxEntries;
+    this.entries = [];
+    this.cursor = -1;
+    this.draft = "";
+  }
+
+  add(entry) {
+    const value = String(entry || "").trim();
+    if (!value) {
+      return;
+    }
+    if (this.entries[0] === value) {
+      this.cursor = -1;
+      this.draft = "";
+      return;
+    }
+    this.entries.unshift(value);
+    this.entries = clampHistory(this.entries, this.maxEntries);
+    this.cursor = -1;
+    this.draft = "";
+  }
+
+  sync(entries = []) {
+    this.entries = clampHistory(
+      entries.map((entry) => String(entry || "").trim()).filter(Boolean),
+      this.maxEntries,
+    );
+    this.cursor = -1;
+    this.draft = "";
+  }
+
+  previous(currentDraft = "") {
+    if (this.entries.length === 0) {
+      return currentDraft;
+    }
+    if (this.cursor === -1) {
+      this.draft = currentDraft;
+    }
+    this.cursor = Math.min(this.cursor + 1, this.entries.length - 1);
+    return this.entries[this.cursor];
+  }
+
+  next() {
+    if (this.entries.length === 0) {
+      return this.draft;
+    }
+    if (this.cursor <= 0) {
+      this.cursor = -1;
+      return this.draft;
+    }
+    this.cursor -= 1;
+    return this.entries[this.cursor];
+  }
+}
+
+class ReadlineInputProxy extends PassThrough {
+  constructor(stdin) {
+    super();
+    this.stdin = stdin;
+    this.isTTY = Boolean(stdin?.isTTY);
+    this.fd = stdin?.fd;
+  }
+
+  setRawMode(mode) {
+    return this.stdin?.setRawMode?.(mode);
+  }
+
+  resume() {
+    this.stdin?.resume?.();
+    return super.resume();
+  }
+
+  pause() {
+    this.stdin?.pause?.();
+    return super.pause();
+  }
+}
+
+class StatusBarController {
+  constructor({ stdout = process.stdout, noColor = false } = {}) {
+    this.stdout = stdout;
+    this.noColor = noColor;
+    this.state = null;
+  }
+
+  update(nextState) {
+    this.state = nextState;
+    this.render();
+  }
+
+  render() {
+    if (!this.stdout.isTTY || !this.state) {
+      return;
+    }
+    const line = renderStatusBar(this.state, { noColor: this.noColor });
+    const row = Math.max(1, this.stdout.rows || 1);
+    this.stdout.write("\x1b7");
+    this.stdout.write(`\x1b[${row};1H`);
+    this.stdout.write("\x1b[2K");
+    this.stdout.write(line);
+    this.stdout.write("\x1b8");
+  }
+
+  clear() {
+    if (!this.stdout.isTTY) {
+      return;
+    }
+    const row = Math.max(1, this.stdout.rows || 1);
+    this.stdout.write("\x1b7");
+    this.stdout.write(`\x1b[${row};1H`);
+    this.stdout.write("\x1b[2K");
+    this.stdout.write("\x1b8");
+  }
+}
+
+class PromptController {
+  constructor({
+    stdin = process.stdin,
+    stdout = process.stdout,
+    noColor = false,
+    onCtrlC = async () => {},
+    history = new CommandHistory(100),
+  } = {}) {
+    this.stdin = stdin;
+    this.stdout = stdout;
+    this.noColor = noColor;
+    this.onCtrlC = onCtrlC;
+    this.history = history;
+    this.proxy = new ReadlineInputProxy(stdin);
+    this.rl = createInterface({
+      input: this.proxy,
+      output: stdout,
+      terminal: true,
+      historySize: history.maxEntries,
+      removeHistoryDuplicates: false,
+    });
+    this.rl.setPrompt(promptText({ noColor }));
+    this.pendingRead = null;
+    this.closed = false;
+    this.rawBuffer = "";
+    this.pasteBuffer = "";
+    this.inPaste = false;
+
+    this._handleRawData = this._handleRawData.bind(this);
+    this._handleSigint = this._handleSigint.bind(this);
+    this._handleHistory = this._handleHistory.bind(this);
+
+    this.stdin.setEncoding?.("utf8");
+    this.stdin.on("data", this._handleRawData);
+    this.rl.on("SIGINT", this._handleSigint);
+    this.rl.on("history", this._handleHistory);
+
+    if (this.stdout.isTTY) {
+      this.stdout.write("\x1b[?2004h");
+    }
+  }
+
+  _handleHistory(entries) {
+    this.history.sync(entries);
+  }
+
+  _handleSigint() {
+    Promise.resolve(this.onCtrlC()).catch(() => {});
+    this.rl.write(null, CTRL_U);
+    this.stdout.write("\n");
+    this.refresh();
+  }
+
+  _flushPlainBuffer(preserve = 0) {
+    if (this.rawBuffer.length <= preserve) {
+      return;
+    }
+    const chunk = this.rawBuffer.slice(0, this.rawBuffer.length - preserve);
+    this.rawBuffer = this.rawBuffer.slice(this.rawBuffer.length - preserve);
+    if (chunk) {
+      this.proxy.write(chunk);
+    }
+  }
+
+  _handleRawData(chunk) {
+    if (this.closed) {
+      return;
+    }
+    this.rawBuffer += String(chunk || "");
+
+    while (this.rawBuffer) {
+      if (this.inPaste) {
+        const endIndex = this.rawBuffer.indexOf(BRACKETED_PASTE_END);
+        if (endIndex === -1) {
+          const keep = trailingMarkerPrefixLength(this.rawBuffer, BRACKETED_PASTE_END);
+          this.pasteBuffer += this.rawBuffer.slice(0, this.rawBuffer.length - keep);
+          this.rawBuffer = this.rawBuffer.slice(this.rawBuffer.length - keep);
+          break;
+        }
+        this.pasteBuffer += this.rawBuffer.slice(0, endIndex);
+        this.rawBuffer = this.rawBuffer.slice(endIndex + BRACKETED_PASTE_END.length);
+        this.inPaste = false;
+        this._completePaste();
+        continue;
+      }
+
+      const startIndex = this.rawBuffer.indexOf(BRACKETED_PASTE_START);
+      if (startIndex === -1) {
+        this._flushPlainBuffer(trailingMarkerPrefixLength(this.rawBuffer, BRACKETED_PASTE_START));
+        break;
+      }
+
+      if (startIndex > 0) {
+        this.proxy.write(this.rawBuffer.slice(0, startIndex));
+      }
+      this.rawBuffer = this.rawBuffer.slice(startIndex + BRACKETED_PASTE_START.length);
+      this.inPaste = true;
+      this.pasteBuffer = "";
+    }
+  }
+
+  _completePaste() {
+    if (!this.pasteBuffer.includes("\n")) {
+      this.proxy.write(this.pasteBuffer);
+      this.pasteBuffer = "";
+      return;
+    }
+
+    const combined = `${this.rl.line || ""}${this.pasteBuffer}`.trimEnd();
+    this.rl.write(null, CTRL_U);
+    this.stdout.write("\n");
+    this.pasteBuffer = "";
+    this._resolvePending(combined);
+  }
+
+  _resolvePending(value) {
+    const pending = this.pendingRead;
+    if (!pending) {
+      return;
+    }
+    this.pendingRead = null;
+    pending.cleanup();
+    pending.resolve(value);
+  }
+
+  async readMessage() {
+    if (this.closed) {
+      return null;
+    }
+
+    return new Promise((resolve) => {
+      const onLine = (line) => this._resolvePending(String(line || "").trimEnd());
+      const onClose = () => this._resolvePending(null);
+      const cleanup = () => {
+        this.rl.off("line", onLine);
+        this.rl.off("close", onClose);
+      };
+      this.pendingRead = { resolve, cleanup };
+      this.rl.once("line", onLine);
+      this.rl.once("close", onClose);
+      this.rl.prompt();
+    });
+  }
+
+  print(text = "") {
+    if (!text) {
+      return;
+    }
+    this.stdout.write("\r\x1b[2K");
+    this.stdout.write(text.endsWith("\n") ? text : `${text}\n`);
+    this.refresh();
+  }
+
+  beginExternalLine(text = "") {
+    this.stdout.write("\r\x1b[2K");
+    if (text) {
+      this.stdout.write(text);
+    }
+  }
+
+  writeInline(text = "") {
+    if (!text) {
+      return;
+    }
+    this.stdout.write(text);
+  }
+
+  refresh() {
+    if (typeof this.rl._refreshLine === "function") {
+      this.rl._refreshLine();
+      return;
+    }
+    this.rl.prompt(true);
+  }
+
+  clearCurrentLine() {
+    this.rl.write(null, CTRL_U);
+    this.stdout.write("\r\x1b[2K");
+  }
+
+  close() {
+    this.closed = true;
+    this.stdin.off("data", this._handleRawData);
+    this.rl.off("SIGINT", this._handleSigint);
+    this.rl.off("history", this._handleHistory);
+    if (this.stdout.isTTY) {
+      this.stdout.write("\x1b[?2004l");
+    }
+    this.rl.close();
+    this.proxy.end();
+  }
+}
+
+export function createCtrlCHandler({ client, promptController, statusBar, state } = {}) {
+  return async function handleCtrlC() {
+    client?.send?.({ type: "abort" });
+    if (state) {
+      state.thinking = false;
+      statusBar?.update?.({
+        agent: state.agentId,
+        model: state.model,
+        tokens: state.tokens,
+        cost: state.cost,
+        connected: state.connected,
+      });
+    }
+    promptController?.clearCurrentLine?.();
+  };
+}
+
+function createBannerLine({ agentName, model }) {
+  return `nemoris v${packageJson.version} · agent: ${agentName} · model: ${model || "default"}`;
+}
+
+function renderEventError(message, options = {}) {
+  return infoText(`Error: ${message}`, ANSI.error, options);
+}
+
+function renderAgentLabel(agentName, options = {}) {
+  return infoText(`${agentName} › `, ANSI.accent, options);
+}
+
+export async function runChat({
+  projectRoot,
+  stateDir,
+  agent,
+  model,
+  noColor = false,
+  json = false,
+  stdin = process.stdin,
+  stdout = process.stdout,
+  stderr = process.stderr,
+  socketClient,
+  sessionId = randomUUID(),
+} = {}) {
+  const requestedAgent = agent || "main";
+  const requestedModel = model || null;
+  const agentName = loadAgentName(projectRoot, requestedAgent);
+  const client = socketClient || new TuiSocketClient({ stateDir });
+  const history = new CommandHistory(100);
+  const statusBar = new StatusBarController({ stdout, noColor });
+  const state = {
+    agentId: requestedAgent,
+    agentName,
+    model: requestedModel || "default",
+    tokens: 0,
+    cost: 0,
+    connected: false,
+    thinking: false,
+  };
+  const prompt = new PromptController({
+    stdin,
+    stdout,
+    noColor,
+    history,
+    onCtrlC: createCtrlCHandler({ client, statusBar, state }),
+  });
+  const pendingTools = new Map();
+  let activeStream = null;
+  let pendingApproval = null;
+  let bannerShown = false;
+  let closed = false;
+  let initialStatusResolved = false;
+  let spinnerTimer = null;
+  let spinnerFrame = 0;
+  let resolveInitialStatus = () => {};
+  const initialStatus = new Promise((resolve) => {
+    resolveInitialStatus = resolve;
+  });
+
+  const refreshStatusBar = () => {
+    const payload = {
+      agent: state.agentId,
+      model: state.model,
+      tokens: state.tokens,
+      cost: state.cost,
+      connected: state.connected,
+    };
+    if (state.thinking) {
+      payload.model = `${state.model} ${stripAnsi(renderThinking(spinnerFrame, { noColor }))}`;
+    }
+    statusBar.update(payload);
+  };
+
+  const stopSpinner = () => {
+    state.thinking = false;
+    if (spinnerTimer) {
+      clearInterval(spinnerTimer);
+      spinnerTimer = null;
+    }
+    refreshStatusBar();
+  };
+
+  const startSpinner = () => {
+    if (spinnerTimer) {
+      return;
+    }
+    state.thinking = true;
+    spinnerFrame = 0;
+    refreshStatusBar();
+    spinnerTimer = setInterval(() => {
+      spinnerFrame += 1;
+      refreshStatusBar();
+    }, 100);
+  };
+
+  const showBanner = () => {
+    if (bannerShown || json) {
+      return;
+    }
+    stdout.write(`${renderWordmark({ noColor })}\n`);
+    stdout.write(`${infoText(createBannerLine({ agentName: state.agentName, model: state.model }), ANSI.secondary, { noColor })}\n\n`);
+    bannerShown = true;
+    if (stdout.isTTY) {
+      stdout.write("\n");
+    }
+    refreshStatusBar();
+  };
+
+  const printMessage = (text) => {
+    if (json) {
+      stdout.write(`${safeJsonStringify({ type: "display", text: stripAnsi(text) })}\n`);
+      return;
+    }
+    prompt.print(text);
+    refreshStatusBar();
+  };
+
+  const handleMessage = (message) => {
+    if (json) {
+      stdout.write(`${safeJsonStringify(message)}\n`);
+      return;
+    }
+
+    switch (message.type) {
+      case "status":
+        state.connected = Boolean(message.connected ?? true);
+        state.agentId = message.agent || state.agentId;
+        state.agentName = loadAgentName(projectRoot, state.agentId);
+        state.model = message.model || state.model;
+        state.tokens = Number.isFinite(message.tokens) ? message.tokens : state.tokens;
+        state.cost = Number.isFinite(Number(message.cost)) ? Number(message.cost) : state.cost;
+        if (!initialStatusResolved) {
+          initialStatusResolved = true;
+          resolveInitialStatus();
+        }
+        refreshStatusBar();
+        return;
+      case "pong":
+        refreshStatusBar();
+        return;
+      case "error":
+        stopSpinner();
+        printMessage(renderEventError(message.message || "Unknown error.", { noColor }));
+        return;
+      case "tool_call": {
+        stopSpinner();
+        pendingTools.set(keyForTool(message.jobId, message.name), {
+          name: message.name,
+          args: message.args,
+        });
+        printMessage(renderToolCard({
+          name: message.name,
+          args: message.args,
+        }, { noColor }));
+        return;
+      }
+      case "tool_result": {
+        stopSpinner();
+        const cached = pendingTools.get(keyForTool(message.jobId, message.name)) || {};
+        printMessage(renderToolCard({
+          name: message.name,
+          args: cached.args,
+          result: message.result,
+          isError: Boolean(message.is_error),
+          durationMs: message.duration_ms,
+        }, { noColor }));
+        return;
+      }
+      case "approval_request":
+        stopSpinner();
+        pendingApproval = message;
+        printMessage(renderApprovalPrompt({
+          tool: message.tool,
+          args: message.args,
+          jobId: message.jobId,
+        }, { noColor }));
+        return;
+      case "stream_token":
+        stopSpinner();
+        if (!activeStream || activeStream.jobId !== message.jobId) {
+          activeStream = {
+            jobId: message.jobId,
+            text: "",
+          };
+          prompt.beginExternalLine(renderAgentLabel(state.agentName, { noColor }));
+        }
+        activeStream.text += message.token || "";
+        prompt.writeInline(infoText(message.token || "", ANSI.primary, { noColor }));
+        refreshStatusBar();
+        return;
+      case "stream_end":
+        stopSpinner();
+        state.tokens += Number.isFinite(message.tokens) ? message.tokens : 0;
+        state.cost += Number.isFinite(Number(message.cost)) ? Number(message.cost) : 0;
+        activeStream = {
+          jobId: message.jobId,
+          text: activeStream?.text || "",
+          complete: true,
+        };
+        prompt.writeInline("\n");
+        prompt.refresh();
+        refreshStatusBar();
+        return;
+      case "agent_response":
+        stopSpinner();
+        if (
+          activeStream &&
+          activeStream.jobId === message.jobId &&
+          normaliseWhitespace(activeStream.text) === normaliseWhitespace(message.text)
+        ) {
+          activeStream = null;
+          refreshStatusBar();
+          return;
+        }
+        printMessage(`${renderAgentLabel(state.agentName, { noColor })}${renderAgentResponse(message.text || "", { noColor })}`);
+        activeStream = null;
+        return;
+      default:
+        printMessage(infoText(safeJsonStringify(message), ANSI.muted, { noColor }));
+    }
+  };
+
+  client.on("connected", () => {
+    state.connected = true;
+    client.send({
+      type: "hello",
+      sessionId,
+      agent: requestedAgent,
+      model: requestedModel,
+    });
+    refreshStatusBar();
+  });
+
+  client.on("disconnected", () => {
+    state.connected = false;
+    refreshStatusBar();
+    if (!closed && !json) {
+      printMessage(infoText("Connection lost. Reconnecting...", ANSI.warning, { noColor }));
+    }
+  });
+
+  client.on("message", handleMessage);
+  client.on("error", (error) => {
+    if (closed) {
+      return;
+    }
+    stopSpinner();
+    const message = error?.message || String(error);
+    if (json) {
+      stderr.write(`${safeJsonStringify({ type: "client_error", message })}\n`);
+      return;
+    }
+    printMessage(renderEventError(message, { noColor }));
+  });
+
+  try {
+    try {
+      await client.connect();
+    } catch (connectError) {
+      const code = connectError?.code || "";
+      if (code === "ENOENT" || code === "ECONNREFUSED") {
+        stderr.write("Daemon not running. Start with: nemoris start\n");
+        process.exitCode = 1;
+        return 1;
+      }
+      throw connectError;
+    }
+    await Promise.race([
+      initialStatus,
+      new Promise((resolve) => setTimeout(resolve, 200)),
+    ]);
+    showBanner();
+
+    while (!closed) {
+      const line = await prompt.readMessage();
+      if (line == null) {
+        break;
+      }
+
+      const text = String(line || "").trim();
+      if (!text) {
+        continue;
+      }
+
+      history.add(text);
+
+      if (pendingApproval) {
+        const approved = parseBooleanApproval(text);
+        if (approved != null) {
+          client.send({
+            type: "approval",
+            action: approved ? "approve" : "deny",
+            approvalId: pendingApproval.approvalId,
+            jobId: pendingApproval.jobId,
+          });
+          pendingApproval = null;
+          continue;
+        }
+      }
+
+      const payload = buildOutboundPayload(text, {
+        agent: requestedAgent,
+        model: requestedModel,
+      });
+      if (!payload) {
+        continue;
+      }
+
+      if (!client.send(payload)) {
+        printMessage(renderEventError("Socket is not connected.", { noColor }));
+        continue;
+      }
+
+      startSpinner();
+    }
+  } finally {
+    closed = true;
+    stopSpinner();
+    statusBar.clear();
+    prompt.close();
+    client.close();
+  }
+
+  return 0;
+}