aegiscode 5.2.32 → 6.0.0

package/src/app.js

@@ -0,0 +1,543 @@
+'use strict';
+
+/**
+ * The CLI application: session state, the ask/stream path, and the command
+ * dispatcher.
+ *
+ * Split from `bin/aegiscode.js` so the whole app is constructible with injected
+ * IO (`out`, `err`, `readline`) and a stub client — the tests drive real turns,
+ * real streaming and real command dispatch without a TTY and without a child
+ * process. Bin entry = argument parsing and process lifecycle; everything else
+ * lives here.
+ */
+
+const readline = require('node:readline');
+const { createTools, createClient, usageTokens } = require('./deps.js');
+const { GLYPH, VERBS, themeOf, RESET } = require('./theme.js');
+const { LiveRegion, termWidth, EC, w } = require('./screen.js');
+const { parseLine, findCommand, COMMANDS } = require('./commands.js');
+const render = require('./render.js');
+const { fmtTokens, fmtEur, maskKey, fmtElapsed } = require('./format.js');
+
+const VERSION = require('../package.json').version;
+
+function createApp(options = {}) {
+  const opts = {
+    model: null,
+    stream: true,
+    light: false,
+    maxTokens: undefined,
+    system: undefined,
+    interactive: true,
+    ...options,
+  };
+  const out = options.out || process.stdout;
+  const err = options.err || process.stderr;
+  const client = options.client || createClient();
+  const { TOOLS, toolList } = options.tools || createTools(client);
+
+  const ctx = () => ({ light: opts.light });
+  const width = () => (options.width ? options.width() : termWidth());
+
+  const session = {
+    turns: 0,
+    calls: 0,
+    tokens: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cost: 0, // € spent, from ledger rows observed this session
+    balance: null,
+    lastLedgerAt: null,
+    startedAt: Date.now(),
+  };
+
+  let abortController = null;
+  let closed = false;
+
+  // --- helpers --------------------------------------------------------------
+
+  /** Refresh the balance and fold any *new* usage row into the session tally.
+   *  Best-effort: an accounting refresh must never break a turn.
+   *  @returns {Promise<{balance:number, lastCost:number|null}|null>} */
+  async function refreshSpend() {
+    try {
+      const data = await client.tokenBankBalance();
+      session.balance = Number(data.balance_eur || 0);
+      let lastCost = null;
+      const row = (data.ledger || [])[0];
+      if (row && row.kind === 'usage' && row.created_at && row.created_at !== session.lastLedgerAt) {
+        session.lastLedgerAt = row.created_at;
+        // amount_eur is signed from the user's side (negative = spent); the
+        // ledger fallback inverts the raw micros column, which has the
+        // opposite sign.
+        const eur = Math.abs(
+          Number(row.amount_eur != null ? row.amount_eur : -Number(row.charged_micros || 0) / 1e6)
+        );
+        session.cost += eur;
+        lastCost = eur;
+      }
+      return { balance: session.balance, lastCost };
+    } catch {
+      return null; // no balance rights / offline: keep showing tokens
+    }
+  }
+
+  function bannerLines() {
+    return render.renderBanner(ctx(), {
+      width: width(),
+      version: VERSION,
+      model: opts.model || 'server default',
+      base: client.apiBase,
+      key: maskKey(client.apiKey),
+      stream: opts.stream,
+    });
+  }
+
+  /**
+   * Write lines out. Accepts a single line as well as a block — a bare string
+   * would otherwise be iterated as characters, which renders a notice one
+   * character per line.
+   */
+  function emit(lines) {
+    const block = typeof lines === 'string' ? [lines] : lines;
+    for (const l of block) out.write(l + '\n');
+  }
+
+  // --- the ask path ---------------------------------------------------------
+
+  /**
+   * One pooled call, streamed into the live region.
+   * @returns {Promise<{text:string, usage:object|null, model:string|null, ms:number, interrupted:boolean}>}
+   */
+  async function ask(prompt) {
+    const started = Date.now();
+    const live = opts.interactive && opts.stream && out.isTTY ? new LiveRegion(out) : null;
+    let tick = 0;
+    let chars = 0;
+    let partial = '';
+    let reasoning = 0;
+    let verb = VERBS[Math.floor(Math.random() * VERBS.length)];
+    let sawReasoning = false;
+
+    const paint = () => {
+      if (!live) return;
+      live.update([
+        render.renderWorking(ctx(), {
+          tick: tick++,
+          verb,
+          elapsedMs: Date.now() - started,
+          streamed: chars,
+        }),
+      ]);
+    };
+
+    const timer = live ? setInterval(paint, 90) : null;
+    if (timer && timer.unref) timer.unref();
+    paint();
+
+    abortController = new AbortController();
+    let interrupted = false;
+    const onSigint = () => {
+      interrupted = true;
+      if (abortController) abortController.abort();
+    };
+    process.once('SIGINT', onSigint);
+
+    try {
+      const res = await client.chatCompletion({
+        prompt,
+        model: opts.model || undefined,
+        system: opts.system,
+        maxTokens: opts.maxTokens,
+        stream: Boolean(opts.stream),
+        // Ask the server for the token count on the streaming path: an
+        // OpenAI-compatible SSE reply carries no usage unless asked, and this
+        // is the same wire form the desktop sends.
+        includeUsage: Boolean(opts.stream),
+        signal: abortController.signal,
+        onReasoning: (t) => {
+          reasoning += w(t);
+          // The pool's worker findings arrive on the reasoning channel before
+          // the answer; say so rather than looking stalled.
+          if (!sawReasoning) {
+            sawReasoning = true;
+            verb = 'Reasoning';
+          }
+        },
+        onStream: ({ delta, reasoning: r }) => {
+          if (r) reasoning += w(r);
+          if (delta) {
+            chars += w(delta);
+            partial += delta;
+            // Re-paint on every delta but coalesce to ~30fps through the frame
+            // counter — a fast provider otherwise spends the CPU on escapes.
+            if (live && tick % 2 === 0) paint();
+          }
+        },
+      });
+
+      const choice = (res.choices && res.choices[0]) || {};
+      const text = (choice.message && choice.message.content) || partial;
+      return {
+        text,
+        usage: res.usage || null,
+        model: res.model || opts.model || null,
+        ms: Date.now() - started,
+        interrupted,
+        reasoningChars: reasoning,
+      };
+    } catch (e) {
+      // A user interrupt is not a failure: keep what already streamed.
+      if (interrupted && partial) {
+        return {
+          text: partial,
+          usage: null,
+          model: opts.model || null,
+          ms: Date.now() - started,
+          interrupted: true,
+          reasoningChars: reasoning,
+        };
+      }
+      throw e;
+    } finally {
+      if (timer) clearInterval(timer);
+      process.removeListener('SIGINT', onSigint);
+      if (live) live.clear();
+      abortController = null;
+    }
+  }
+
+  /** Print a completed turn: role block, then the accounting line. */
+  function printTurn(turn) {
+    emit(render.renderTurn(ctx(), turn, width()));
+  }
+
+  /** Ask, then account for it. Shared by plain prompts and `/ask`. */
+  async function runPrompt(prompt, { label = 'you' } = {}) {
+    if (!prompt) {
+      emit(render.renderNotice(ctx(), 'warn', 'nothing to ask — give /ask a prompt'));
+      return;
+    }
+    if (!client.apiKey) {
+      emit(
+        render.renderNotice(
+          ctx(),
+          'error',
+          'no AEGIS_API_KEY set — export one (https://aegiscloud.org) or run /byok-set'
+        )
+      );
+      return;
+    }
+
+    printTurn({ role: 'user', text: prompt, label });
+
+    let res;
+    try {
+      res = await ask(prompt);
+    } catch (e) {
+      emit(render.renderTurn(ctx(), { role: 'error', text: e.message }, width()));
+      return;
+    }
+
+    session.turns++;
+    session.calls++;
+
+    const tokens = usageTokens(res.usage);
+    if (tokens != null) {
+      session.tokens += tokens;
+      session.inputTokens += Number(res.usage.input_tokens ?? res.usage.prompt_tokens ?? 0) || 0;
+      session.outputTokens += Number(res.usage.output_tokens ?? res.usage.completion_tokens ?? 0) || 0;
+    }
+
+    const spend = await refreshSpend();
+
+    printTurn({
+      role: 'assistant',
+      text: res.text || '(the pool returned no text — see /balance for what it charged)',
+      meta: {
+        model: res.model,
+        tokens,
+        usage:
+          res.usage == null
+            ? null
+            : {
+                input: res.usage.input_tokens ?? res.usage.prompt_tokens,
+                output: res.usage.output_tokens ?? res.usage.completion_tokens,
+              },
+        // What this call settled at, from the ledger row it produced — the
+        // number that has to agree with the token count beside it.
+        eur: spend && spend.lastCost != null ? spend.lastCost : null,
+        ms: res.ms,
+        calls: 1,
+      },
+    });
+
+    if (res.interrupted) {
+      emit(render.renderNotice(ctx(), 'warn', 'interrupted — the pool may still be running and billing this call'));
+    }
+  }
+
+  // --- command dispatch -----------------------------------------------------
+
+  async function runTool(name, args) {
+    const tool = TOOLS[name];
+    if (!tool) throw new Error(`unknown tool: ${name}`);
+    if (!client.apiKey) {
+      throw new Error('no AEGIS_API_KEY set — export one (https://aegiscloud.org)');
+    }
+    const text = await tool.run(args || {});
+    emit(render.renderToolResult(ctx(), name, text, width()));
+  }
+
+  function printHelp() {
+    emit([render.renderHeading(ctx(), 'commands', width())]);
+    const rows = COMMANDS.map((c) => {
+      const usage = `/${c.name}${c.args ? ' ' + c.args : ''}`;
+      return { usage, help: c.help, aliases: (c.aliases || []).map((a) => `/${a}`).join(' ') };
+    });
+    const widest = rows.reduce((m, r) => Math.max(m, r.usage.length), 0);
+    const t = themeOf(ctx());
+    for (const r of rows) {
+      const alias = r.aliases ? render.fg(t, t.dim) + `  (${r.aliases})` + RESET : '';
+      emit([`  ${render.fg(t, t.plasma)}${'/' + r.usage.slice(1)}` +
+        ' '.repeat(Math.max(1, widest - r.usage.length + 2)) +
+        render.fg(t, t.text) + r.help + RESET + alias]);
+    }
+    emit(['', render.renderNotice(ctx(), 'info', `plain text is a prompt ${GLYPH.bullet} /quit exits`)]);
+  }
+
+  /** Handle one line of input. Returns false when the session should end. */
+  async function handleLine(line) {
+    const parsed = parseLine(line);
+
+    if (parsed.kind === 'empty') return true;
+    if (parsed.kind === 'prompt') {
+      await runPrompt(parsed.text);
+      return true;
+    }
+    if (parsed.kind === 'unknown') {
+      emit(render.renderNotice(ctx(), 'error', `unknown command: /${parsed.name} — try /help`));
+      return true;
+    }
+
+    const cmd = parsed.command;
+    const arg = parsed.arg;
+
+    if (cmd.local) {
+      switch (cmd.local) {
+        case 'quit':
+          return false;
+        case 'clear':
+          out.write(EC.clearScreen);
+          emit(bannerLines());
+          return true;
+        case 'help':
+          printHelp();
+          return true;
+        case 'model':
+          if (!arg) {
+            emit(render.renderNotice(ctx(), 'info', `model: ${opts.model || 'server default'}`));
+          } else if (arg === '-') {
+            opts.model = null;
+            emit(render.renderNotice(ctx(), 'ok', 'model pin cleared — the server will choose'));
+          } else {
+            opts.model = arg;
+            emit(render.renderNotice(ctx(), 'ok', `pinned model: ${arg}`));
+          }
+          return true;
+        case 'stream':
+          opts.stream = arg ? !/^off|false|0$/i.test(arg) : !opts.stream;
+          emit(render.renderNotice(ctx(), 'ok', `streaming ${opts.stream ? 'on' : 'off'}`));
+          return true;
+        case 'theme':
+          opts.light = arg ? /^light/i.test(arg) : !opts.light;
+          emit(render.renderNotice(ctx(), 'ok', `theme: ${opts.light ? 'light' : 'dark'}`));
+          return true;
+        case 'cost': {
+          const t = themeOf(ctx());
+          emit([render.renderHeading(ctx(), 'session', width())]);
+          emit([
+            `  tokens   ${render.fg(t, t.text)}${fmtTokens(session.tokens)}${RESET}  ` +
+              render.fg(t, t.muted) + `(${fmtTokens(session.inputTokens)} in / ${fmtTokens(session.outputTokens)} out)` + RESET,
+            `  spend    ${render.fg(t, t.pulse)}${fmtEur(session.cost)}${RESET}`,
+            `  calls    ${session.calls}`,
+            `  balance  ${session.balance == null ? 'unknown' : fmtEur(session.balance)}`,
+            `  elapsed  ${fmtElapsed(Date.now() - session.startedAt)}`,
+          ]);
+          return true;
+        }
+        default:
+          emit(render.renderNotice(ctx(), 'error', `/${cmd.name} is not implemented`));
+          return true;
+      }
+    }
+
+    if (cmd.generic) {
+      const { tool, args } = cmd.build(arg);
+      if (!tool) {
+        emit(render.renderNotice(ctx(), 'error', '/tool needs a tool name — see /help'));
+        return true;
+      }
+      try {
+        await runTool(tool, args);
+      } catch (e) {
+        emit(render.renderNotice(ctx(), 'error', e.message));
+      }
+      return true;
+    }
+
+    // Tool-backed command.
+    try {
+      let args = cmd.build(arg);
+      if (cmd.secret) {
+        const key = await readSecret(`provider key for ${args.provider}: `);
+        if (!key) {
+          emit(render.renderNotice(ctx(), 'warn', 'empty key — nothing sent'));
+          return true;
+        }
+        args = { ...args, api_key: key };
+      }
+      if (cmd.name === 'ask') return await runPrompt(args.prompt);
+      await runTool(cmd.tool, args);
+    } catch (e) {
+      emit(render.renderNotice(ctx(), 'error', e.message));
+    }
+    return true;
+  }
+
+  /** Read a secret without echoing it (raw mode; falls back to plain input). */
+  function readSecret(promptText) {
+    if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== 'function') {
+      return Promise.resolve('');
+    }
+    return new Promise((resolve) => {
+      const t = themeOf(ctx());
+      out.write(render.fg(t, t.muted) + promptText + RESET);
+      const stdin = process.stdin;
+      let buf = '';
+      stdin.setRawMode(true);
+      stdin.resume();
+      const onData = (chunk) => {
+        for (const ch of chunk.toString('utf8')) {
+          if (ch === '\r' || ch === '\n') {
+            stdin.setRawMode(false);
+            stdin.removeListener('data', onData);
+            out.write('\n');
+            return resolve(buf);
+          }
+          if (ch === '\x03') {
+            // ctrl+c
+            stdin.setRawMode(false);
+            stdin.removeListener('data', onData);
+            out.write('\n');
+            return resolve('');
+          }
+          if (ch === '\u007f') {
+            buf = buf.slice(0, -1);
+            out.write('\b \b');
+            continue;
+          }
+          buf += ch;
+          out.write('•');
+        }
+      };
+      stdin.on('data', onData);
+    });
+  }
+
+  // --- entry points ---------------------------------------------------------
+
+  /** Non-interactive: one prompt, plain output, exit code. */
+  async function runOnce(prompt, { json = false } = {}) {
+    if (!client.apiKey) {
+      err.write('aegiscode: no AEGIS_API_KEY set. Export your key first (https://aegiscloud.org).\n');
+      return 2;
+    }
+    const res = await ask(prompt);
+    await refreshSpend();
+    const tokens = usageTokens(res.usage);
+    if (json) {
+      out.write(
+        JSON.stringify(
+          {
+            text: res.text,
+            model: res.model,
+            usage: res.usage,
+            tokens,
+            ms: res.ms,
+            interrupted: res.interrupted,
+            balance_eur: session.balance,
+          },
+          null,
+          2
+        ) + '\n'
+      );
+    } else {
+      out.write(res.text + '\n');
+      if (tokens != null) {
+        const t = themeOf(ctx());
+        out.write(
+          render.fg(t, t.dim) + GLYPH.spend + ' ' + render.fg(t, t.beam) + (res.model || 'aegis') + RESET +
+            render.fg(t, t.dim) + ' ' + GLYPH.bullet + ' ' + RESET +
+            render.fg(t, t.text) + `${fmtTokens(tokens)} tok` + RESET + '\n'
+        );
+      }
+    }
+    return res.interrupted ? 130 : 0;
+  }
+
+  /** Interactive REPL. */
+  async function runInteractive() {
+    emit(bannerLines());
+    await refreshSpend();
+    out.write('\n');
+
+    const rl = options.readline || readline.createInterface({ input: process.stdin, output: out, terminal: true });
+    const promptStr = render.fg(themeOf(ctx()), themeOf(ctx()).plasma) + GLYPH.prompt + ' ' + RESET;
+    rl.setPrompt(promptStr);
+    rl.prompt();
+
+    return new Promise((resolve) => {
+      rl.on('line', async (line) => {
+        rl.pause();
+        let keep = true;
+        try {
+          keep = await handleLine(line);
+        } catch (e) {
+          emit(render.renderNotice(ctx(), 'error', e.message));
+        }
+        if (!keep) {
+          closed = true;
+          rl.close();
+          return;
+        }
+        rl.resume();
+        rl.prompt();
+      });
+      rl.on('close', () => {
+        if (!closed) out.write('\n');
+        resolve(0);
+      });
+    });
+  }
+
+  return {
+    opts,
+    session,
+    client,
+    TOOLS,
+    toolList,
+    ask,
+    runPrompt,
+    handleLine,
+    runOnce,
+    runInteractive,
+    refreshSpend,
+    bannerLines,
+    get aborted() {
+      return abortController != null;
+    },
+  };
+}
+
+module.exports = { createApp, VERSION };

package/src/art.js

@@ -0,0 +1,45 @@
+'use strict';
+
+/**
+ * AEGIS brand art.
+ *
+ * A hexagonal shield with a signal core — the mark that replaces the mascot
+ * art every Claude Code derivative (including this repo's sibling project
+ * aegiscodex-dev) ships. Same job, different iconography on purpose:
+ * `test/cli-identity.test.mjs` asserts Claude Code's own art never appears here.
+ *
+ * Every row is the same display width (9 cells) so it can be centred or stacked
+ * without drift; `tests` assert that rather than trusting it.
+ *
+ * The wordmark spells the whole product name (`aegiscode`) with the same letter
+ * spacing the shorter `AEGIS` mark used, now that the host and the CLI have been
+ * folded onto one name. `test/cli-identity.test.mjs` strips the spacing and
+ * asserts the mark still names the product.
+ */
+
+const SIGIL = [
+  ' ▄▄▄▄▄▄▄ ',
+  '▟███████▙',
+  '▜███▀███▛',
+  ' ▜█████▛ ',
+  '  ▜███▛  ',
+  '   ▜▛    ',
+];
+
+/** Cell offsets (row, col) of the core, painted in the secondary colour. */
+const CORE = [{ row: 2, col: 4 }];
+
+const WORDMARK = 'A E G I S  C O D E';
+const TAGLINE = 'Cloud brain in your shell.';
+
+/**
+ * Left-pad every row of `art` so it sits centred inside `width`.
+ * @returns {string[]}
+ */
+function center(art, width) {
+  const w = art.reduce((m, r) => Math.max(m, [...r].length), 0);
+  const pad = Math.max(0, Math.floor((width - w) / 2));
+  return art.map((r) => ' '.repeat(pad) + r);
+}
+
+module.exports = { SIGIL, CORE, WORDMARK, TAGLINE, center, SIGIL_WIDTH: 9 };