ispbills-icli 5.3.0 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ispbills-icli",
-  "version": "5.3.0",
+  "version": "6.0.0",
   "description": "iCli — IspBills AI network engineer in your terminal",
   "keywords": [
     "ispbills",
@@ -23,10 +23,5 @@
     "src/",
     "README.md"
   ],
-  "dependencies": {
-    "chalk": "^5.3.0",
-    "marked": "^15.0.12",
-    "marked-terminal": "^7.3.0",
-    "ora": "^9.4.1"
-  }
+  "dependencies": {}
 }

package/src/banner.js

@@ -0,0 +1,42 @@
+import { RESET, BOLD, DIM, CYAN, WHITE, ACCENT, GRAY, cols, shortModel, rule } from './ui.js';
+
+const LOGO = [
+  '  ██╗ ██████╗ ██████╗ ██████╗ ██╗██╗      ██████╗ ████████╗',
+  '  ██║██╔════╝██╔═══██╗██╔══██╗██║██║     ██╔═══██╗╚══██╔══╝',
+  '  ██║██║     ██║   ██║██████╔╝██║██║     ██║   ██║   ██║   ',
+  '  ██║██║     ██║   ██║██╔═══╝ ██║██║     ██║   ██║   ██║   ',
+  '  ██║╚██████╗╚██████╔╝██║     ██║███████╗╚██████╔╝   ██║   ',
+  '  ╚═╝ ╚═════╝ ╚═════╝ ╚═╝     ╚═╝╚══════╝ ╚═════╝    ╚═╝   ',
+];
+
+/**
+ * Full iCopilot banner. On narrow terminals falls back to a compact header.
+ *
+ * @param {object} cfg   Loaded config ({ url, user, _model }).
+ * @param {object} opts  { model }
+ */
+export function printBanner(cfg = {}, opts = {}) {
+  const width = cols();
+  const model = opts.model || cfg._model || 'IspBills AI';
+
+  console.log();
+  if (width >= 62) {
+    for (const line of LOGO) console.log(ACCENT + BOLD + line + RESET);
+    console.log(`             ${DIM}iCopilot — network engineer in your terminal${RESET}`);
+  } else {
+    console.log(rule());
+    console.log(` ${BOLD}iCopilot${RESET} ${DIM}— IspBills AI terminal${RESET}`);
+    console.log(rule());
+  }
+  console.log();
+
+  const parts = [];
+  parts.push(`${DIM}model${RESET} ${CYAN}${shortModel(model)}${RESET}`);
+  if (cfg.user?.name) parts.push(`${DIM}user${RESET} ${WHITE}${cfg.user.name}${RESET}`);
+  if (cfg.user?.role) parts.push(`${DIM}role${RESET} ${WHITE}${cfg.user.role}${RESET}`);
+  console.log('  ' + parts.join(`  ${GRAY}·${RESET}  `));
+  if (cfg.url) console.log(`  ${DIM}url${RESET}   ${ACCENT}${cfg.url}${RESET}`);
+  console.log();
+  console.log(`  ${DIM}Type a message to start.  ${RESET}${ACCENT}/help${RESET}${DIM} for commands  ·  ${RESET}${ACCENT}Ctrl+C${RESET}${DIM} to exit${RESET}`);
+  console.log();
+}

package/src/client.js

@@ -0,0 +1,100 @@
+import { refreshToken } from './auth.js';
+
+/**
+ * Incrementally extract the answer text from the raw JSON the backend streams
+ * in `delta` events (the reply object is built up as a JSON string).
+ */
+function parseStreamText(raw) {
+  const m = raw.match(/"text"\s*:\s*"((?:[^"\\]|\\.)*)/);
+  if (!m) return raw.trimStart().startsWith('{') ? null : raw;
+  return m[1]
+    .replace(/\\n/g, '\n')
+    .replace(/\\t/g, '\t')
+    .replace(/\\r/g, '')
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, '\\');
+}
+
+/**
+ * Stream a chat turn from the IspBills Terminal AI backend.
+ *
+ * Emits UI-agnostic events via `onEvent` and resolves with the final reply.
+ *
+ * @param {object}   cfg       Loaded config ({ url, token, refresh_token, ... }).
+ * @param {Array}    messages  Conversation history [{role, content}].
+ * @param {object}   [options] { onEvent(event), signal, context }
+ * @returns {Promise<{reply: object, text: string, meta: object}>}
+ */
+export async function streamChat(cfg, messages, options = {}) {
+  const { onEvent = () => {}, signal, context = {} } = options;
+  const body = JSON.stringify({ messages, context });
+
+  const doFetch = (token) =>
+    fetch(`${cfg.url}/api/v1/ai/chat/stream`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'text/event-stream',
+        Authorization: 'Bearer ' + token,
+      },
+      body,
+      signal,
+    });
+
+  let res = await doFetch(cfg.token);
+  if (res.status === 401 && cfg.refresh_token) {
+    const updated = await refreshToken(cfg);
+    if (!updated) throw new Error('Session expired. Run `icli login`.');
+    Object.assign(cfg, updated);
+    res = await doFetch(cfg.token);
+  }
+  if (!res.ok) {
+    const txt = await res.text().catch(() => '');
+    throw new Error(`AI request failed (HTTP ${res.status}): ${txt.slice(0, 200)}`);
+  }
+
+  let rawAnswer = '';
+  let answerText = '';
+  let finalResult = null;
+
+  const decoder = new TextDecoder();
+  let sseBuffer = '';
+
+  for await (const chunk of res.body) {
+    if (signal?.aborted) break;
+    sseBuffer += decoder.decode(chunk, { stream: true });
+    const lines = sseBuffer.split('\n');
+    sseBuffer = lines.pop();
+
+    for (const line of lines) {
+      const t = line.replace(/\r$/, '');
+      if (!t.startsWith('data: ')) continue;
+      let ev;
+      try {
+        ev = JSON.parse(t.slice(6));
+      } catch {
+        continue;
+      }
+
+      if (ev.status_delta !== undefined) {
+        onEvent({ type: 'status', line: ev.status_delta });
+      } else if (ev.reason_delta !== undefined) {
+        onEvent({ type: 'reasoning', delta: ev.reason_delta });
+      } else if (ev.delta !== undefined) {
+        rawAnswer += ev.delta;
+        const txt = parseStreamText(rawAnswer);
+        if (txt !== null && txt.length > answerText.length) {
+          onEvent({ type: 'text', delta: txt.slice(answerText.length) });
+          answerText = txt;
+        }
+      } else if (ev.done) {
+        finalResult = ev.result;
+      }
+    }
+  }
+
+  const reply = finalResult?.reply ?? {};
+  const meta = finalResult?._meta ?? {};
+  const text = reply.text || answerText || '';
+  return { reply, text, meta };
+}

package/src/commands.js

@@ -0,0 +1,67 @@
+import { RESET, BOLD, DIM, GRAY, WHITE, ACCENT, GREEN } from './ui.js';
+
+/** All slash commands, used for the menu, help and Tab completion. */
+export const SLASH_COMMANDS = [
+  { cmd: '/check',    hint: '[device]',  desc: 'Run diagnostics on a device'  },
+  { cmd: '/vlan',     hint: '[id]',      desc: 'Check VLAN usage'             },
+  { cmd: '/onu',      hint: '[id]',      desc: 'Show ONU status and signal'   },
+  { cmd: '/customer', hint: '[name/IP]', desc: 'Look up a customer'           },
+  { cmd: '/ping',     hint: '[host]',    desc: 'Ping a host'                  },
+  { cmd: '/online',   hint: '',          desc: 'List online sessions'         },
+  { cmd: '/new',      hint: '',          desc: 'Start a fresh conversation'   },
+  { cmd: '/history',  hint: '',          desc: 'Show conversation history'    },
+  { cmd: '/clear',    hint: '',          desc: 'Clear the screen'             },
+  { cmd: '/update',   hint: '',          desc: 'Update iCli to the latest version' },
+  { cmd: '/logout',   hint: '',          desc: 'Log out and clear credentials' },
+  { cmd: '/help',     hint: '',          desc: 'Show help'                    },
+  { cmd: '/exit',     hint: '',          desc: 'Exit iCli'                    },
+];
+
+/** readline completer for slash commands. */
+export function slashCompleter(line) {
+  if (line.startsWith('/')) {
+    const hits = SLASH_COMMANDS.map((s) => s.cmd + ' ').filter((s) => s.startsWith(line));
+    return [hits.length ? hits : SLASH_COMMANDS.map((s) => s.cmd + ' '), line];
+  }
+  return [[], line];
+}
+
+/**
+ * Map an IspBills AI shortcut command to a natural-language question.
+ * Returns null for commands that are handled locally by the REPL.
+ */
+export function slashToQuestion(line) {
+  const [sc, ...rest] = line.trim().split(/\s+/);
+  const arg = rest.join(' ');
+  switch (sc) {
+    case '/check':    return arg ? `run diagnostics on ${arg}` : 'check status of all devices';
+    case '/vlan':     return arg ? `is vlan ${arg} in use or free?` : 'list all vlans in use';
+    case '/onu':      return arg ? `show ONU ${arg} status and signal level` : 'list all ONUs';
+    case '/customer': return arg ? `look up customer ${arg}` : 'show recent customers';
+    case '/ping':     return arg ? `ping ${arg} through the network` : 'which devices are reachable?';
+    case '/online':   return 'list currently online PPPoE sessions';
+    default:          return null;
+  }
+}
+
+export function printSlashMenu() {
+  console.log(`\n  ${BOLD}Slash commands${RESET}`);
+  for (const { cmd, hint, desc } of SLASH_COMMANDS) {
+    const key = (cmd + (hint ? ' ' + hint : '')).padEnd(20);
+    console.log(`  ${ACCENT}${key}${RESET}${DIM}${desc}${RESET}`);
+  }
+  console.log();
+}
+
+export function printHistory(history) {
+  const turns = history.filter((m) => m.role === 'user');
+  if (!turns.length) {
+    console.log(`\n  ${GRAY}No history yet.${RESET}\n`);
+    return;
+  }
+  console.log(`\n  ${BOLD}History${RESET}`);
+  turns.forEach((m, i) =>
+    console.log(`  ${DIM}${String(i + 1).padStart(2)}.${RESET} ${WHITE}${m.content.replace(/\s+/g, ' ').slice(0, 80)}${RESET}`)
+  );
+  console.log();
+}

package/src/loader.js

@@ -0,0 +1,77 @@
+import { DIM, RESET } from './ui.js';
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+const GRADIENT_COLORS = [
+  '\x1b[38;5;240m',
+  '\x1b[38;5;245m',
+  '\x1b[38;5;250m',
+  '\x1b[38;5;255m',
+  '\x1b[38;5;250m',
+  '\x1b[38;5;245m',
+];
+
+/**
+ * A single-line loader shown while the backend is streaming.
+ * Styles: 'spinner' (default), 'gradient', 'minimal'.
+ */
+export class Loader {
+  constructor(config = { text: 'Thinking', style: 'spinner' }) {
+    this.config = config;
+    this.frame = 0;
+    this.interval = null;
+  }
+
+  setText(text) {
+    this.config = { ...this.config, text };
+  }
+
+  start() {
+    if (this.interval) return;
+    this.frame = 0;
+    const { style } = this.config;
+    const ms = style === 'gradient' ? 150 : style === 'spinner' ? 80 : 300;
+    this.interval = setInterval(() => this.draw(), ms);
+    this.draw();
+  }
+
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+      process.stdout.write('\r\x1b[K');
+    }
+  }
+
+  get running() {
+    return this.interval !== null;
+  }
+
+  draw() {
+    const { text, style } = this.config;
+    this.frame++;
+    switch (style) {
+      case 'minimal': {
+        const dots = ['·', '··', '···'];
+        process.stdout.write(`\r  ${DIM}${text}${dots[this.frame % 3]}${RESET}`);
+        break;
+      }
+      case 'gradient': {
+        const len = GRADIENT_COLORS.length;
+        let out = '\r  ';
+        for (let i = 0; i < text.length; i++) {
+          out += GRADIENT_COLORS[(this.frame + i) % len] + text[i];
+        }
+        out += RESET;
+        process.stdout.write(out);
+        break;
+      }
+      case 'spinner':
+      default: {
+        const char = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length];
+        process.stdout.write(`\r  ${DIM}${char} ${text}…${RESET}`);
+        break;
+      }
+    }
+  }
+}

package/src/renderer.js

@@ -0,0 +1,162 @@
+import {
+  RESET, BOLD, DIM, ITALIC, CYAN, GREEN, YELLOW, RED, GRAY, WHITE, ACCENT,
+  cols, shortModel,
+} from './ui.js';
+
+/** Pick a status icon from the content of a server progress line. */
+function statusIcon(line) {
+  const l = line.toLowerCase();
+  if (/unreachable|skip|fail|error|denied|timeout/.test(l)) return `${RED}✗${RESET}`;
+  if (/done|success|found|complet|online|ready|ok\b/.test(l)) return `${GREEN}✓${RESET}`;
+  if (/batch|sub.?agent|fleet|parallel/.test(l)) return `${ACCENT}◈${RESET}`;
+  if (/\[\d+\/\d+\]/.test(l)) return `${ACCENT}◉${RESET}`;
+  if (/probe|reachab|ping/.test(l)) return `${YELLOW}◎${RESET}`;
+  if (/connect|ssh|telnet|api|session/.test(l)) return `${ACCENT}⇢${RESET}`;
+  if (/read|fetch|get|query|look|search/.test(l)) return `${GRAY}↓${RESET}`;
+  return `${GRAY}·${RESET}`;
+}
+
+/**
+ * Streaming + final-reply renderer for the iCopilot TUI. Consumes the
+ * UI-agnostic events emitted by client.streamChat and draws them.
+ */
+export class TuiRenderer {
+  constructor(opts = {}) {
+    this.display = { reasoning: false, ...(opts.display || {}) };
+    this.streaming = false;
+    this.lineBuf = '';
+    this.inCodeBlock = false;
+    this.reasoningOpen = false;
+    this.sawStatus = false;
+  }
+
+  handle(event) {
+    switch (event.type) {
+      case 'text': return this.renderText(event.delta);
+      case 'status': return this.renderStatus(event.line);
+      case 'reasoning': return this.renderReasoning(event.delta);
+    }
+  }
+
+  // ── Streaming answer text ──────────────────────────────────────────────────
+  renderText(delta) {
+    this.endReasoning();
+    this.streaming = true;
+    this.lineBuf += delta;
+    const lines = this.lineBuf.split('\n');
+    this.lineBuf = lines.pop();
+    for (const line of lines) {
+      process.stdout.write(this.formatMarkdownLine(line) + '\n');
+    }
+  }
+
+  flushLineBuf() {
+    if (this.lineBuf) {
+      process.stdout.write(this.formatMarkdownLine(this.lineBuf) + '\n');
+      this.lineBuf = '';
+    }
+  }
+
+  formatMarkdownLine(line) {
+    if (line.startsWith('```')) {
+      this.inCodeBlock = !this.inCodeBlock;
+      return this.inCodeBlock ? `  ${DIM}` : RESET;
+    }
+    if (this.inCodeBlock) return `  ${DIM}${line}${RESET}`;
+    if (/^#{1,3}\s/.test(line)) return `\n  ${BOLD}${line.replace(/^#+\s*/, '')}${RESET}`;
+    let out = line
+      .replace(/\*\*(.+?)\*\*/g, `${BOLD}$1${RESET}`)
+      .replace(/`([^`]+)`/g, `${CYAN}$1${RESET}`)
+      .replace(/^(\s*)[-*]\s+/, `$1${ACCENT}·${RESET} `);
+    return '  ' + out;
+  }
+
+  // ── Server progress (tool activity happening backend-side) ─────────────────
+  renderStatus(line) {
+    this.endStreaming();
+    this.endReasoning();
+    if (!this.sawStatus) {
+      process.stdout.write(`\n  ${DIM}${ITALIC}working${RESET}\n`);
+      this.sawStatus = true;
+    }
+    const text = line.trimStart();
+    const indent = /^[\s·•⌁]/.test(line) ? '    ' : '  ';
+    process.stdout.write(`${indent}${statusIcon(line)} ${DIM}${text}${RESET}\n`);
+  }
+
+  // ── Reasoning ──────────────────────────────────────────────────────────────
+  renderReasoning(delta) {
+    if (!this.display.reasoning) return;
+    this.endStreaming();
+    if (!this.reasoningOpen) {
+      process.stdout.write(`\n  ${ACCENT}◆${RESET} ${DIM}Reasoning${RESET}\n  ${GRAY}`);
+      this.reasoningOpen = true;
+    }
+    process.stdout.write(delta.replace(/\n/g, `\n  ${GRAY}`));
+  }
+
+  endReasoning() {
+    if (this.reasoningOpen) {
+      process.stdout.write(RESET + '\n');
+      this.reasoningOpen = false;
+    }
+  }
+
+  endStreaming() {
+    if (this.streaming) {
+      this.flushLineBuf();
+      this.inCodeBlock = false;
+      process.stdout.write(RESET);
+      this.streaming = false;
+    }
+  }
+
+  // ── Final reply ─────────────────────────────────────────────────────────────
+  renderReply(reply = {}, meta = {}) {
+    this.endStreaming();
+    this.endReasoning();
+    const type = reply.type ?? 'message';
+
+    if (type === 'plan') this.renderPlan(reply);
+    else if (type === 'connect') this.renderConnect(reply);
+    // 'message' text already streamed live via renderText; nothing more to draw.
+
+    this.renderFooter(meta);
+    this.sawStatus = false;
+  }
+
+  renderPlan(reply) {
+    console.log(`\n  ${ACCENT}${BOLD}◆ Plan${RESET}`);
+    if (reply.summary) console.log(`  ${DIM}${reply.summary}${RESET}`);
+    const steps = reply.steps || [];
+    steps.forEach((s, i) => {
+      const last = i === steps.length - 1;
+      const branch = `${GRAY}${last ? '└─' : '├─'}${RESET}`;
+      const risk =
+        (s.risk === 'destructive' || s.risk === 'high') ? ` ${RED}⚠ destructive${RESET}` :
+        (s.risk === 'caution' || s.risk === 'medium') ? ` ${YELLOW}⚡ caution${RESET}` : '';
+      const blocked = s.blocked ? ` ${RED}⛔ blocked${RESET}` : '';
+      console.log(`  ${branch} ${DIM}${i + 1}.${RESET} ${YELLOW}${s.cmd || ''}${RESET}${risk}${blocked}`);
+      const why = s.why || s.purpose;
+      if (why) console.log(`     ${GRAY}${why}${RESET}`);
+    });
+    console.log(`\n  ${DIM}Type ${RESET}${WHITE}apply fix${RESET}${DIM} to confirm.${RESET}`);
+  }
+
+  renderConnect(reply) {
+    const d = reply.device ?? reply ?? {};
+    const proto = d.proto ? ` ${DIM}via ${d.proto}${RESET}` : '';
+    console.log(
+      `\n  ${GREEN}🔌${RESET} ${BOLD}${(d.kind ?? '?').toUpperCase()} #${d.id ?? '?'}${RESET}${proto}`
+    );
+    if (reply.note) console.log(`  ${DIM}${reply.note}${RESET}`);
+    console.log(`  ${DIM}Establishing session…${RESET}`);
+  }
+
+  renderFooter(meta) {
+    const parts = [meta.model ? shortModel(meta.model) : null, meta.user, meta.role].filter(Boolean);
+    if (parts.length) {
+      console.log(`\n  ${GRAY}${parts.join('  ·  ')}${RESET}`);
+    }
+  }
+}

package/src/session.js

@@ -0,0 +1,41 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const SESSION_DIR = join(homedir(), '.config', 'ispbills-icli', 'sessions');
+
+export function sessionDir() {
+  return SESSION_DIR;
+}
+
+export function initSessionDir() {
+  if (!existsSync(SESSION_DIR)) mkdirSync(SESSION_DIR, { recursive: true });
+}
+
+export function newSessionPath() {
+  const id = new Date().toISOString().replace(/[:.]/g, '-');
+  return join(SESSION_DIR, `${id}.jsonl`);
+}
+
+/** Append a single message to the JSONL session log (best-effort). */
+export function saveMessage(sessionPath, message) {
+  try {
+    appendFileSync(sessionPath, JSON.stringify({ timestamp: new Date().toISOString(), message }) + '\n');
+  } catch {
+    /* non-fatal — session logging is a convenience only */
+  }
+}
+
+export function listSessions() {
+  if (!existsSync(SESSION_DIR)) return [];
+  return readdirSync(SESSION_DIR).filter((f) => f.endsWith('.jsonl')).sort();
+}
+
+export function loadSession(sessionPath) {
+  if (!existsSync(sessionPath)) return [];
+  return readFileSync(sessionPath, 'utf-8')
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => { try { return JSON.parse(line).message; } catch { return null; } })
+    .filter(Boolean);
+}

package/src/ui.js

@@ -0,0 +1,61 @@
+// Zero-dependency ANSI helpers shared across the iCopilot TUI.
+// Raw escape codes keep the package dependency-free and portable to
+// Windows terminals (Windows Terminal, PowerShell 7, cmd via VT mode).
+
+export const RESET = '\x1b[0m';
+export const BOLD = '\x1b[1m';
+export const DIM = '\x1b[2m';
+export const ITALIC = '\x1b[3m';
+export const UNDERLINE = '\x1b[4m';
+
+export const GRAY = '\x1b[90m';
+export const WHITE = '\x1b[97m';
+export const CYAN = '\x1b[36m';
+export const GREEN = '\x1b[32m';
+export const YELLOW = '\x1b[33m';
+export const RED = '\x1b[31m';
+export const MAGENTA = '\x1b[35m';
+export const BLUE = '\x1b[34m';
+
+// Accent used throughout the iCopilot brand (soft blue).
+export const ACCENT = '\x1b[38;5;111m';
+
+/** Terminal width, clamped to a sensible range. */
+export function cols() {
+  const c = process.stdout.columns || 80;
+  return Math.max(20, c);
+}
+
+/** Wrap text in an ANSI color and always reset. */
+export function paint(color, text) {
+  return `${color}${text}${RESET}`;
+}
+
+/** Length of a string ignoring ANSI escape codes. */
+export function visLen(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+
+/** Truncate to `max` visible chars with an ellipsis. */
+export function trunc(s, max = 50) {
+  return s.length > max ? s.slice(0, max) + '…' : s;
+}
+
+/** Naive pluralisation used by grouped tool output. */
+export function plural(n, noun) {
+  if (n === 1) return `1 ${noun}`;
+  if (noun.endsWith('y')) return `${n} ${noun.slice(0, -1)}ies`;
+  return `${n} ${noun}s`;
+}
+
+/** A horizontal rule spanning the terminal width. */
+export function rule(color = GRAY) {
+  return paint(color, '─'.repeat(cols()));
+}
+
+/** Shorten a fully-qualified model id for display (e.g. "anthropic/claude-…"). */
+export function shortModel(m) {
+  if (!m) return '';
+  const parts = String(m).split('/');
+  return parts[parts.length - 1];
+}