neagen 0.1.0 → 0.1.2

package/lib/slash.mjs

@@ -0,0 +1,49 @@
+// Slash commands for the neagen TUI — single source for /help and command selection.
+
+export const SLASH_COMMANDS = [
+  { cmd: "/model", help: "pick a model — type to filter, arrows to move, enter to select" },
+  { cmd: "/new", help: "start a fresh conversation" },
+  { cmd: "/help", help: "show commands" },
+  { cmd: "/exit", help: "quit (also /quit, Ctrl-D, Ctrl-C)" },
+];
+
+/** Hidden alias — completable, not listed in /help. */
+export const SLASH_ALIASES = ["/quit"];
+
+export const SLASH_NAMES = [...SLASH_COMMANDS.map((entry) => entry.cmd), ...SLASH_ALIASES];
+
+export function slashQuery(line) {
+  if (!line.startsWith("/") || line.includes(" ")) return null;
+  return line.toLowerCase();
+}
+
+export function slashCommandMatches(line, commands = SLASH_COMMANDS) {
+  const query = slashQuery(line);
+  if (query === null) return [];
+  return commands.filter((entry) => entry.cmd.toLowerCase().startsWith(query));
+}
+
+export function slashCompletionSuffix(line) {
+  const query = slashQuery(line);
+  if (query === null) return "";
+  const hits = SLASH_NAMES.filter((name) => name.toLowerCase().startsWith(query));
+  if (hits.length !== 1) return "";
+  return hits[0].slice(line.length);
+}
+
+/**
+ * readline completer: Tab-completes slash commands on the command word only
+ * (leading "/" with no space yet) so Tab never hijacks normal chat input.
+ */
+export function completeSlash(line) {
+  if (!line.startsWith("/") || line.includes(" ")) return [[], line];
+  const query = line.toLowerCase();
+  const hits = SLASH_NAMES.filter((name) => name.startsWith(query));
+  return [hits, line];
+}
+
+export function slashHelpLines() {
+  const rows = SLASH_COMMANDS.map(({ cmd, help }) => `  ${cmd.padEnd(11)} ${help}`);
+  rows.push("  (type / to open the command selector; Tab accepts the prefill)");
+  return rows;
+}

package/lib/tui.mjs

@@ -1,28 +1,30 @@
-// neagen TUI — chat, agent-mail, files against the deployed agent.
-// Login happens here (device-grant panel) when no valid session exists.
-//
-// Resolves Eve's TUI internals from the INSTALLED `eve` package (via
-// require.resolve), so it works no matter where npm puts the dependency — global
-// install, npx cache, or this repo's node_modules. `eve` is a hard dependency of
-// this package (see ../package.json), pinned to an exact version because these
-// dist paths are internal to that version.
-
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { Client } from "eve/client";
+// neagen CLI — chat through Neagen's server-mediated turn transport.
+// Login happens here (device grant) when no valid session exists.
+
+import readline from "node:readline/promises";
+import { stdin } from "node:process";
+import { dim, bold } from "./ansi.mjs";
 import { assertTransportSafe, clearCreds, loadToken, resolveHost } from "./creds.mjs";
-import { probeHost, resolveIdentity } from "./api.mjs";
+import {
+  getSelectedModel,
+  listModels,
+  probeHost,
+  resolveIdentity,
+  selectModel,
+} from "./api.mjs";
 import { runDeviceGrantLogin } from "./device-login.mjs";
-import { panel } from "./flow.mjs";
+import {
+  formatRequestDetails,
+  requestToolName,
+  sendTransportTurn,
+  sendWakeSyncTurn,
+  summarizeResult,
+} from "./eve-chat.mjs";
+import { createTurnStreamRenderer } from "./turn-stream.mjs";
+import { pickModel, readPromptLine } from "./picker.mjs";
+import { SLASH_COMMANDS, slashHelpLines } from "./slash.mjs";
 import { subscribeInboxWakeAbly } from "./wake.mjs";
 
-const require = createRequire(import.meta.url);
-// `eve` exposes "./package.json" in its exports map, so this resolves the
-// installed package root regardless of hoisting.
-const EVE_DIST = join(dirname(require.resolve("eve/package.json")), "dist", "src");
-const EVE_TUI = join(EVE_DIST, "cli", "dev", "tui");
-
 const profile = process.env.NEAGEN_PROFILE?.trim() || undefined;
 const host = resolveHost();
 
@@ -38,59 +40,21 @@ try {
   process.exit(1);
 }
 
-async function importEve(relPath) {
-  return import(pathToFileURL(join(EVE_DIST, relPath)).href);
-}
-
-const [
-  { EveTUIRunner },
-  { createPromptCommandHandler },
-  { promptCommandsFor },
-  { formatRemoteAuthChallengeMessage },
-  { toErrorMessage },
-  { isVercelAuthChallenge },
-  { TerminalRenderer },
-] = await Promise.all([
-  import(pathToFileURL(join(EVE_TUI, "runner.js")).href),
-  import(pathToFileURL(join(EVE_TUI, "prompt-command-handler.js")).href),
-  import(pathToFileURL(join(EVE_TUI, "prompt-commands.js")).href),
-  import(pathToFileURL(join(EVE_TUI, "remote-auth-result.js")).href),
-  importEve("shared/errors.js"),
-  importEve("services/dev-client/vercel-auth-error.js"),
-  import(pathToFileURL(join(EVE_TUI, "terminal-renderer.js")).href),
-]);
-
-const target = {
-  kind: "remote",
-  serverUrl: host,
-  workspaceRoot: process.cwd(),
-};
-
-const renderer = new TerminalRenderer({ availablePromptCommands: promptCommandsFor("remote") });
-
 function fail(message) {
-  try {
-    panel(renderer).renderLine(message, "error");
-  } catch {
-    console.error(`\n  ${message}\n`);
-  }
+  console.error(`\n  ${message}\n`);
   process.exit(1);
 }
 
 async function ensureReachable() {
-  const ui = panel(renderer);
-  ui.begin("neagen", "pulse");
-  ui.renderLine(`Connecting to ${host}…`, "info");
+  process.stdout.write(`Connecting to ${host}...\n`);
   try {
     await probeHost(host);
-    ui.renderLine("Agent online.", "success");
+    process.stdout.write("Agent online.\n");
   } catch (e) {
-    ui.renderLine(`Can't reach ${host} (${e.message}).`, "error");
-    ui.renderLine("Check your connection, or set NEAGEN_HOST to your server.", "info");
-    ui.end({ preserveDiagnostics: true });
+    process.stderr.write(`Can't reach ${host} (${e.message}).\n`);
+    process.stderr.write("Check your connection, or set NEAGEN_HOST to your server.\n");
     process.exit(1);
   }
-  ui.end({ preserveDiagnostics: false });
 }
 
 async function ensureAuthenticated() {
@@ -101,7 +65,7 @@ async function ensureAuthenticated() {
     clearCreds(profile);
     token = null;
   }
-  token = await runDeviceGrantLogin({ host, profile, renderer });
+  token = await runDeviceGrantLogin({ host, profile });
   const me = await resolveIdentity(host, token);
   if (!me) {
     clearCreds(profile);
@@ -110,6 +74,107 @@ async function ensureAuthenticated() {
   return { token, me };
 }
 
+function formatModel(model) {
+  if (!model) return "unknown";
+  const label = model.providerLabel && model.name ? `${model.providerLabel} ${model.name}` : model.id;
+  return `${label} (${model.id})`;
+}
+
+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;
+}
+
+async function runModelPicker(rl, token) {
+  let selection;
+  let models;
+  try {
+    [selection, models] = await Promise.all([
+      getSelectedModel(host, token),
+      listModels(host, token),
+    ]);
+  } catch (e) {
+    process.stderr.write(`! ${e?.message ?? e}\n`);
+    return;
+  }
+
+  const activeId = selection?.activeModel?.id;
+  const chosen = await pickModel(rl, models, activeId);
+  if (!chosen) {
+    process.stdout.write(`${dim("(no change)")}\n`);
+    return;
+  }
+  if (chosen.id === activeId) {
+    process.stdout.write(`${dim(`already using ${formatModel(chosen)}`)}\n`);
+    return;
+  }
+
+  try {
+    const updated = await selectModel(host, token, chosen.id);
+    process.stdout.write(`Switched model to ${bold(formatModel(updated.activeModel))}.\n`);
+  } catch (e) {
+    process.stderr.write(`! ${e?.message ?? e}\n`);
+  }
+}
+
+async function switchModelByName(token, raw) {
+  const modelId = modelAliases(raw);
+  const selection = await selectModel(host, token, modelId);
+  process.stdout.write(`Switched model to ${bold(formatModel(selection.activeModel))}.\n`);
+}
+
+async function handleModelCommand(rl, token, raw) {
+  const arg = raw.trim();
+  if (!arg) {
+    await runModelPicker(rl, token);
+    return;
+  }
+  await switchModelByName(token, arg);
+}
+
+function printHelp() {
+  process.stdout.write([...slashHelpLines(), ""].join("\n"));
+}
+
+function normalizeSlashInput(input) {
+  if (input === "/quit") return "/exit";
+  return input;
+}
+
+async function askApproval(rl, request) {
+  const tool = requestToolName(request);
+  const details = formatRequestDetails(request);
+  const answer = (await rl.question(
+    `\nApprove ${tool}${details ? ` (${details})` : ""}?\n(y/n) > `,
+  )).trim().toLowerCase();
+  return answer === "y" || answer === "yes";
+}
+
+async function askQuestion(rl, request) {
+  const options = (request.options ?? []).map((option, index) => `${index + 1}. ${option.label}`).join("  ");
+  return rl.question(`\n${request.prompt}\n${options ? `${options}\n` : ""}> `);
+}
+
+const turnRenderer = createTurnStreamRenderer();
+
+function printTurnOutcome(result) {
+  if (result?.assistantTextStreamed) {
+    process.stdout.write("\n");
+    return;
+  }
+  const summary = summarizeResult(result);
+  if (summary && summary !== "(no reply)") {
+    process.stdout.write(`\n${summary}\n\n`);
+  } else {
+    process.stdout.write("\n");
+  }
+}
+
 await ensureReachable();
 
 let session;
@@ -122,27 +187,58 @@ try {
 const { me } = session;
 const label = me.displayName ?? "you";
 const ownerId = me.ownerId;
+const token = session.token;
 
-const client = new Client({
-  host,
-  auth: { bearer: () => loadToken(profile) ?? "" },
-  preserveCompletedSessions: true,
+let conversationId;
+const rl = readline.createInterface({
+  input: stdin,
+  output: process.stdout,
+  historySize: 100,
 });
 
-try {
-  await client.health();
-} catch (e) {
-  fail(`Agent unreachable at ${host} (${e.message}).`);
+let chain = Promise.resolve();
+function runExclusive(fn) {
+  const next = chain.then(fn, fn);
+  chain = next.catch(() => {});
+  return next;
+}
+
+async function sendTurn(message) {
+  const result = await sendTransportTurn({
+    host,
+    token,
+    conversationId,
+    message,
+    render: turnRenderer,
+    handlers: {
+      askApproval: (request) => askApproval(rl, request),
+      askQuestion: (request) => askQuestion(rl, request),
+    },
+  });
+  conversationId = result?.conversationId ?? conversationId;
+  return result;
 }
 
 let wake;
 try {
-  const token = loadToken(profile);
   wake = await subscribeInboxWakeAbly(ownerId, (ev) => {
     const what = ev.kind === "message" ? "a message" : `a file (${ev.filename})`;
-    renderer.renderNotice(
-      `📬 New mail — ${what} arrived. Ask me about it (e.g. "what's new?") to fetch it.`,
-    );
+    process.stdout.write(`\nNew mail: ${what} arrived. Fetching it now...\n`);
+    void runExclusive(async () => {
+      const result = await sendWakeSyncTurn({
+        host,
+        token,
+        event: ev,
+        render: turnRenderer,
+        handlers: {
+          askApproval: (request) => askApproval(rl, request),
+          askQuestion: (request) => askQuestion(rl, request),
+        },
+      });
+      printTurnOutcome(result);
+    }).catch((e) => {
+      process.stderr.write(`! wake sync failed: ${e?.message ?? e}\n`);
+    });
   }, { host, bearerToken: token });
 } catch {
   /* wake is best-effort */
@@ -158,16 +254,58 @@ const stopWake = async () => {
 process.on("SIGINT", stopWake);
 process.on("exit", () => void wake?.close());
 
-await new EveTUIRunner({
-  name: `neagen (${label})`,
-  session: client.session(),
-  client,
-  serverUrl: host,
-  renderer,
-  promptCommandHandler: createPromptCommandHandler({ target }),
-  availablePromptCommands: promptCommandsFor("remote"),
-  formatTransportError: (error) =>
-    isVercelAuthChallenge(error) ? formatRemoteAuthChallengeMessage(host) : toErrorMessage(error),
-}).run();
+process.stdout.write(`neagen (${label})\n`);
+process.stdout.write("Type a message, / for commands, /model to switch models, /help for the list.\n\n");
+
+async function handleSlash(rl, input) {
+  const normalized = normalizeSlashInput(input);
+
+  if (normalized === "/exit") return true;
+  if (normalized === "/help") {
+    printHelp();
+    return false;
+  }
+  if (normalized === "/new") {
+    conversationId = undefined;
+    process.stdout.write("Started a new conversation.\n");
+    return false;
+  }
+  if (normalized === "/model" || normalized.startsWith("/model ")) {
+    await handleModelCommand(rl, token, normalized.slice("/model".length));
+    return false;
+  }
+
+  process.stdout.write(`${dim(`unknown command: ${input} (try /help)`)}\n`);
+  return false;
+}
+
+try {
+  for (;;) {
+    let line;
+    try {
+      line = await readPromptLine(rl, { prompt: "neagen> ", slashCommands: SLASH_COMMANDS });
+    } catch {
+      break;
+    }
+    if (line === null) break;
+
+    const input = line.trim();
+    if (!input) continue;
+
+    try {
+      if (input.startsWith("/")) {
+        if (await handleSlash(rl, input)) break;
+        continue;
+      }
+
+      const result = await runExclusive(() => sendTurn(line));
+      printTurnOutcome(result);
+    } catch (e) {
+      process.stderr.write(`! ${e?.message ?? e}\n`);
+    }
+  }
+} finally {
+  rl.close();
+}
 
 await stopWake();

package/lib/turn-stream.mjs

@@ -0,0 +1,219 @@
+import { clearLine, cursorTo } from "node:readline";
+import { stdout } from "node:process";
+import { dim } from "./ansi.mjs";
+
+function sseEvent(event, data) {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+export function parseSseChunk(buffer) {
+  const events = [];
+  const parts = buffer.split(/\n\n+/);
+  const trailing = parts.pop() ?? "";
+
+  for (const part of parts) {
+    const event = part.match(/^event: (.+)$/m)?.[1];
+    const dataLine = part.match(/^data: (.+)$/m)?.[1];
+    if (!event || !dataLine) continue;
+    try {
+      events.push({ event, data: JSON.parse(dataLine) });
+    } catch {
+      /* ignore malformed chunks */
+    }
+  }
+
+  return { events, trailing };
+}
+
+function readReasoningDelta(data) {
+  if (typeof data?.reasoningDelta === "string") return data.reasoningDelta;
+  if (typeof data?.delta === "string") return data.delta;
+  return "";
+}
+
+function readMessageDelta(data) {
+  if (typeof data?.messageDelta === "string") return data.messageDelta;
+  if (typeof data?.delta === "string") return data.delta;
+  return "";
+}
+
+export function createTurnStreamRenderer({ write = (text) => stdout.write(text) } = {}) {
+  let assistantLineOpen = false;
+  let reasoningLineOpen = false;
+  let assistantTextStreamed = false;
+
+  const closeAssistantLine = () => {
+    if (!assistantLineOpen) return;
+    write("\n");
+    assistantLineOpen = false;
+  };
+
+  const closeReasoningLine = () => {
+    if (!reasoningLineOpen) return;
+    write("\n");
+    reasoningLineOpen = false;
+  };
+
+  return {
+    get assistantTextStreamed() {
+      return assistantTextStreamed;
+    },
+    reset() {
+      assistantTextStreamed = false;
+      closeAssistantLine();
+      closeReasoningLine();
+    },
+    handle(eventName, data) {
+      switch (eventName) {
+        case "turn.started":
+          closeAssistantLine();
+          closeReasoningLine();
+          break;
+        case "reasoning.appended": {
+          const delta = readReasoningDelta(data);
+          if (!delta) break;
+          if (!reasoningLineOpen) {
+            closeAssistantLine();
+            write(`${dim("… ")}`);
+            reasoningLineOpen = true;
+          }
+          write(dim(delta));
+          break;
+        }
+        case "reasoning.completed":
+          closeReasoningLine();
+          break;
+        case "message.appended": {
+          const delta = readMessageDelta(data);
+          if (!delta) break;
+          assistantTextStreamed = true;
+          closeReasoningLine();
+          if (!assistantLineOpen) {
+            write("\n");
+            assistantLineOpen = true;
+          }
+          write(delta);
+          break;
+        }
+        case "message.completed":
+          closeAssistantLine();
+          break;
+        case "actions.requested": {
+          closeAssistantLine();
+          closeReasoningLine();
+          const actions = Array.isArray(data?.actions) ? data.actions : [];
+          const labels = actions.map((action) => {
+            if (action?.kind === "tool-call" && typeof action.toolName === "string") {
+              return action.toolName;
+            }
+            return action?.kind ?? "action";
+          });
+          if (labels.length > 0) {
+            write(`${dim(`↳ ${labels.join(", ")}`)}\n`);
+          }
+          break;
+        }
+        case "action.result": {
+          const result = data?.result;
+          const name = result?.toolName ?? result?.kind ?? "tool";
+          const status = data?.status ?? "completed";
+          write(`${dim(`  ${status === "completed" ? "✓" : "×"} ${name}`)}\n`);
+          break;
+        }
+        case "input.requested":
+          closeAssistantLine();
+          closeReasoningLine();
+          write(`${dim("… approval required")}\n`);
+          break;
+        case "neagen.waiting_saved":
+          closeAssistantLine();
+          closeReasoningLine();
+          break;
+        case "neagen.error":
+          closeAssistantLine();
+          closeReasoningLine();
+          write(`\n! ${data?.message ?? "Turn failed."}\n`);
+          break;
+        default:
+          break;
+      }
+    },
+    finish() {
+      closeAssistantLine();
+      closeReasoningLine();
+    },
+  };
+}
+
+export function createTurnStatusSpinner(label = "thinking") {
+  if (!stdout.isTTY) return { stop() {} };
+
+  let frame = 0;
+  let active = true;
+  const frames = ["", ".", "..", "..."];
+  const render = () => {
+    if (!active) return;
+    cursorTo(stdout, 0);
+    stdout.write(`${label}${frames[frame % frames.length]}`);
+    clearLine(stdout, 1);
+    frame += 1;
+  };
+
+  render();
+  const timer = setInterval(render, 450);
+  return {
+    stop() {
+      if (!active) return;
+      active = false;
+      clearInterval(timer);
+      cursorTo(stdout, 0);
+      clearLine(stdout, 0);
+    },
+  };
+}
+
+export async function readTurnSseStream(response, onEvent) {
+  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 = "";
+  const collected = [];
+
+  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) {
+      collected.push(entry);
+      await onEvent?.(entry.event, entry.data);
+    }
+  }
+
+  if (buffer.trim()) {
+    const parsed = parseSseChunk(`${buffer}\n\n`);
+    for (const entry of parsed.events) {
+      collected.push(entry);
+      await onEvent?.(entry.event, entry.data);
+    }
+  }
+
+  return collected;
+}
+
+export { sseEvent };

package/neagen.mjs

@@ -62,8 +62,8 @@ async function runTui(profile) {
     );
     process.exit(1);
   }
-  if (profile) process.env.NEAGEN_PROFILE = profile;
-  await import("./lib/tui.mjs");
+  const { runProductTui } = await import("./lib/eve-product-tui.mjs");
+  await runProductTui({ profile });
 }
 
 async function runLogin(profile) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neagen",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Your personal networking agent, in the terminal. Chat, agent-mail, and files against your Neagen — passkey login, no passwords.",
   "type": "module",
   "bin": {