neagen 0.1.0 → 0.1.2

package/lib/eve-product-tui.mjs

@@ -0,0 +1,399 @@
+// Product Neagen TUI: Eve's terminal runner, Neagen's authenticated /api/turns
+// transport. This keeps Eve's TUI/approval/tool rendering while preserving the
+// app's wallet, memory, billing, conversation, and model-selection lifecycle.
+
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { assertTransportSafe, clearCreds, loadToken, resolveHost } from "./creds.mjs";
+import {
+  getSelectedModel,
+  listModels,
+  probeHost,
+  resolveIdentity,
+  selectModel,
+} from "./api.mjs";
+import { runDeviceGrantLogin } from "./device-login.mjs";
+import { parseSseChunk } from "./turn-stream.mjs";
+
+const require = createRequire(import.meta.url);
+
+function eveInternalUrl(relativePath) {
+  const root = dirname(require.resolve("eve/package.json"));
+  return pathToFileURL(join(root, relativePath)).href;
+}
+
+async function loadEveTuiRunner() {
+  const mod = await import(eveInternalUrl("dist/src/cli/dev/tui/runner.js"));
+  return mod.EveTUIRunner;
+}
+
+function normalizeHost(host) {
+  return host.replace(/\/$/, "");
+}
+
+function modelAliases(input) {
+  const value = input.trim();
+  const lower = value.toLowerCase();
+  if (lower === "deepseek" || lower === "flash") return "deepseek/deepseek-v4-flash";
+  if (lower === "sonnet" || lower === "claude" || lower === "claude-sonnet") {
+    return "anthropic/claude-sonnet-4.6";
+  }
+  return value;
+}
+
+function formatModel(model) {
+  if (!model) return "unknown";
+  const label = model.providerLabel && model.name ? `${model.providerLabel} ${model.name}` : model.id;
+  return `${label} (${model.id})`;
+}
+
+function agentInfoForModel(model, identity) {
+  return {
+    agent: {
+      name: identity?.neagenName ?? "Neagen",
+      model: {
+        id: model?.id ?? "unknown",
+        provider: model?.provider ?? model?.providerLabel,
+      },
+    },
+    diagnostics: {
+      discoveryErrors: 0,
+      discoveryWarnings: 0,
+    },
+  };
+}
+
+function inputRequestToolName(request) {
+  return request?.action?.toolName ?? "input";
+}
+
+function isNeagenCommitEvent(eventName) {
+  return eventName === "neagen.finalized" ||
+    eventName === "neagen.waiting_saved" ||
+    eventName === "neagen.gate_declined";
+}
+
+function neagenErrorToSessionFailed(data) {
+  return {
+    type: "session.failed",
+    data: {
+      error: {
+        code: data?.code ?? "turn_failed",
+        message: data?.message ?? "Turn failed.",
+      },
+    },
+  };
+}
+
+function isBoundaryEvent(event) {
+  return event?.type === "session.waiting" ||
+    event?.type === "session.completed" ||
+    event?.type === "session.failed";
+}
+
+async function* readProductTurnEvents(response, onProductEvent) {
+  if (!response.ok) {
+    let message = `HTTP ${response.status}`;
+    const text = await response.text();
+    try {
+      message = JSON.parse(text)?.error?.message ?? message;
+    } catch {
+      if (text.trim()) message = text.trim();
+    }
+    throw new Error(message);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("Turn stream is not readable.");
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let heldBoundary;
+
+  async function* handleEntry(entry) {
+    const { event, data } = entry;
+
+    if (event === "done") {
+      if (heldBoundary) {
+        yield heldBoundary;
+        heldBoundary = undefined;
+      }
+      return;
+    }
+
+    if (event === "neagen.error") {
+      yield neagenErrorToSessionFailed(data);
+      heldBoundary = undefined;
+      return;
+    }
+
+    if (isNeagenCommitEvent(event)) {
+      onProductEvent(event, data);
+      if (heldBoundary) {
+        yield heldBoundary;
+        heldBoundary = undefined;
+      }
+      return;
+    }
+
+    const eveEvent = { type: event, data };
+    if (isBoundaryEvent(eveEvent)) {
+      heldBoundary = eveEvent;
+      return;
+    }
+    yield eveEvent;
+  }
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const parsed = parseSseChunk(buffer);
+    buffer = parsed.trailing;
+    for (const entry of parsed.events) {
+      yield* handleEntry(entry);
+    }
+  }
+
+  if (buffer.trim()) {
+    const parsed = parseSseChunk(`${buffer}\n\n`);
+    for (const entry of parsed.events) {
+      yield* handleEntry(entry);
+    }
+  }
+
+  if (heldBoundary) yield heldBoundary;
+}
+
+class ProductMessageResponse {
+  constructor(events) {
+    this.events = events;
+  }
+
+  [Symbol.asyncIterator]() {
+    return this.events[Symbol.asyncIterator]();
+  }
+}
+
+class ProductSession {
+  constructor(client, state = {}) {
+    this.client = client;
+    this.conversationId = state.conversationId;
+  }
+
+  get state() {
+    return {
+      sessionId: this.conversationId,
+      streamIndex: 0,
+      conversationId: this.conversationId,
+    };
+  }
+
+  async send(input) {
+    const payload = typeof input === "string" ? { message: input } : (input ?? {});
+    const body = payload.inputResponses?.length
+      ? { conversationId: this.conversationId, inputResponses: payload.inputResponses }
+      : { conversationId: this.conversationId, body: payload.message };
+
+    if (!body.body && !body.inputResponses) {
+      throw new Error("Nothing to send.");
+    }
+    if (body.inputResponses && !body.conversationId) {
+      throw new Error("No Neagen conversation is waiting for approval.");
+    }
+
+    const response = await fetch(`${this.client.host}/api/turns`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.client.token}`,
+        "content-type": "application/json",
+        accept: "text/event-stream",
+      },
+      body: JSON.stringify(body),
+      signal: payload.signal,
+    });
+
+    const events = readProductTurnEvents(response, (event, data) => {
+      if (data?.conversationId) this.conversationId = data.conversationId;
+      if (event === "neagen.gate_declined" && data?.conversationId) {
+        this.conversationId = data.conversationId;
+      }
+    });
+    return new ProductMessageResponse(events);
+  }
+}
+
+class ProductClient {
+  constructor({ host, token, identity }) {
+    this.host = normalizeHost(host);
+    this.token = token;
+    this.identity = identity;
+    this.cachedSelection = undefined;
+  }
+
+  session(state) {
+    return new ProductSession(this, state);
+  }
+
+  async selectedModel() {
+    const selection = await getSelectedModel(this.host, this.token);
+    this.cachedSelection = selection;
+    return selection.activeModel;
+  }
+
+  async info() {
+    let model;
+    try {
+      model = await this.selectedModel();
+    } catch {
+      model = this.cachedSelection?.activeModel;
+    }
+    return agentInfoForModel(model, this.identity);
+  }
+}
+
+function modelOptions(models, activeId) {
+  return models.map((model) => ({
+    value: model.id,
+    label: `${model.id === activeId ? "● " : ""}${model.name ?? model.id}`,
+    description: `${model.providerLabel ?? model.provider ?? ""} · ${model.id}`,
+  }));
+}
+
+function createModelCommandHandler({ host, token, productClient, title }) {
+  return {
+    async handle(command, context) {
+      if (command.name !== "model") {
+        return { message: `/${command.name} is not supported in the Neagen TUI.` };
+      }
+
+      const raw = command.argument.trim();
+      if (raw) {
+        const updated = await selectModel(host, token, modelAliases(raw));
+        productClient.cachedSelection = updated;
+        context.renderer.renderAgentHeader?.({
+          name: title,
+          serverUrl: host,
+          info: agentInfoForModel(updated.activeModel, productClient.identity),
+        });
+        return { message: `Switched model to ${formatModel(updated.activeModel)}.` };
+      }
+
+      const [selection, models] = await Promise.all([
+        getSelectedModel(host, token),
+        listModels(host, token),
+      ]);
+      productClient.cachedSelection = selection;
+      const activeId = selection.activeModel?.id;
+      const flow = context.renderer.setupFlow;
+      if (!flow) {
+        return {
+          message: `Current model: ${formatModel(selection.activeModel)}. Use /model provider/model to switch.`,
+        };
+      }
+
+      flow.begin("Choose Neagen model", "pulse");
+      try {
+        const chosen = await flow.readSelect({
+          kind: "search",
+          message: "Pick the model Neagen should use",
+          placeholder: "Filter models",
+          initialValue: activeId,
+          options: modelOptions(models, activeId),
+        });
+        const modelId = chosen?.[0];
+        if (!modelId) return { message: "/model cancelled." };
+        if (modelId === activeId) return { message: `Already using ${formatModel(selection.activeModel)}.` };
+        const updated = await selectModel(host, token, modelId);
+        productClient.cachedSelection = updated;
+        context.renderer.renderAgentHeader?.({
+          name: title,
+          serverUrl: host,
+          info: agentInfoForModel(updated.activeModel, productClient.identity),
+        });
+        return { message: `Switched model to ${formatModel(updated.activeModel)}.` };
+      } finally {
+        flow.end({ preserveDiagnostics: false });
+      }
+    },
+  };
+}
+
+async function ensureReachable(host) {
+  process.stdout.write(`Connecting to ${host}...\n`);
+  await probeHost(host);
+}
+
+async function ensureAuthenticated({ host, profile }) {
+  let token = loadToken(profile, host);
+  if (token) {
+    const identity = await resolveIdentity(host, token);
+    if (identity) return { token, identity };
+    clearCreds(profile);
+    token = null;
+  }
+  token = await runDeviceGrantLogin({ host, profile });
+  const identity = await resolveIdentity(host, token);
+  if (!identity) {
+    clearCreds(profile);
+    throw new Error("Session could not be verified after login.");
+  }
+  return { token, identity };
+}
+
+export async function runProductTui({ profile } = {}) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("neagen requires an interactive terminal.");
+  }
+
+  const host = normalizeHost(resolveHost());
+  assertTransportSafe(host);
+  await ensureReachable(host);
+  const { token, identity } = await ensureAuthenticated({ host, profile });
+  const EveTUIRunner = await loadEveTuiRunner();
+  const client = new ProductClient({ host, token, identity });
+  const title = identity.neagenName ?? "neagen";
+  const session = client.session();
+
+  const selected = await client.selectedModel().catch(() => undefined);
+  process.stdout.write(`Agent online. Model: ${selected?.id ?? "unknown"}.\n`);
+
+  await new EveTUIRunner({
+    session,
+    client,
+    serverUrl: host,
+    name: title,
+    tools: "full",
+    reasoning: "full",
+    assistantResponseStats: "tokensPerSecond",
+    promptCommandHandler: createModelCommandHandler({ host, token, productClient: client, title }),
+    availablePromptCommands: [
+      { name: "help", aliases: [], description: "Show available commands", takesArgument: false },
+      { name: "new", aliases: [], description: "Start a fresh session", takesArgument: false },
+      {
+        name: "model",
+        aliases: [],
+        description: "Pick the Neagen model",
+        argumentHint: "[provider/model]",
+        takesArgument: true,
+      },
+      {
+        name: "loglevel",
+        aliases: [],
+        description: "Show or hide logs",
+        argumentHint: "[all|stderr|sandbox|none]",
+        takesArgument: true,
+      },
+      { name: "exit", aliases: ["quit"], description: "Quit", takesArgument: false },
+    ],
+  }).run();
+}
+
+export {
+  createModelCommandHandler,
+  ProductClient,
+  ProductSession,
+  readProductTurnEvents,
+  inputRequestToolName,
+};

package/lib/picker.mjs

@@ -0,0 +1,280 @@
+// Interactive terminal picker — type to filter, arrows to move, enter to select.
+
+import { emitKeypressEvents } from "node:readline";
+import { stdin, stdout } from "node:process";
+import { dim, bold } from "./ansi.mjs";
+import { slashCommandMatches, slashCompletionSuffix } from "./slash.mjs";
+
+const DEFAULT_WINDOW = 10;
+
+/**
+ * @param {import("node:readline/promises").Interface} rl
+ * @param {object} options
+ * @param {readonly unknown[]} options.items
+ * @param {(item: unknown, filter: string) => boolean} options.matchItem
+ * @param {(item: unknown, selected: boolean, active: boolean) => string} options.formatRow
+ * @param {string[]} options.headerLines
+ * @param {number} [options.windowSize]
+ * @param {number} [options.initialIndex]
+ */
+export function runPicker(rl, options) {
+  const {
+    items,
+    matchItem,
+    formatRow,
+    headerLines,
+    windowSize = DEFAULT_WINDOW,
+    initialIndex = 0,
+  } = options;
+
+  return new Promise((resolve) => {
+    let filter = "";
+    let view = [...items];
+    let index = Math.min(Math.max(0, initialIndex), Math.max(0, view.length - 1));
+    let offset = Math.max(0, Math.min(index - 2, Math.max(0, view.length - windowSize)));
+
+    const refilter = () => {
+      view = items.filter((item) => matchItem(item, filter));
+      index = 0;
+      offset = 0;
+    };
+
+    rl.pause();
+    const prevRaw = stdin.isRaw;
+    const savedKeypress = stdin.listeners("keypress");
+    stdin.removeAllListeners("keypress");
+    emitKeypressEvents(stdin);
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+
+    let lastLines = 0;
+    const clearRender = () => {
+      if (lastLines > 0) stdout.write(`\x1b[${lastLines}A\x1b[J`);
+    };
+    const render = () => {
+      clearRender();
+      const lines = [...headerLines, dim(`  filter: ${filter || "(all)"}   ·   ${view.length} match`)];
+      if (view.length === 0) {
+        lines.push(dim("    no matches"));
+      } else {
+        for (let i = offset; i < Math.min(offset + windowSize, view.length); i++) {
+          lines.push(formatRow(view[i], i === index, false));
+        }
+      }
+      stdout.write(`${lines.join("\n")}\n`);
+      lastLines = lines.length;
+    };
+
+    const finish = (result) => {
+      stdin.removeListener("keypress", onKey);
+      clearRender();
+      if (stdin.isTTY) stdin.setRawMode(prevRaw);
+      stdin.removeAllListeners("keypress");
+      for (const listener of savedKeypress) stdin.on("keypress", listener);
+      rl.resume();
+      resolve(result);
+    };
+
+    function onKey(str, key) {
+      if (!key) return;
+      if (key.ctrl && key.name === "c") return finish(null);
+      if (key.name === "escape") return finish(null);
+      if (key.name === "return" || key.name === "enter") return finish(view[index] ?? null);
+      if (key.name === "up") {
+        if (index > 0) index--;
+      } else if (key.name === "down") {
+        if (index < view.length - 1) index++;
+      } else if (key.name === "backspace") {
+        filter = filter.slice(0, -1);
+        refilter();
+      } else if (str && str.length === 1 && !key.ctrl && !key.meta && str >= " ") {
+        filter += str;
+        refilter();
+      } else {
+        return;
+      }
+      if (index < offset) offset = index;
+      if (index >= offset + windowSize) offset = index - windowSize + 1;
+      render();
+    }
+
+    stdin.on("keypress", onKey);
+    render();
+  });
+}
+
+export function pickModel(rl, models, activeId) {
+  const initialIndex = Math.max(0, models.findIndex((model) => model.id === activeId));
+  return runPicker(rl, {
+    items: models,
+    initialIndex,
+    headerLines: [dim("  pick a model — type to filter · ↑/↓ move · enter select · esc cancel")],
+    matchItem: (model, filter) => {
+      const haystack = `${model.name ?? ""} ${model.providerLabel ?? ""} ${model.id}`.toLowerCase();
+      return haystack.includes(filter.toLowerCase());
+    },
+    formatRow: (model, selected, _active) => {
+      const arrow = selected ? bold("›") : " ";
+      const mark = model.id === activeId ? "●" : " ";
+      const name = selected ? bold(model.name ?? model.id) : (model.name ?? model.id);
+      const meta = dim(
+        `${model.providerLabel ?? ""} · $${model.inputUsdPerMillionTokens ?? "?"}/$${model.outputUsdPerMillionTokens ?? "?"} per M`,
+      );
+      return `  ${arrow} ${mark} ${name}  ${meta}`;
+    },
+  });
+}
+
+export function pickSlashCommand(rl, commands) {
+  return runPicker(rl, {
+    items: commands,
+    headerLines: [dim("  pick a command — type to filter · ↑/↓ move · enter select · esc cancel")],
+    matchItem: (entry, filter) => {
+      const haystack = `${entry.cmd} ${entry.help}`.toLowerCase();
+      return haystack.includes(filter.toLowerCase());
+    },
+    formatRow: (entry, selected) => {
+      const arrow = selected ? bold("›") : " ";
+      const cmd = selected ? bold(entry.cmd) : entry.cmd;
+      return `  ${arrow} ${cmd.padEnd(11)} ${dim(entry.help)}`;
+    },
+  });
+}
+
+export function readPromptLine(rl, options) {
+  const {
+    prompt,
+    slashCommands = [],
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    let selectedIndex = 0;
+    let matches = [];
+    let lastLines = 0;
+
+    function visibleSlashMatches() {
+      if (!buffer.startsWith("/") || buffer.includes(" ")) return [];
+      return slashCommandMatches(buffer, slashCommands);
+    }
+
+    function clampSelection() {
+      if (matches.length === 0) {
+        selectedIndex = 0;
+        return;
+      }
+      selectedIndex = Math.max(0, Math.min(selectedIndex, matches.length - 1));
+    }
+
+    function clearRender() {
+      if (lastLines > 0) stdout.write(`\x1b[${lastLines}A\x1b[J`);
+    }
+
+    function render() {
+      matches = visibleSlashMatches();
+      clampSelection();
+
+      clearRender();
+      const suffix = slashCompletionSuffix(buffer);
+      const lines = [`${prompt}${buffer}${suffix ? dim(suffix) : ""}`];
+
+      if (buffer.startsWith("/") && !buffer.includes(" ")) {
+        lines.push(dim("  pick a command - type to filter · ↑/↓ move · tab complete · enter select"));
+        if (matches.length === 0) {
+          lines.push(dim("    no matches"));
+        } else {
+          for (let i = 0; i < matches.length; i++) {
+            const entry = matches[i];
+            const arrow = i === selectedIndex ? bold("›") : " ";
+            const cmd = i === selectedIndex ? bold(entry.cmd) : entry.cmd;
+            lines.push(`  ${arrow} ${cmd.padEnd(11)} ${dim(entry.help)}`);
+          }
+        }
+      }
+
+      stdout.write(`${lines.join("\n")}\n`);
+      lastLines = lines.length;
+    }
+
+    function finish(value) {
+      stdin.removeListener("keypress", onKey);
+      clearRender();
+      if (value !== null) stdout.write(`${prompt}${value}\n`);
+      if (stdin.isTTY) stdin.setRawMode(prevRaw);
+      stdin.removeAllListeners("keypress");
+      for (const listener of savedKeypress) stdin.on("keypress", listener);
+      rl.resume();
+      resolve(value);
+    }
+
+    function acceptSlashSelection() {
+      if (!buffer.startsWith("/") || buffer.includes(" ")) return false;
+      const suffix = slashCompletionSuffix(buffer);
+      if (suffix) {
+        buffer += suffix;
+        return true;
+      }
+      if (matches.length === 0) return false;
+      buffer = matches[selectedIndex]?.cmd ?? buffer;
+      return true;
+    }
+
+    function onKey(str, key) {
+      if (!key) return;
+      if (key.ctrl && key.name === "c") return finish(null);
+      if (key.ctrl && key.name === "d" && buffer.length === 0) return finish(null);
+      if (key.name === "return" || key.name === "enter") {
+        if (acceptSlashSelection()) return finish(buffer);
+        return finish(buffer);
+      }
+      if (key.name === "tab") {
+        const suffix = slashCompletionSuffix(buffer);
+        if (suffix) {
+          buffer += suffix;
+          selectedIndex = 0;
+          return render();
+        }
+        if (acceptSlashSelection()) return render();
+        return;
+      }
+      if (key.name === "escape") {
+        buffer = "";
+        selectedIndex = 0;
+        return render();
+      }
+      if (key.name === "backspace") {
+        buffer = buffer.slice(0, -1);
+        selectedIndex = 0;
+        return render();
+      }
+      if (key.name === "up" && matches.length > 0) {
+        selectedIndex = Math.max(0, selectedIndex - 1);
+        return render();
+      }
+      if (key.name === "down" && matches.length > 0) {
+        selectedIndex = Math.min(matches.length - 1, selectedIndex + 1);
+        return render();
+      }
+      if (str && str.length === 1 && !key.ctrl && !key.meta && str >= " ") {
+        buffer += str;
+        selectedIndex = 0;
+        return render();
+      }
+    }
+
+    rl.pause();
+    const prevRaw = stdin.isRaw;
+    const savedKeypress = stdin.listeners("keypress");
+    stdin.removeAllListeners("keypress");
+    emitKeypressEvents(stdin);
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+
+    try {
+      stdin.on("keypress", onKey);
+      render();
+    } catch (error) {
+      reject(error);
+    }
+  });
+}