aegiscode 5.2.32 → 6.0.0

package/src/commands.js

@@ -0,0 +1,163 @@
+'use strict';
+
+/**
+ * Slash commands — the CLI's face on the shared tool registry.
+ *
+ * Every command that talks to AEGIS names a tool from `mcp/tools.js`, and
+ * `test/cli-tools.test.mjs` asserts both directions: no command points at a
+ * tool that does not exist, and no tool is unreachable from the prompt. A new
+ * capability added to the registry therefore shows up here or fails the build,
+ * which is the failure mode we want (the alternative is a capability that
+ * exists in the MCP host and is invisible in the terminal).
+ *
+ * Plain text (no leading `/`) is a prompt: it goes to the pooled brain.
+ */
+
+const COMMANDS = [
+  {
+    name: 'ask',
+    args: '<prompt>',
+    help: 'Send a prompt to the AEGIS pool (same as typing it plainly).',
+    tool: 'aegis_ask',
+    build: (arg) => ({ prompt: arg }),
+  },
+  {
+    name: 'status',
+    help: 'Validate the API key; show plan, account and memory state.',
+    tool: 'aegis_status',
+    build: () => ({}),
+  },
+  {
+    name: 'models',
+    aliases: ['model-list'],
+    help: 'List the model ids you can pin with /model.',
+    tool: 'aegis_list_models',
+    build: () => ({}),
+  },
+  {
+    name: 'balance',
+    aliases: ['spend'], // not `cost` — that name is the local session tally below
+    help: 'Token-bank balance and recent spend (tokens beside €).',
+    tool: 'aegis_balance',
+    build: () => ({}),
+  },
+  {
+    name: 'recall',
+    args: '<query>',
+    help: 'Search your AEGIS cloud memory.',
+    tool: 'aegis_memory_search',
+    build: (arg) => ({ query: arg }),
+  },
+  {
+    name: 'remember',
+    args: '<text>',
+    help: 'Save a durable note to cloud memory.',
+    tool: 'aegis_memory_save',
+    build: (arg) => ({ content: arg }),
+  },
+  {
+    name: 'memory',
+    aliases: ['memories'],
+    help: 'List the most recent cloud-memory entries.',
+    tool: 'aegis_memory_list',
+    build: () => ({}),
+  },
+  {
+    name: 'import',
+    args: '[--confirm]',
+    help: 'Import memory from other tools on this machine (dry run unless --confirm).',
+    tool: 'aegis_memory_import',
+    build: (arg) => ({ confirm: /--confirm\b/.test(arg) }),
+  },
+  {
+    name: 'byok',
+    help: 'Show which providers have your own key configured.',
+    tool: 'aegis_byok_status',
+    build: () => ({}),
+  },
+  {
+    name: 'byok-set',
+    args: '<provider>',
+    help: 'Set YOUR provider key (prompted, never echoed, never in history).',
+    tool: 'aegis_byok_set',
+    secret: 'key',
+    build: (arg) => ({ provider: arg.trim() }),
+  },
+  {
+    name: 'byok-rm',
+    args: '<provider>',
+    help: 'Remove a stored provider key.',
+    tool: 'aegis_byok_set',
+    build: (arg) => ({ provider: arg.trim() }),
+  },
+  {
+    name: 'tool',
+    args: '<name> [json]',
+    help: 'Call any registry tool directly (escape hatch for new tools).',
+    generic: true,
+    build: (arg) => {
+      const sp = arg.indexOf(' ');
+      const name = (sp === -1 ? arg : arg.slice(0, sp)).trim();
+      const rest = sp === -1 ? '' : arg.slice(sp + 1).trim();
+      let args = {};
+      if (rest) {
+        try {
+          args = JSON.parse(rest);
+        } catch (err) {
+          throw new Error(`/tool: arguments must be JSON — ${err.message}`);
+        }
+      }
+      return { tool: name, args };
+    },
+  },
+
+  // --- local commands: no server call, handled by app.js --------------------
+  {
+    name: 'model',
+    args: '[id]',
+    help: 'Pin a model id (no argument shows the current pin and clears it with `-`).',
+    local: 'model',
+  },
+  { name: 'stream', args: '[on|off]', help: 'Toggle streaming output.', local: 'stream' },
+  { name: 'theme', args: '[dark|light]', help: 'Switch the colour theme.', local: 'theme' },
+  { name: 'cost', aliases: ['usage'], help: 'This session: tokens, spend and call count.', local: 'cost' },
+  { name: 'clear', aliases: ['cls'], help: 'Clear the screen.', local: 'clear' },
+  { name: 'help', aliases: ['?', 'h'], help: 'Show this list.', local: 'help' },
+  { name: 'quit', aliases: ['exit', 'q'], help: 'Exit.', local: 'quit' },
+];
+
+const BY_NAME = new Map();
+for (const c of COMMANDS) {
+  BY_NAME.set(c.name, c);
+  for (const a of c.aliases || []) BY_NAME.set(a, c);
+}
+
+function findCommand(name) {
+  return BY_NAME.get(String(name || '').toLowerCase()) || null;
+}
+
+/**
+ * Classify one input line.
+ * @returns {{kind:'empty'}|{kind:'command',command:object,arg:string}|{kind:'prompt',text:string}}
+ */
+function parseLine(line) {
+  const raw = String(line == null ? '' : line);
+  const trimmed = raw.trim();
+  if (!trimmed) return { kind: 'empty' };
+  if (trimmed[0] !== '/') return { kind: 'prompt', text: trimmed };
+  const sp = trimmed.indexOf(' ');
+  const name = (sp === -1 ? trimmed.slice(1) : trimmed.slice(1, sp)).trim();
+  const arg = sp === -1 ? '' : trimmed.slice(sp + 1).trim();
+  const command = findCommand(name);
+  if (!command) {
+    return { kind: 'unknown', name, text: trimmed };
+  }
+  return { kind: 'command', command, arg };
+}
+
+/** Commands that map to a registry tool, for the coverage test. */
+function toolBackedCommands() {
+  return COMMANDS.filter((c) => c.tool);
+}
+
+module.exports = { COMMANDS, findCommand, parseLine, toolBackedCommands };

package/src/deps.js

@@ -0,0 +1,65 @@
+'use strict';
+
+/**
+ * Where the CLI finds the modules it shares with the rest of the repo.
+ *
+ * Two layouts must work:
+ *
+ *   in-repo   <repo>/cli/src/deps.js   -> <repo>/client/aegis.js, <repo>/mcp/tools.js
+ *   npm       <pkg>/src/deps.js        -> <pkg>/vendor/{client,mcp,desktop}/...
+ *
+ * The published package is staged by `scripts/predist.mjs` into `cli/vendor/`
+ * keeping the repo's own relative shape, so nothing here (or in the copied
+ * files) needs a path rewrite — `vendor/mcp/tools.js` requiring
+ * `../client/foreign-memory.js` resolves inside the vendor tree by construction.
+ *
+ * Resolution is by existence, and a missing module is a loud error rather than
+ * a silent fallback to a second copy: duplicate transports are how the two
+ * hosts would drift.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function roots() {
+  const srcDir = __dirname; // <root>/cli/src
+  const cliDir = path.join(srcDir, '..');
+  return [
+    path.join(srcDir, '..', '..'), // repo root (in-repo layout)
+    path.join(cliDir, 'vendor'), // staged tree (published layout)
+  ];
+}
+
+/** Resolve a repo-relative module path against whichever root has it. */
+function resolveShared(relPath) {
+  for (const root of roots()) {
+    const candidate = path.join(root, relPath);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  throw new Error(
+    `aegiscode: cannot find ${relPath}. Expected it beside cli/ (in the repo) or ` +
+      'under cli/vendor/ (installed package). Reinstall the package, or run ' +
+      '`node scripts/predist.mjs` from cli/ if this is a source checkout.'
+  );
+}
+
+const clientPath = resolveShared(path.join('client', 'aegis.js'));
+const toolsPath = resolveShared(path.join('mcp', 'tools.js'));
+// The desktop's pure usage module is the single source of truth for turning a
+// provider's usage object into a display number. The CLI reuses the same file
+// instead of re-implementing the mapping, so the terminal and the GUI can never
+// disagree about what a call consumed (test/cli-tools.test.mjs asserts the
+// function identity).
+const usagePath = resolveShared(path.join('desktop', 'renderer', 'usage.js'));
+
+const { createClient } = require(clientPath);
+const { createTools } = require(toolsPath);
+const { usageTokens } = require(usagePath);
+
+module.exports = {
+  createClient,
+  createTools,
+  usageTokens,
+  paths: { client: clientPath, tools: toolsPath, usage: usagePath },
+  roots,
+};

package/src/format.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * Number/text formatting for the CLI — one place, so the transcript, the status
+ * bar and the headless `--print` output always agree.
+ *
+ * The sub-cent rule mirrors the server-side ledger: AEGIS pooled calls settle
+ * around €0.0007, so a 2dp rendering shows a real charge as "€0.00" next to its
+ * token count and reads as free usage.
+ */
+
+/** Group digits: 1562 -> "1,562". */
+function fmtTokens(n) {
+  const v = Number(n);
+  if (!Number.isFinite(v) || v <= 0) return '0';
+  return Math.round(v)
+    .toString()
+    .replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+
+/** € amount, 4dp below a cent (per-call spend) and 2dp above it (top-ups). */
+function fmtEur(n) {
+  const v = Number(n);
+  if (!Number.isFinite(v)) return '€?';
+  const abs = Math.abs(v);
+  return `€${abs < 0.01 ? abs.toFixed(4) : abs.toFixed(2)}`;
+}
+
+/** Signed € amount, from the user's side: -€0.0007 spent, +€5.00 added. */
+function fmtEurSigned(n) {
+  const v = Number(n);
+  if (!Number.isFinite(v)) return '€?';
+  return `${v < 0 ? '-' : '+'}${fmtEur(Math.abs(v))}`;
+}
+
+/** Compact duration: 850 -> "0.9s", 65000 -> "1m05s". */
+function fmtElapsed(ms) {
+  const s = Math.max(0, Number(ms) || 0) / 1000;
+  if (s < 10) return `${s.toFixed(1)}s`;
+  if (s < 60) return `${Math.round(s)}s`;
+  const m = Math.floor(s / 60);
+  const rest = Math.round(s - m * 60);
+  return `${m}m${String(rest).padStart(2, '0')}s`;
+}
+
+/** Mask an API key for display: never echo enough to be useful if leaked. */
+function maskKey(key) {
+  const s = String(key || '');
+  if (!s) return 'not set';
+  if (s.length <= 8) return '•'.repeat(s.length);
+  return `${s.slice(0, 6)}${'•'.repeat(4)}${s.slice(-4)}`;
+}
+
+module.exports = { fmtTokens, fmtEur, fmtEurSigned, fmtElapsed, maskKey };

package/src/render.js

@@ -0,0 +1,281 @@
+'use strict';
+
+/**
+ * The CLI's renderers: banner, transcript turns, per-turn meta line, status bar,
+ * and the markdown-lite body treatment.
+ *
+ * Every function returns an array of lines (strings with SGR escapes) rather
+ * than writing to stdout, so the whole surface is assertable from a plain Node
+ * test with no TTY and no child process — the same split the desktop uses for
+ * its pure renderer modules.
+ */
+
+const { RGB, BG, RESET, BOLD, DIM, ITALIC, UNDER, RESET_FG, RESET_BG, GLYPH, themeOf } = require('./theme.js');
+const { SIGIL, CORE, WORDMARK, TAGLINE, center } = require('./art.js');
+const { w, pad, padStart, wrapBlock, clip } = require('./screen.js');
+const { fmtTokens, fmtEur, fmtElapsed } = require('./format.js');
+
+const fg = (t, c) => `${RGB(...c)}`;
+const bg = (c) => BG(...c);
+
+/**
+ * The start-up banner: sigil art, wordmark, tagline and a heavy-ruled identity
+ * box (heavy corners, never rounded — the rounded frame is the Claude Code
+ * look this CLI exists to not be).
+ */
+function renderBanner(ctx, info = {}) {
+  const t = themeOf(ctx);
+  const width = Number(info.width) || 80;
+  const lines = [];
+
+  if (width >= 34) {
+    const artRows = center(SIGIL, width);
+    for (const [i, row] of artRows.entries()) {
+      // `center()` only ever left-pads with spaces, so the offset is the width
+      // the core cell moved by; shift the core columns to match.
+      const offset = row.length - SIGIL[i].length;
+      const coreCols = CORE.filter((c) => c.row === i).map((c) => c.col + offset);
+      if (!coreCols.length) {
+        lines.push(fg(t, t.plasma) + row + RESET);
+        continue;
+      }
+      // Paint the core cell in the secondary colour so the mark reads as a
+      // signal rather than a solid block.
+      let painted = '';
+      [...row].forEach((ch, c) => {
+        painted += coreCols.includes(c) ? fg(t, t.beam) + ch + fg(t, t.plasma) : ch;
+      });
+      lines.push(fg(t, t.plasma) + painted + RESET);
+    }
+    lines.push('');
+    lines.push(' '.repeat(Math.max(0, Math.floor((width - w(WORDMARK)) / 2))) + fg(t, t.plasma) + BOLD + WORDMARK + RESET);
+    lines.push(' '.repeat(Math.max(0, Math.floor((width - w(TAGLINE)) / 2))) + fg(t, t.muted) + TAGLINE + RESET);
+    lines.push('');
+  }
+
+  lines.push(...renderIdentityBox(ctx, info, width));
+  return lines;
+}
+
+/** The `┏━ aegiscode ━┓` identity panel: what you are talking to, and as what. */
+function renderIdentityBox(ctx, info, width) {
+  const t = themeOf(ctx);
+  const boxW = Math.max(24, Math.min(width, 64));
+  const inner = boxW - 2;
+
+  const rows = [
+    ['version', info.version ? `v${info.version}` : null],
+    ['model', info.model || 'server default'],
+    ['base', info.base || ''],
+    ['key', info.key || 'not set'],
+    ['render', info.stream === false ? 'buffered' : 'streaming'],
+  ].filter(([, v]) => v);
+
+  const title = ' aegiscode ';
+  const headFill = Math.max(0, inner - w(title) - 1);
+  const out = [
+    fg(t, t.plasma) + GLYPH.box.tl + GLYPH.box.h + BOLD + title + RESET + fg(t, t.plasma) + GLYPH.box.h.repeat(headFill) + GLYPH.box.tr + RESET,
+  ];
+  for (const [k, v] of rows) {
+    const label = fg(t, t.muted) + k.padEnd(8) + RESET;
+    // Row budget: 1 border + 1 space + 8 label + 1 space + value + fill + 1 space
+    // + 1 border = boxW, so the value gets `inner - 11` cells.
+    const value = clip(String(v), Math.max(0, inner - 11));
+    out.push(
+      fg(t, t.plasma) + GLYPH.box.v + RESET + ' ' + label + ' ' + fg(t, t.text) + value + RESET +
+        ' '.repeat(Math.max(0, inner - 11 - w(value))) + ' ' + fg(t, t.plasma) + GLYPH.box.v + RESET
+    );
+  }
+  out.push(fg(t, t.plasma) + GLYPH.box.bl + GLYPH.box.h.repeat(inner) + GLYPH.box.br + RESET);
+  // Clip the hint as plain text *before* styling — clipping an already-styled
+  // line would cut through an escape sequence and bleed colour.
+  const hint = clip(` type /help for commands ${GLYPH.bullet} /quit to exit`, width);
+  out.push(fg(t, t.dim) + hint + RESET);
+  return out;
+}
+
+/** Markdown-lite body: fenced code, bullets, headings, inline code/bold. */
+function mdLines(text, width, ctx) {
+  const t = themeOf(ctx);
+  const out = [];
+  let inFence = false;
+  const bodyW = Math.max(20, width - 4);
+
+  for (const raw of String(text == null ? '' : text).split('\n')) {
+    const fence = /^\s*```/.test(raw);
+    if (fence) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) {
+      for (const l of wrapBlock(raw, bodyW)) out.push(fg(t, t.beam) + '  ' + l + RESET);
+      continue;
+    }
+    if (raw.trim() === '') {
+      out.push('');
+      continue;
+    }
+    const bullet = /^(\s*)[-*]\s+(.*)$/.exec(raw);
+    if (bullet) {
+      const indent = ' '.repeat(Math.min(6, bullet[1].length));
+      for (const l of wrapBlock(inline(bullet[2], ctx), bodyW - 2)) {
+        out.push(`${indent}${fg(t, t.dim)}${GLYPH.bullet}${RESET} ${l}`);
+      }
+      continue;
+    }
+    const heading = /^(#{1,6})\s+(.*)$/.exec(raw);
+    if (heading) {
+      out.push(fg(t, t.plasma) + BOLD + inline(heading[2], ctx) + RESET);
+      continue;
+    }
+    for (const l of wrapBlock(inline(raw, ctx), bodyW, '')) out.push(l);
+  }
+  return out;
+}
+
+/** Inline span treatment: `code` in beam, **bold** in bold. */
+function inline(text, ctx) {
+  const t = themeOf(ctx);
+  return String(text)
+    .replace(/`([^`]+)`/g, (_, code) => fg(t, t.beam) + code + RESET)
+    .replace(/\*\*([^*]+)\*\*/g, (_, bold) => BOLD + bold + RESET);
+}
+
+/**
+ * One transcript turn. Roles get a heavy gutter (┃) and their own sigil, so a
+ * turn is scannable without the boxed-bubble or `>`-prefix look.
+ */
+function renderTurn(ctx, turn, width = 80) {
+  const t = themeOf(ctx);
+  const role = turn.role || 'assistant';
+  const rail = fg(t, t.dim) + GLYPH.rail + RESET;
+  const lines = [];
+
+  const head = {
+    user: { mark: GLYPH.prompt, label: 'you', colour: t.text },
+    assistant: { mark: GLYPH.sigil, label: 'aegis', colour: t.plasma },
+    tool: { mark: GLYPH.pointer, label: turn.label || 'tool', colour: t.beam },
+    system: { mark: GLYPH.warn, label: 'aegis', colour: t.muted },
+    error: { mark: GLYPH.err, label: 'error', colour: t.fault },
+  }[role] || { mark: GLYPH.bullet, label: role, colour: t.muted };
+
+  lines.push(`${rail}${fg(t, head.colour)}${head.mark} ${BOLD}${head.label}${RESET}`);
+
+  const body = role === 'assistant' || role === 'system' ? mdLines(turn.text, width - 2, ctx) : wrapBlock(turn.text, width - 4);
+  for (const l of body) lines.push(`${rail} ${l}`);
+
+  if (turn.meta) lines.push(renderMeta(ctx, turn.meta, width));
+  return lines;
+}
+
+/**
+ * The per-turn accounting line — tokens consumed beside what they cost, which
+ * is the readout this whole surface exists to make possible.
+ */
+function renderMeta(ctx, meta, width = 80) {
+  const t = themeOf(ctx);
+  const bits = [];
+  if (meta.model) bits.push(fg(t, t.beam) + meta.model + RESET);
+  const tokens = meta.tokens == null ? null : `${fmtTokens(meta.tokens)} tok`;
+  if (tokens) bits.push(fg(t, t.text) + tokens + RESET);
+  if (meta.usage) {
+    const { input, output } = meta.usage;
+    if (Number.isFinite(input) || Number.isFinite(output)) {
+      bits.push(fg(t, t.muted) + `${fmtTokens(input || 0)}/${fmtTokens(output || 0)}` + RESET);
+    }
+  }
+  if (meta.eur != null) bits.push(fg(t, meta.eur > 0 ? t.alert : t.pulse) + fmtEur(meta.eur) + RESET);
+  if (meta.ms != null) bits.push(fg(t, t.muted) + fmtElapsed(meta.ms) + RESET);
+  if (meta.calls > 1) bits.push(fg(t, t.muted) + `${meta.calls} calls` + RESET);
+  if (!bits.length) return '';
+  return `${fg(t, t.dim)}${GLYPH.railEnd}${GLYPH.divider} ${RESET}${GLYPH.spend} ${bits.join(fg(t, t.dim) + ' ' + GLYPH.bullet + ' ' + RESET)}`;
+}
+
+/**
+ * The bottom bar: a full-width inverted strip. Segments are packed left and the
+ * hint is right-aligned; the bar is clipped (never wrapped) so a narrow
+ * terminal degrades instead of corrupting the transcript.
+ */
+function renderStatus(ctx, state = {}, width = 80) {
+  const t = themeOf(ctx);
+  const left = [];
+  left.push(`${GLYPH.sigil} aegis`);
+  if (state.model) left.push(state.model);
+  if (state.tokens != null) left.push(`${fmtTokens(state.tokens)} tok`);
+  if (state.spend != null) left.push(fmtEur(state.spend));
+  if (state.mode) left.push(state.mode);
+
+  const right = state.hint || 'ctrl+c quit';
+  const body = ` ${left.join('  ' + GLYPH.bullet + ' ')} `;
+  const gap = width - w(body) - w(right) - 1;
+  // Always exactly `width` cells: the bar is a background, so a short line
+  // would leave the terminal's own background showing through the strip.
+  const content = gap > 0 ? body + ' '.repeat(gap) + right + ' ' : clip(body, width);
+  return bg(t.ink) + fg(t, t.plasma) + pad(content, width) + RESET + RESET_BG;
+}
+
+/** The working line (drawn in the live region, then replaced by the turn). */
+function renderWorking(ctx, state = {}) {
+  const t = themeOf(ctx);
+  const frame = GLYPH.spin[Math.floor((state.tick || 0)) % GLYPH.spin.length];
+  const verb = state.verb || 'Working';
+  const tail = [];
+  if (state.elapsedMs != null) tail.push(fmtElapsed(state.elapsedMs));
+  if (state.streamed) tail.push(`${fmtTokens(state.streamed)} char`);
+  return (
+    fg(t, t.plasma) + frame + RESET + ' ' + fg(t, t.text) + verb + RESET +
+    fg(t, t.muted) + '…' + (tail.length ? ` ${tail.join(' ' + GLYPH.bullet + ' ')}` : '') + RESET +
+    fg(t, t.dim) + '  esc to interrupt' + RESET
+  );
+}
+
+/** A ruled section header used by command output (`/balance`, `/models`). */
+function renderHeading(ctx, text, width = 80) {
+  const t = themeOf(ctx);
+  const label = ` ${text} `;
+  const fill = Math.max(0, width - w(label) - 2);
+  const left = Math.floor(fill / 2);
+  return (
+    fg(t, t.dim) + GLYPH.rule.repeat(left) + RESET + fg(t, t.plasma) + BOLD + label + RESET +
+    fg(t, t.dim) + GLYPH.rule.repeat(fill - left) + RESET
+  );
+}
+
+/** Render a tool result body: heading + indented lines, no role gutter. */
+function renderToolResult(ctx, name, text, width = 80) {
+  const t = themeOf(ctx);
+  const lines = [renderHeading(ctx, name, width)];
+  for (const l of wrapBlock(String(text == null ? '' : text), width - 2)) {
+    lines.push('  ' + (l ? fg(t, t.text) + l + RESET : ''));
+  }
+  return lines;
+}
+
+/** The transient "you didn't finish a stream" note. */
+function renderNotice(ctx, kind, text) {
+  const t = themeOf(ctx);
+  const colour = kind === 'error' ? t.fault : kind === 'warn' ? t.alert : t.muted;
+  const mark = kind === 'error' ? GLYPH.err : kind === 'warn' ? GLYPH.warn : GLYPH.ok;
+  return fg(t, colour) + `${mark} ${text}` + RESET;
+}
+
+module.exports = {
+  renderBanner,
+  renderIdentityBox,
+  renderTurn,
+  renderMeta,
+  renderStatus,
+  renderWorking,
+  renderHeading,
+  renderToolResult,
+  renderNotice,
+  mdLines,
+  inline,
+  fg,
+  bg,
+  UNDER,
+  ITALIC,
+  RESET_FG,
+  pad,
+  padStart,
+};