@bahulam/code 2.6.0

package/src/ui/palette.mjs

@@ -0,0 +1,189 @@
+/**
+ * Kepler palette — semantic color tokens for the CLI.
+ *
+ * Every feature module imports from here, never from raw ANSI. Tokens resolve
+ * at call time so changing terminal capabilities (resize, `refresh()`) is
+ * picked up without restarting the process.
+ *
+ *   import { paint } from './palette.mjs';
+ *   process.stdout.write(paint.brand.primary('KEPLER'));
+ *
+ * Composition (multiple styles on one string):
+ *
+ *   paint.bold(paint.brand.primary('KEPLER'))
+ *
+ * Tier behavior:
+ *   truecolor → 24-bit RGB
+ *   ansi256   → nearest 256-color index
+ *   ansi16    → nearest basic color
+ *   none      → identity (input returned unchanged)
+ *
+ * Brand identity (Mission Control PRD-055):
+ *   primary  Deep Space Purple  #7c3aed
+ *   accent   Stellar Magenta    #ec4899
+ *   data     Neon Cyan          #22d3ee
+ *   success  Aligned green      #22c55e
+ *   warn     Soft amber         #eab308
+ *   danger   Failure red        #ef4444
+ *   dim      Sub-agent / hint   #6b7280
+ *   text     Primary text       #c9d1d9
+ */
+
+import { term } from './term.mjs';
+
+const ESC = '\x1b[';
+const RESET = `${ESC}0m`;
+
+// ── Brand tokens ─────────────────────────────────────────────────────────
+// Each token is { rgb: [r,g,b], ansi256: n, ansi16: 'fgName' }.
+// `ansi16` maps to a key in BASIC_FG below.
+
+export const TOKENS = Object.freeze({
+  // Brand
+  'brand.primary': { rgb: [124, 58, 237],  ansi256: 99,  ansi16: 'magenta' }, // #7c3aed
+  'brand.accent':  { rgb: [236, 72, 153],  ansi256: 198, ansi16: 'magenta' }, // #ec4899
+  'brand.data':    { rgb: [34, 211, 238],  ansi256: 87,  ansi16: 'cyan'    }, // #22d3ee
+
+  // State
+  'state.success': { rgb: [34, 197, 94],   ansi256: 41,  ansi16: 'green'   }, // #22c55e
+  'state.warn':    { rgb: [234, 179, 8],   ansi256: 220, ansi16: 'yellow'  }, // #eab308
+  'state.danger':  { rgb: [239, 68, 68],   ansi256: 196, ansi16: 'red'     }, // #ef4444
+
+  // Text
+  'text.primary':  { rgb: [201, 209, 217], ansi256: 250, ansi16: 'white'   }, // #c9d1d9
+  'text.dim':      { rgb: [107, 114, 128], ansi256: 245, ansi16: 'gray'    }, // #6b7280
+  'text.muted':    { rgb: [156, 163, 175], ansi256: 247, ansi16: 'gray'    }, // #9ca3af
+});
+
+// ── ANSI 16-color foreground codes ───────────────────────────────────────
+
+const BASIC_FG = {
+  black:   30,
+  red:     31,
+  green:   32,
+  yellow:  33,
+  blue:    34,
+  magenta: 35,
+  cyan:    36,
+  white:   37,
+  gray:    90,
+};
+
+// ── Style codes (work at every tier) ─────────────────────────────────────
+
+const STYLE_CODES = {
+  bold:      [1, 22],
+  dim:       [2, 22],
+  italic:    [3, 23],
+  underline: [4, 24],
+  inverse:   [7, 27],
+  strike:    [9, 29],
+};
+
+// ── Open / close sequence builders ───────────────────────────────────────
+
+function openForToken(token, capability) {
+  const def = TOKENS[token];
+  if (!def) return '';
+
+  if (capability === 'truecolor') {
+    const [r, g, b] = def.rgb;
+    return `${ESC}38;2;${r};${g};${b}m`;
+  }
+  if (capability === 'ansi256') {
+    return `${ESC}38;5;${def.ansi256}m`;
+  }
+  if (capability === 'ansi16') {
+    return `${ESC}${BASIC_FG[def.ansi16] || BASIC_FG.white}m`;
+  }
+  return '';
+}
+
+function wrap(open) {
+  if (!open) return (input) => String(input ?? '');
+  // Re-open after every embedded reset so nested styles compose.
+  // Cheap and predictable; most tool output is short enough that the cost
+  // is negligible compared to writing to the TTY.
+  return (input) => {
+    const text = String(input ?? '');
+    if (!text) return '';
+    if (!text.includes(RESET)) return `${open}${text}${RESET}`;
+    return `${open}${text.split(RESET).join(`${RESET}${open}`)}${RESET}`;
+  };
+}
+
+function styleWrap(openCode, closeCode) {
+  return (input) => {
+    const text = String(input ?? '');
+    if (!text) return '';
+    // No color tier check here — styles like bold/dim work even in ansi16.
+    if (!term().color) return text;
+    const open = `${ESC}${openCode}m`;
+    const close = `${ESC}${closeCode}m`;
+    if (!text.includes(close)) return `${open}${text}${close}`;
+    return `${open}${text.split(close).join(`${close}${open}`)}${close}`;
+  };
+}
+
+// ── Build a structured `paint` object once per token ─────────────────────
+
+function buildPaint() {
+  const paint = {};
+
+  // Brand / state / text colorizers, nested by namespace.
+  for (const token of Object.keys(TOKENS)) {
+    const [ns, name] = token.split('.');
+    if (!paint[ns]) paint[ns] = {};
+    paint[ns][name] = (input) => {
+      const t = term();
+      if (!t.color) return String(input ?? '');
+      return wrap(openForToken(token, t.colorLevel))(input);
+    };
+  }
+
+  // Style colorizers (callable directly).
+  for (const [style, [open, close]] of Object.entries(STYLE_CODES)) {
+    paint[style] = styleWrap(open, close);
+  }
+
+  // Compose helper — apply multiple styles left-to-right.
+  paint.compose = (...fns) => (input) =>
+    fns.reduce((acc, fn) => (typeof fn === 'function' ? fn(acc) : acc), input);
+
+  // Raw token accessor for callers that need to inject codes around their
+  // own text (e.g. status bar repaint loops that re-style a buffer).
+  paint.token = (key) => {
+    const t = term();
+    if (!t.color) return { open: '', close: '' };
+    return { open: openForToken(key, t.colorLevel), close: RESET };
+  };
+
+  return paint;
+}
+
+export const paint = buildPaint();
+
+// ── Plain-text helper (always strips colors) ─────────────────────────────
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+export function strip(input) {
+  return String(input ?? '').replace(ANSI_RE, '');
+}
+
+/**
+ * Visible length of a string (ignoring ANSI codes).
+ * Surrogate pairs (emoji) count as 1 visual cell for layout purposes — this
+ * is consistent with most terminals' rendering of single-codepoint emoji.
+ */
+export function width(input) {
+  const plain = strip(input);
+  // Strip variation selectors so "🛰️" measures as one cell.
+  return [...plain.replace(/︎|️/g, '')].length;
+}
+
+// ── Backwards compatibility re-exports ───────────────────────────────────
+// `ansi.mjs` and other legacy modules import these names. New code should
+// prefer `paint.brand.primary(...)` etc.
+
+export const RESET_CODE = RESET;

package/src/ui/slash-commands.mjs

@@ -0,0 +1,245 @@
+/**
+ * Slash Commands — canonical catalog + input normalizer.
+ *
+ * This module is the ONE source of truth for the REPL's slash commands.
+ * Consumers:
+ *   - src/terminal/repl.mjs imports COMMANDS, HELP_GROUPS, etc. for its
+ *     runtime dispatch and slash-hint suggestions.
+ *   - src/index.mjs iterates COMMANDS for `bahulam-code --help` output.
+ *
+ * The runtime *handlers* live in repl.mjs (they need session/ctx access
+ * that only the REPL has). This module is data-only + pure normalization.
+ */
+
+// name -> one-line description (bare string).
+export const COMMANDS = {
+  '/help':        'Show commands',
+  '/login':       'Sign in via browser',
+  '/whoami':      'Show logged-in user',
+  '/status':      'Session status & system info',
+  '/plan':        'Show plan/tasks',
+  '/tasks':       'Show or update project tasks',
+  '/stats':       'Progress bars & metrics',
+  '/new':         'Start a new session',
+  '/clear':       'Clear conversation',
+  '/git':         'Git status',
+  '/diff':        'Git diff',
+  '/cost':        'Show session cost',
+  '/model':       'Show or set session model overrides',
+  '/attach':      'Attach image path or clipboard image to next prompt',
+  '/attachments': 'List or clear pending image attachments',
+  '/history':     'Show conversation',
+  '/settings':    'Show policy/settings',
+  '/last':        'Expand last tool output',
+  '/expand':      'Expand tool output by index (or "all")',
+  '/fold':        'Hide previously expanded tool output',
+  '/checkpoint':  'List recent file checkpoints',
+  '/undo':        'Restore the last file checkpoint',
+  '/preflight':   'Re-run the onboarding diagnostic',
+  '/report':      'Save the mission report as markdown',
+  '/why':         'Print the agent reasoning for the last decision',
+  '/map':         'Show the registered project tree',
+  '/budget':      'Set / clear a hard session cost cap',
+  '/quiet':       'Verbosity: hide sub-agent inner tools',
+  '/verbose':     'Verbosity: show sub-agent inner tools',
+  '/surgical':    'Verbosity: show everything (reasoning, expanded tools)',
+  '/compact':     'Compact conversation context',
+  '/agents':      'List available agents',
+  '/explore':     'Code explorer agent',
+  '/review':      'Code review agent',
+  '/architect':   'Feature architect agent',
+  '/safety':      'Show safety guardrail status',
+  '/revoke':      'Revoke auto-approvals',
+  '/resume':      'Resume a previous session',
+  '/sessions':    'List resumable sessions',
+  '/logout':      'Sign out and clear credentials',
+  '/exit':        'Exit CLI',
+};
+
+// Grouped view for the `/help` interactive display. Each entry is
+// [command-with-args, description] so subcommands appear inline.
+export const HELP_GROUPS = [
+  {
+    key: 'plan',
+    title: 'Plan',
+    summary: 'plan and project tasks',
+    commands: [
+      ['/plan', 'Plan and task overview'],
+      ['/plan status', 'Plan owner and task files'],
+      ['/plan edit', 'Show editable task/plan paths'],
+      ['/tasks', 'List project tasks'],
+      ['/tasks add <text>', 'Add backlog task'],
+      ['/tasks active|blocked|done <text>', 'Append to a task list'],
+    ],
+  },
+  {
+    key: 'status',
+    title: 'Status',
+    summary: 'session, usage, budget',
+    commands: [
+      ['/status', 'Session snapshot'],
+      ['/status context', 'Loaded .bahulam context'],
+      ['/status metrics', 'Progress bars and runtime metrics'],
+      ['/status cost', 'Credits and message window'],
+      ['/model [role] [model]', 'Show or set session model override'],
+      ['/attach <image>', 'Attach image to the next prompt'],
+      ['/attach clipboard', 'Attach image currently copied to macOS/Windows clipboard'],
+      ['/attachments', 'List pending image attachments'],
+      ['/attachments clear', 'Clear pending image attachments'],
+      ['/status budget <amount|clear>', 'Set or clear session budget'],
+    ],
+  },
+  {
+    key: 'history',
+    title: 'History',
+    summary: 'transcript, reports, undo',
+    commands: [
+      ['/history', 'Recent transcript'],
+      ['/history approvals', 'Approval log'],
+      ['/history last', 'Expand last tool output'],
+      ['/history expand [n|all]', 'Expand tool output'],
+      ['/history checkpoint', 'List checkpoints'],
+      ['/history undo', 'Restore latest checkpoint'],
+      ['/history report', 'Save mission report'],
+    ],
+  },
+  {
+    key: 'settings',
+    title: 'Settings',
+    summary: 'auth, policy, verbosity',
+    commands: [
+      ['/settings policy', 'Effective project policy'],
+      ['/settings login', 'Sign in'],
+      ['/settings logout', 'Sign out'],
+      ['/settings whoami', 'Current user'],
+      ['/settings quiet|verbose|surgical', 'Verbosity'],
+      ['/settings revoke', 'Revoke auto-approvals'],
+    ],
+  },
+  {
+    key: 'worktree',
+    title: 'Worktree',
+    summary: 'git and files',
+    commands: [
+      ['/git', 'Git status'],
+      ['/diff', 'Git diff'],
+      ['/map', 'Registered project tree'],
+      ['/preflight', 'Onboarding diagnostic'],
+      ['/safety', 'Safety guardrail status'],
+    ],
+  },
+  {
+    key: 'agents',
+    title: 'Agents',
+    summary: 'specialist modes',
+    commands: [
+      ['/agents', 'List built-in and local agents'],
+      ['/agents create <name>', 'Create .bahulam/agents/<name>.yaml'],
+      ['/agents edit <name>', 'Open local agent YAML'],
+      ['/agents sync [name]', 'Sync all or one local agent to cloud'],
+      ['/explore <instruction>', 'Explore code'],
+      ['/review <instruction>', 'Review code'],
+      ['/architect <instruction>', 'Design an approach'],
+    ],
+  },
+  {
+    key: 'session',
+    title: 'Session',
+    summary: 'resume and clear',
+    commands: [
+      ['/sessions', 'List resumable sessions'],
+      ['/resume [id]', 'Resume a session'],
+      ['/compact', 'Compact conversation context'],
+      ['/new', 'Start a fresh session'],
+      ['/clear', 'Clear conversation'],
+      ['/exit', 'Exit CLI'],
+    ],
+  },
+];
+
+export const HELP_GROUP_ALIASES = new Map(
+  HELP_GROUPS.flatMap(group => [[group.key, group], [group.title.toLowerCase(), group]])
+);
+
+// Old flat commands that the user might still type. Map them to the new
+// namespaced form so completion + help nudge them toward the current UX.
+export const LEGACY_COMMAND_HINTS = {
+  '/stats':      '/status metrics',
+  '/cost':       '/status cost',
+  '/budget':     '/status budget',
+  '/last':       '/history last',
+  '/expand':     '/history expand',
+  '/fold':       '/history fold',
+  '/undo':       '/history undo',
+  '/checkpoint': '/history checkpoint',
+  '/report':     '/history report',
+  '/login':      '/settings login',
+  '/logout':     '/settings logout',
+  '/whoami':     '/settings whoami',
+  '/quiet':      '/settings quiet',
+  '/verbose':    '/settings verbose',
+  '/surgical':   '/settings surgical',
+  '/revoke':     '/settings revoke',
+};
+
+// Namespaced subcommands. `/status metrics` -> `/stats`, etc.
+export const NAMESPACED_COMMANDS = {
+  '/status': {
+    metrics: '/stats',
+    stats:   '/stats',
+    cost:    '/cost',
+    credits: '/cost',
+    budget:  '/budget',
+  },
+  '/history': {
+    last:        '/last',
+    expand:      '/expand',
+    fold:        '/fold',
+    undo:        '/undo',
+    checkpoint:  '/checkpoint',
+    checkpoints: '/checkpoint',
+    report:      '/report',
+  },
+  '/settings': {
+    login:    '/login',
+    logout:   '/logout',
+    whoami:   '/whoami',
+    quiet:    '/quiet',
+    verbose:  '/verbose',
+    surgical: '/surgical',
+    revoke:   '/revoke',
+  },
+};
+
+/**
+ * Normalize a raw slash-command input like "/status metrics arg" into
+ * { cmd: '/stats', rest: 'arg', rawCmd, aliasTarget }, resolving legacy
+ * aliases and namespaced subcommands to their canonical form.
+ *
+ * - `rawCmd`      the lower-cased first token as the user typed it
+ * - `cmd`         the canonical command (namespaced hit if any, else rawCmd)
+ * - `rest`        the remaining args joined with spaces
+ * - `aliasTarget` for legacy flat commands, the new namespaced form to
+ *                 suggest to the user (null when not aliased)
+ */
+export function normalizeCommandInput(input) {
+  const parts = String(input || '').trim().split(/\s+/).filter(Boolean);
+  const rawCmd = (parts[0] || '').toLowerCase();
+  const restParts = parts.slice(1);
+  const sub = (restParts[0] || '').toLowerCase();
+  const namespaced = NAMESPACED_COMMANDS[rawCmd]?.[sub];
+  if (namespaced) {
+    return {
+      cmd: namespaced,
+      rest: restParts.slice(1).join(' '),
+      rawCmd,
+      aliasTarget: null,
+    };
+  }
+  return {
+    cmd: rawCmd,
+    rest: restParts.join(' '),
+    rawCmd,
+    aliasTarget: LEGACY_COMMAND_HINTS[rawCmd] || null,
+  };
+}

package/src/ui/spinner.mjs

@@ -0,0 +1,116 @@
+/**
+ * Single shared spinner — Mission Control (PRD-055 §4.4).
+ *
+ * One spinner instance per process. The repl and status bar consume frames
+ * from the same source so the eye never sees two animations out of phase.
+ *
+ * Usage:
+ *
+ *   const stop = startSpinner('Reading auth.py');
+ *   await doWork();
+ *   stop();                          // clears the line and stops the timer
+ *
+ * Or, for a managed line that already exists (e.g. the status bar):
+ *
+ *   const tick = spinnerFrame();     // current frame, advances on next call
+ *
+ * Behavior:
+ *   - 120ms per frame.
+ *   - Suppressed entirely when stdout is not a TTY or when KEPLER_PLAIN=1.
+ *     The `start`/`stop` API is still safe to call (no-op).
+ *   - Color follows the current orbit (orchestrated by the caller via the
+ *     palette token). Default: brand.primary.
+ *   - ASCII fallback (when no Unicode): 'plain dot rotation'.
+ */
+
+import { paint } from './palette.mjs';
+import { term } from './term.mjs';
+
+// 8-step rotation. The PRD spec calls for ◯ → ◔ → ◑ → ◕ → ● → ◕ → ◑ → ◔
+// which yields a perceptual "breathing" cycle rather than a left-right spin.
+const FRAMES_UTF = ['◯', '◔', '◑', '◕', '●', '◕', '◑', '◔'];
+const FRAMES_ASCII = ['.', 'o', 'O', '@', 'O', 'o', '.', ' '];
+
+const INTERVAL_MS = 120;
+
+let _frame = 0;
+
+/**
+ * Current spinner glyph. Advances the cursor each call.
+ * Honors capability detection automatically.
+ */
+export function spinnerFrame(painter = paint.brand.primary) {
+  const frames = term().unicode ? FRAMES_UTF : FRAMES_ASCII;
+  const ch = frames[_frame % frames.length];
+  _frame = (_frame + 1) % frames.length;
+  return painter ? painter(ch) : ch;
+}
+
+/**
+ * Reset to frame 0 — useful at the start of a new turn so consecutive
+ * tool calls do not inherit each other's phase.
+ */
+export function resetSpinner() {
+  _frame = 0;
+}
+
+/**
+ * Start an inline spinner attached to `text`. Returns a stop function.
+ *
+ * The line is re-rendered in place using carriage return + erase, so the
+ * caller does not need to manage cursor state. If the terminal cannot
+ * render in place (non-TTY, dumb terminal, plain mode), the spinner becomes
+ * a single static line `"… text"` written once.
+ */
+export function startSpinner(text, { stream = process.stderr, painter, color = 'brand.primary' } = {}) {
+  const t = term();
+  if (!t.isTTY || t.plain || !t.color) {
+    try { stream.write(`… ${text}\n`); } catch {}
+    return () => {};
+  }
+
+  const paintFn = painter || tokenPainter(color);
+  let stopped = false;
+
+  const render = () => {
+    if (stopped) return;
+    const glyph = spinnerFrame(paintFn);
+    try {
+      stream.write(`\r\x1b[2K${glyph} ${paint.text.dim(text)}`);
+    } catch {
+      // Stream closed mid-spin — stop quietly.
+      stop();
+    }
+  };
+
+  render();
+  const handle = setInterval(render, INTERVAL_MS);
+
+  function stop() {
+    if (stopped) return;
+    stopped = true;
+    clearInterval(handle);
+    try {
+      stream.write('\r\x1b[2K');
+    } catch {}
+  }
+
+  return stop;
+}
+
+/**
+ * Look up a painter function from a dotted token name (e.g. 'brand.accent').
+ * Falls back to the identity painter when the token does not exist.
+ */
+function tokenPainter(tokenPath) {
+  const [ns, name] = String(tokenPath || '').split('.');
+  const group = paint[ns];
+  if (group && typeof group[name] === 'function') return group[name];
+  return (s) => String(s ?? '');
+}
+
+/**
+ * Interval used by the shared spinner. Exposed for the status bar to
+ * synchronize its own re-paints with the spinner phase.
+ */
+export const SPINNER_INTERVAL_MS = INTERVAL_MS;