ispbills-icli 8.2.0 → 8.3.1

package/README.md

@@ -146,10 +146,29 @@ suggestion (accept with **Tab** or **→**), and runs the highlighted command on
 |---|---|
 | `/mac [addr]` | Locate a MAC address on the network |
 | `/arp [device]` · `/route [device]` | ARP / routing tables |
+| `/overlaps [ip/vlan/bgp/route]` | Find overlapping IP subnets, VLAN ids, interface assignments, BGP prefixes or routes |
+| `/flapping [device]` | List flapping interfaces (frequent up/down transitions) |
 | `/dhcp` | DHCP leases and pool usage |
 | `/ping [host]` · `/trace [host]` | Ping / traceroute a host |
 | `/customer [name/IP]` | Look up a customer |
 
+**Backups & version control**
+
+| Slash | Description |
+|---|---|
+| `/backup [device]` | Back up device config (all devices if omitted). Each answer is archived to your per-user git repo |
+| `/git [args]` | Run git in that backup repo — e.g. `/git status`, `/git log`, `/git commit -m "note"`, `/git remote add origin <url>`, `/git push` |
+| `/gist` | Save the last answer or the whole transcript to a **secret** GitHub gist (uses the `gh` CLI, or `/gist token <TOKEN>`) |
+
+**Memory**
+
+| Slash | Description |
+|---|---|
+| `/remember <note>` | Save a standing note the AI keeps in mind on every turn |
+| `/memory` | List your saved memory notes |
+| `/forget <n/all>` | Delete a note by number, matching text, or `all` |
+| `/copy` | Copy the last AI answer to the system clipboard |
+
 **Session**
 
 | Slash | Description |
@@ -168,6 +187,8 @@ suggestion (accept with **Tab** or **→**), and runs the highlighted command on
 | **/** then **↑/↓** | Open the slash menu and move the selection; **Tab** / **→** completes, **Enter** runs |
 | **@** | Mention a device/entity (e.g. `@olt:`, `@onu:`); **Tab** / **→** completes the tag |
 | **↑/↓** (empty input) | Navigate input history |
+| **Ctrl+Z** / **Ctrl+Y** | Undo / redo the input line |
+| **Paste** | Multi-line pastes (incl. mouse right-click) keep their line breaks and are never auto-submitted — press **Enter** to send |
 | **Shift+Tab** | Toggle autopilot mode |
 | **Ctrl+T** | Toggle reasoning display |
 | **Ctrl+L** | Clear the transcript |
@@ -201,6 +222,10 @@ iCli connects to the same AI engine as the in-browser terminal:
 - **Rich rendering** — Markdown tables, colored lists, headings, and code blocks; `@`-mentions are highlighted; long lists render as aligned tables  
 - **Interactive prompts** — when the AI needs a decision, it shows a selectable choice list (↑/↓, **Enter**) with an optional free-text answer (**Tab**)  
 - **Plans & connect cards** — proposed fixes stream in live as a reviewable plan (`apply fix` to confirm, or use the Apply/Explain/Cancel prompt); device connections show as a connect card  
+- **Bot memory** — `/remember` saves standing operator notes that are injected into every answer (`/memory`, `/forget` to manage)  
+- **Backups in git** — `/backup` archives config to a per-user git repo; run `/git status|log|commit|push` from the prompt  
+- **Share as a gist** — `/gist` publishes the last answer or transcript to a secret GitHub gist  
+- **Copy & paste** — `/copy` puts the last answer on the clipboard; multi-line pastes (mouse right-click or Cmd/Ctrl+V) keep their line breaks, and **Ctrl+Z / Ctrl+Y** undo/redo work in the input  
 - **Full-screen terminal UI** — a full-height alternate-screen TUI (built on [Ink](https://github.com/vadimdemedes/ink)) with the banner pinned to the top, a bottom-pinned bordered input, a selectable slash-command menu, input history, and a bottom-anchored transcript — the same layout as GitHub Copilot CLI / Gemini CLI. Piped/non-interactive use falls back to plain streaming output  
 - **Terminal-aware rendering** — the layout reflows to your terminal width and resizes live; on classic Windows consoles (`cmd.exe` / legacy PowerShell) it auto-switches to ASCII-safe glyphs and borders so nothing shows as broken boxes  
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ispbills-icli",
-  "version": "8.2.0",
+  "version": "8.3.1",
   "description": "iCli — IspBills AI network engineer in your terminal",
   "keywords": [
     "ispbills",

package/src/clipboard.js

@@ -0,0 +1,42 @@
+// Cross-platform "copy to system clipboard" helper. Best-effort: resolves to
+// false (rather than throwing) when no clipboard tool is available so the TUI
+// can show a friendly notice.
+import { spawn } from 'child_process';
+
+function candidates() {
+  if (process.platform === 'darwin') return [['pbcopy', []]];
+  if (process.platform === 'win32') return [['clip', []]];
+  // Linux / BSD: prefer Wayland, then X11 tools.
+  return [
+    ['wl-copy', []],
+    ['xclip', ['-selection', 'clipboard']],
+    ['xsel', ['--clipboard', '--input']],
+  ];
+}
+
+function tryCopy(cmd, args, text) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(cmd, args, { stdio: ['pipe', 'ignore', 'ignore'] });
+    } catch {
+      resolve(false);
+      return;
+    }
+    child.on('error', () => resolve(false));
+    child.on('close', (code) => resolve(code === 0));
+    try {
+      child.stdin.end(text);
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
+/** Copy `text` to the system clipboard. Returns the tool name on success, else null. */
+export async function copyToClipboard(text) {
+  for (const [cmd, args] of candidates()) {
+    if (await tryCopy(cmd, args, text)) return cmd;
+  }
+  return null;
+}

package/src/commands.js

@@ -34,11 +34,23 @@ export const SLASH_COMMANDS = [
   { cmd: '/mac',        hint: '[addr]',      desc: 'Locate a MAC address on the network',     group: 'Lookup'    },
   { cmd: '/arp',        hint: '[device]',    desc: 'ARP table for a device',                  group: 'Lookup'    },
   { cmd: '/route',      hint: '[device]',    desc: 'Routing table for a device',              group: 'Lookup'    },
+  { cmd: '/overlaps',   hint: '[ip/vlan/bgp/route]', desc: 'Find overlapping IP, VLAN, interface, BGP or routes', group: 'Lookup' },
+  { cmd: '/flapping',   hint: '[device]',    desc: 'List flapping interfaces (frequent up/down)', group: 'Lookup' },
   { cmd: '/dhcp',       hint: '',            desc: 'DHCP leases and pool usage',              group: 'Lookup'    },
   { cmd: '/ping',       hint: '[host]',      desc: 'Ping a host through the network',         group: 'Lookup'    },
   { cmd: '/trace',      hint: '[host]',      desc: 'Traceroute the path to a host',           group: 'Lookup'    },
   { cmd: '/customer',   hint: '[name/IP]',   desc: 'Look up a customer',                      group: 'Lookup'    },
 
+  // ── Backups & version control ──
+  { cmd: '/git',        hint: '[args]',      desc: 'Run git in your backup repo (status/commit/push/log)', group: 'Backups', local: true },
+  { cmd: '/gist',       hint: '',            desc: 'Save the last answer or transcript to a GitHub gist',  group: 'Backups', local: true },
+
+  // ── Memory ──
+  { cmd: '/remember',   hint: '<note>',      desc: 'Save a standing note the AI keeps in mind', group: 'Memory', local: true },
+  { cmd: '/memory',     hint: '',            desc: 'List saved memory notes',                 group: 'Memory', local: true },
+  { cmd: '/forget',     hint: '[n/all]',     desc: 'Delete a memory note (by number or all)', group: 'Memory', local: true },
+  { cmd: '/copy',       hint: '',            desc: 'Copy the last AI answer to the clipboard', group: 'Memory', local: true },
+
   // ── Session & app ──
   { cmd: '/autopilot',  hint: '',            desc: 'Toggle autopilot (auto-apply fixes)',     group: 'Session', local: true },
   { cmd: '/model',      hint: '[name]',      desc: 'Show or set the AI model',                group: 'Session', local: true },
@@ -106,6 +118,16 @@ export function slashToQuestion(line) {
     case '/mac':        return on(`locate MAC address ${arg} — which device and port is it on?`, 'how do I locate a MAC address? ask me for the address');
     case '/arp':        return on(`show the ARP table for ${arg}`, 'show ARP tables and flag any duplicate or suspicious entries');
     case '/route':      return on(`show the routing table for ${arg}`, 'show routing tables across the network');
+    case '/overlaps': {
+      const t = arg.toLowerCase();
+      if (/vlan/.test(t))                    return 'scan all devices for duplicate or overlapping VLAN ids and list each conflict with the devices/interfaces involved';
+      if (/bgp|prefix|as\b|peer/.test(t))    return 'check BGP for overlapping or conflicting prefixes and duplicate AS announcements across routers and list each conflict';
+      if (/route|routing/.test(t))           return 'find overlapping or conflicting routes across the routing tables and list each pair with the devices involved';
+      if (/int|port/.test(t))                return 'find interfaces/ports with overlapping or duplicate address or VLAN assignments and list each conflict';
+      if (/ip|subnet|network|cidr/.test(t))  return 'find overlapping or conflicting IP subnets and duplicate IP addresses across the network and list each conflict with the devices involved';
+      return 'scan the whole network for any overlapping or conflicting IP subnets, duplicate IPs, duplicate/overlapping VLAN ids, interface assignment conflicts, and overlapping BGP prefixes or routes — list each conflict grouped by type with the devices involved';
+    }
+    case '/flapping':   return on(`check ${arg} for flapping interfaces — list ports with frequent up/down transitions, their flap counts and last change time`, 'scan all devices for flapping interfaces (frequent up/down transitions) and list them with flap counts and the last state-change time');
     case '/dhcp':       return 'show DHCP leases and pool usage, and flag pools that are nearly exhausted';
     case '/ping':       return on(`ping ${arg} through the network and report latency and loss`, 'which hosts should I ping? list reachable devices');
     case '/trace':      return on(`traceroute the path to ${arg} and show each hop`, 'what host should I traceroute?');

package/src/gist.js

@@ -0,0 +1,90 @@
+// Create GitHub gists from the terminal. Prefers the `gh` CLI (uses its stored
+// auth); falls back to the REST API with a token from the icli config
+// (cfg.github_token) or the GITHUB_TOKEN / GH_TOKEN environment variables.
+import { spawn } from 'child_process';
+import { mkdtempSync, writeFileSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+function sh(cmd, args, { input } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(cmd, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+    } catch (e) {
+      resolve({ code: 127, stdout: '', stderr: String(e.message || e) });
+      return;
+    }
+    let stdout = '', stderr = '';
+    child.stdout.on('data', (d) => (stdout += d));
+    child.stderr.on('data', (d) => (stderr += d));
+    child.on('error', (e) => resolve({ code: 127, stdout, stderr: String(e.message || e) }));
+    child.on('close', (code) => resolve({ code, stdout: stdout.trim(), stderr: stderr.trim() }));
+    if (input != null) { try { child.stdin.end(input); } catch {} }
+    else child.stdin.end();
+  });
+}
+
+async function hasGh() {
+  const res = await sh('gh', ['--version']);
+  return res.code === 0;
+}
+
+function token(cfg) {
+  return cfg?.github_token || process.env.GITHUB_TOKEN || process.env.GH_TOKEN || '';
+}
+
+/** True if any GitHub auth is available (gh CLI or a token). */
+export async function canGist(cfg) {
+  if (token(cfg)) return true;
+  return hasGh();
+}
+
+async function gistViaGh({ filename, content, description, isPublic }) {
+  const dir = mkdtempSync(join(tmpdir(), 'icli-gist-'));
+  const path = join(dir, filename);
+  try {
+    writeFileSync(path, content);
+    const args = ['gist', 'create', path, '-d', description];
+    if (isPublic) args.push('--public');
+    const res = await sh('gh', args);
+    if (res.code !== 0) throw new Error(res.stderr || 'gh gist create failed');
+    const url = (res.stdout.match(/https?:\/\/\S+/) || [res.stdout])[0];
+    return { url };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+async function gistViaApi({ filename, content, description, isPublic }, tok) {
+  const res = await fetch('https://api.github.com/gists', {
+    method: 'POST',
+    headers: {
+      Authorization: 'Bearer ' + tok,
+      Accept: 'application/vnd.github+json',
+      'Content-Type': 'application/json',
+      'User-Agent': 'ispbills-icli',
+    },
+    body: JSON.stringify({ description, public: !!isPublic, files: { [filename]: { content } } }),
+  });
+  if (!res.ok) {
+    const txt = await res.text().catch(() => '');
+    throw new Error(`GitHub API ${res.status}: ${txt.slice(0, 160)}`);
+  }
+  const data = await res.json();
+  return { url: data.html_url };
+}
+
+/**
+ * Create a gist. `opts` = { filename, content, description, isPublic }.
+ * Returns { url }. Throws with a helpful message when no auth is available.
+ */
+export async function createGist(cfg, opts) {
+  const o = { isPublic: false, filename: 'icli.md', description: 'iCli export', ...opts };
+  const tok = token(cfg);
+  if (tok) return gistViaApi(o, tok);
+  if (await hasGh()) return gistViaGh(o);
+  throw new Error(
+    'No GitHub auth. Run `gh auth login`, or save a token with `/gist token <TOKEN>` (needs the "gist" scope).',
+  );
+}

package/src/gitrepo.js

@@ -0,0 +1,78 @@
+// Per-user local git repository for archiving device config backups and giving
+// the operator plain /git commands (status, log, commit, push, diff, …). The
+// repo lives under ~/.config/ispbills-icli/backups/<user>/ and is git-init'd on
+// first use with the operator's IspBills identity.
+import { spawn } from 'child_process';
+import { existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { userDir } from './userdir.js';
+
+// Sub-commands the operator may run through /git. Read-mostly plus the handful
+// needed to record and publish backups; anything else is refused.
+const ALLOWED = new Set([
+  'status', 'log', 'diff', 'show', 'add', 'commit', 'push', 'pull',
+  'fetch', 'remote', 'branch', 'checkout', 'init', 'config', 'ls-files', 'rev-parse',
+]);
+
+/** Absolute path to the user's backup git repo (created if missing). */
+export function repoDir(cfg) {
+  return userDir(cfg, 'backups');
+}
+
+function run(cfg, args, { input } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn('git', args, { cwd: repoDir(cfg), stdio: ['pipe', 'pipe', 'pipe'] });
+    } catch (e) {
+      resolve({ code: 127, stdout: '', stderr: String(e.message || e) });
+      return;
+    }
+    let stdout = '', stderr = '';
+    child.stdout.on('data', (d) => (stdout += d));
+    child.stderr.on('data', (d) => (stderr += d));
+    child.on('error', (e) => resolve({ code: 127, stdout, stderr: String(e.message || e) }));
+    child.on('close', (code) => resolve({ code, stdout, stderr }));
+    if (input != null) { try { child.stdin.end(input); } catch {} }
+    else child.stdin.end();
+  });
+}
+
+/** Initialise the repo on first use and set the local identity. */
+export async function ensureRepo(cfg) {
+  const dir = repoDir(cfg);
+  if (!existsSync(join(dir, '.git'))) {
+    await run(cfg, ['init', '-q']);
+    await run(cfg, ['config', 'user.name', cfg?.user?.name || 'IspBills operator']);
+    await run(cfg, ['config', 'user.email', cfg?.user?.email || 'operator@ispbills.local']);
+    await run(cfg, ['config', 'commit.gpgsign', 'false']);
+    writeFileSync(join(dir, 'README.md'), '# IspBills device backups\n\nManaged by iCli (`/backup`, `/git`).\n');
+    await run(cfg, ['add', 'README.md']);
+    await run(cfg, ['commit', '-q', '-m', 'Initialise backup repository']);
+  }
+  return dir;
+}
+
+/** Run a whitelisted git sub-command; returns { ok, code, stdout, stderr }. */
+export async function git(cfg, args) {
+  const sub = (args[0] || '').toLowerCase();
+  if (!sub) return { ok: false, code: 2, stdout: '', stderr: 'Usage: /git <status|log|commit|push|diff|…>' };
+  if (!ALLOWED.has(sub)) {
+    return { ok: false, code: 2, stdout: '', stderr: `git ${sub} is not allowed from iCli. Allowed: ${[...ALLOWED].join(', ')}` };
+  }
+  await ensureRepo(cfg);
+  const res = await run(cfg, args);
+  return { ok: res.code === 0, ...res };
+}
+
+/** Save backup content to a file and commit it. Returns { file, committed, stderr }. */
+export async function commitBackup(cfg, label, content) {
+  await ensureRepo(cfg);
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const safe = String(label || 'fleet').toLowerCase().replace(/[^a-z0-9._-]+/g, '-').slice(0, 40) || 'fleet';
+  const name = `${stamp}__${safe}.txt`;
+  writeFileSync(join(repoDir(cfg), name), String(content));
+  await run(cfg, ['add', name]);
+  const res = await run(cfg, ['commit', '-q', '-m', `Backup ${safe} @ ${stamp}`]);
+  return { file: name, committed: res.code === 0, stderr: res.stderr };
+}

package/src/memory.js

@@ -0,0 +1,72 @@
+// Per-user persistent "bot memory": short operator notes that are injected
+// into the AI context on every turn so the assistant remembers preferences,
+// naming conventions, standing instructions, etc. Managed with /remember,
+// /forget and /memory.
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { userDir } from './userdir.js';
+
+const MAX_NOTES = 50;
+
+function file(cfg) {
+  return join(userDir(cfg, 'memory'), 'notes.json');
+}
+
+/** Load the user's notes as an array of { at, text }. */
+export function loadNotes(cfg) {
+  try {
+    const data = JSON.parse(readFileSync(file(cfg), 'utf8'));
+    return Array.isArray(data?.notes) ? data.notes : [];
+  } catch {
+    return [];
+  }
+}
+
+function save(cfg, notes) {
+  writeFileSync(file(cfg), JSON.stringify({ notes }, null, 2), { mode: 0o600 });
+  return notes;
+}
+
+/** Append a note. Returns the updated list. */
+export function addNote(cfg, text) {
+  const t = String(text || '').trim();
+  if (!t) return loadNotes(cfg);
+  const notes = loadNotes(cfg);
+  notes.push({ at: new Date().toISOString(), text: t });
+  return save(cfg, notes.slice(-MAX_NOTES));
+}
+
+/**
+ * Remove a note. `which` may be a 1-based index, the string 'all', or a
+ * substring to match. Returns { notes, removed }.
+ */
+export function forgetNote(cfg, which) {
+  const notes = loadNotes(cfg);
+  if (String(which).toLowerCase() === 'all') {
+    save(cfg, []);
+    return { notes: [], removed: notes.length };
+  }
+  const idx = Number(which);
+  if (Number.isInteger(idx) && idx >= 1 && idx <= notes.length) {
+    const [gone] = notes.splice(idx - 1, 1);
+    save(cfg, notes);
+    return { notes, removed: gone ? 1 : 0 };
+  }
+  const needle = String(which || '').toLowerCase();
+  const before = notes.length;
+  const kept = needle ? notes.filter((n) => !n.text.toLowerCase().includes(needle)) : notes;
+  save(cfg, kept);
+  return { notes: kept, removed: before - kept.length };
+}
+
+/** Build the preamble message injected ahead of the conversation, or null. */
+export function memoryPreamble(cfg) {
+  const notes = loadNotes(cfg);
+  if (!notes.length) return null;
+  const body = notes.map((n) => `- ${n.text}`).join('\n');
+  return {
+    role: 'user',
+    content:
+      `[operator memory — standing notes to keep in mind for every answer; do not reply to this message directly]\n${body}`,
+  };
+}

package/src/tui/app.js

@@ -14,6 +14,19 @@ import { streamChat } from '../client.js';
 import { slashToQuestion, SLASH_COMMANDS } from '../commands.js';
 import { saveConfig } from '../config.js';
 import { shortModel } from '../ui.js';
+import { loadNotes, addNote, forgetNote, memoryPreamble } from '../memory.js';
+import { copyToClipboard } from '../clipboard.js';
+import { createGist } from '../gist.js';
+import { git as gitCmd, commitBackup } from '../gitrepo.js';
+
+// Split a command argument string into argv, honouring "quoted" segments.
+function splitArgs(s) {
+  const out = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m;
+  while ((m = re.exec(s))) out.push(m[1] ?? m[2] ?? m[3]);
+  return out;
+}
 
 function useTerminalSize() {
   const { stdout } = useStdout();
@@ -84,6 +97,16 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
   const ctrlC = useRef(0);       // timestamp of the last lone Ctrl+C
   const apRef = useRef(false);   // live autopilot flag (read inside runTurn)
   const modelRef = useRef(cfg._model); // preferred model to request
+  const lastAnswerRef = useRef('');    // most recent assistant answer (for /copy, /gist)
+  const choiceActionRef = useRef(null); // action to run when a non-AI Choice is picked
+
+  // Enable terminal bracketed-paste so multi-line pastes (mouse right-click or
+  // Cmd/Ctrl+V) arrive wrapped in markers as one block — the Composer inserts
+  // them with newlines preserved instead of submitting on the first newline.
+  useEffect(() => {
+    try { process.stdout.write('\x1b[?2004h'); } catch {}
+    return () => { try { process.stdout.write('\x1b[?2004l'); } catch {} };
+  }, []);
 
   const setAutopilotMode = useCallback((next) => {
     apRef.current = next;
@@ -93,7 +116,8 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
   const push = useCallback((item) => setItems((xs) => [...xs, { id: nextId(), ...item }]), []);
   const log = (line) => plain.current.push(line);
 
-  const runTurn = useCallback(async (question, depth = 0) => {
+  const runTurn = useCallback(async (question, opts = {}) => {
+    const { depth = 0, archive = null, label = '' } = opts;
     push({ type: 'user', text: question });
     log(`\n${glyphs.prompt} ${question}\n`);
     convo.current.push({ role: 'user', content: question });
@@ -114,7 +138,9 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
     if (modelRef.current) context.model = modelRef.current;
 
     try {
-      const { reply, text, meta } = await streamChat(cfg, [...convo.current], {
+      const preamble = memoryPreamble(cfg);
+      const outbound = preamble ? [preamble, ...convo.current] : [...convo.current];
+      const { reply, text, meta } = await streamChat(cfg, outbound, {
         signal: abort.signal,
         context,
         onEvent: (ev) => {
@@ -132,12 +158,25 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
       else if (type === 'prompt' || type === 'choice') { push({ type: 'assistant', text: text || reply.question || '' }); log(text || reply.question || ''); }
       else { push({ type: 'assistant', text: text || '(no response)' }); log(text || ''); }
       if (text) convo.current.push({ role: 'assistant', content: text });
+      lastAnswerRef.current = text || reply.summary || reply.question || lastAnswerRef.current;
+
+      // Archive a /backup answer to the per-user git repo.
+      if (archive === 'backup' && text) {
+        try {
+          const r = await commitBackup(cfg, label, text);
+          push({ type: 'notice',
+            text: `${glyphs.check} Backup saved to git repo (${r.file})${r.committed ? '' : ' — nothing new to commit'}.`,
+            color: C.green });
+        } catch (e) {
+          push({ type: 'notice', text: `${glyphs.warn} Could not archive backup: ${e.message}`, color: C.yellow });
+        }
+      }
 
       // Autopilot: auto-confirm a proposed plan without waiting for the user.
       if (type === 'plan' && apRef.current && depth < 3) {
         push({ type: 'notice', text: `${glyphs.bolt} autopilot ${dash()} applying fix…`, color: C.yellow });
         setLive(null); setBusy(false); abortRef.current = null;
-        return runTurn('apply fix', depth + 1);
+        return runTurn('apply fix', { depth: depth + 1 });
       }
 
       // Otherwise surface an interactive prompt for the user to choose/answer.
@@ -178,6 +217,29 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
 
   const doExit = useCallback(() => { onExit?.(plain.current); exit(); }, [exit, onExit]);
 
+  // Create a gist from the last answer or the whole transcript (invoked by the
+  // /gist Choice below).
+  const doGist = useCallback(async (kind) => {
+    let content, filename, description;
+    if (kind === 'transcript') {
+      content = convo.current.map((m) => `### ${m.role}\n\n${m.content}`).join('\n\n---\n\n') || '(empty)';
+      filename = 'icli-transcript.md';
+      description = 'iCli conversation transcript';
+    } else {
+      content = lastAnswerRef.current || '(no answer)';
+      filename = 'icli-answer.md';
+      description = 'iCli answer';
+    }
+    push({ type: 'notice', text: `${glyphs.arrow} Creating secret gist…`, color: C.gray });
+    try {
+      const { url } = await createGist(cfg, { filename, content, description, isPublic: false });
+      const tool = await copyToClipboard(url);
+      push({ type: 'notice', text: `${glyphs.check} Gist created: ${url}${tool ? ' (URL copied)' : ''}`, color: C.green });
+    } catch (e) {
+      push({ type: 'notice', text: `${glyphs.cross} ${e.message}`, color: C.red });
+    }
+  }, [cfg, push]);
+
   const onSubmit = useCallback((raw) => {
     const q = raw.trim();
     if (!q) return;
@@ -224,7 +286,7 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
         const head = c.group !== group ? ((group = c.group), `\n  ${c.group}\n`) : '';
         return head + `    ${(c.cmd + (c.hint ? ' ' + c.hint : '')).padEnd(22)}${c.desc}`;
       }).join('\n');
-      push({ type: 'notice', text: 'Commands:' + lines + '\n\n  Keys: Shift+Tab autopilot · Ctrl+T reasoning · Ctrl+L clear · Ctrl+C twice to exit' });
+      push({ type: 'notice', text: 'Commands:' + lines + '\n\n  Keys: Shift+Tab autopilot · Ctrl+T reasoning · Ctrl+Z/Ctrl+Y undo/redo · Ctrl+L clear · Ctrl+C twice to exit' });
       return;
     }
     if (q === '/history') {
@@ -235,18 +297,100 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
     if (q === '/logout') { onExternal?.('logout'); doExit(); return; }
     if (q === '/update') { onExternal?.('update'); doExit(); return; }
 
+    // ── Memory ──
+    if (q === '/remember' || q.startsWith('/remember ')) {
+      const note = q.slice('/remember'.length).trim();
+      if (!note) { push({ type: 'notice', text: 'Usage: /remember <note>' }); return; }
+      const notes = addNote(cfg, note);
+      push({ type: 'notice', text: `${glyphs.check} Remembered (${notes.length} note${notes.length > 1 ? 's' : ''}). I'll keep this in mind.`, color: C.green });
+      return;
+    }
+    if (q === '/memory') {
+      const notes = loadNotes(cfg);
+      push({ type: 'notice', text: notes.length
+        ? 'Memory notes:\n' + notes.map((n, i) => `  ${i + 1}. ${n.text}`).join('\n') + '\n\n  /forget <n|all> to remove.'
+        : 'No memory notes yet. Add one with /remember <note>.' });
+      return;
+    }
+    if (q === '/forget' || q.startsWith('/forget ')) {
+      const which = q.slice('/forget'.length).trim();
+      if (!which) { push({ type: 'notice', text: 'Usage: /forget <number | all | text>' }); return; }
+      const { notes, removed } = forgetNote(cfg, which);
+      push({ type: 'notice',
+        text: removed ? `${glyphs.check} Forgot ${removed} note(s). ${notes.length} remain.` : 'No matching note found.',
+        color: removed ? C.green : C.gray });
+      return;
+    }
+
+    // ── Clipboard ──
+    if (q === '/copy') {
+      const ans = lastAnswerRef.current;
+      if (!ans) { push({ type: 'notice', text: 'Nothing to copy yet — ask something first.', color: C.gray }); return; }
+      copyToClipboard(ans).then((tool) => push({ type: 'notice',
+        text: tool ? `${glyphs.check} Copied last answer (${ans.length} chars) to the clipboard.`
+                   : `${glyphs.cross} No clipboard tool found. Install xclip / wl-clipboard (Linux), or use macOS/Windows.`,
+        color: tool ? C.green : C.red }));
+      return;
+    }
+
+    // ── GitHub gist ──
+    if (q === '/gist' || q.startsWith('/gist ')) {
+      const rest = q.slice('/gist'.length).trim();
+      if (rest.startsWith('token ')) {
+        cfg.github_token = rest.slice('token '.length).trim();
+        try { saveConfig(cfg); } catch {}
+        push({ type: 'notice', text: `${glyphs.check} GitHub token saved. /gist will use it (needs the "gist" scope).`, color: C.green });
+        return;
+      }
+      if (!lastAnswerRef.current && convo.current.length === 0) {
+        push({ type: 'notice', text: 'Nothing to save yet — ask something first.', color: C.gray });
+        return;
+      }
+      choiceActionRef.current = (v) => doGist(v);
+      setChoice({
+        title: 'Create a secret gist from…',
+        note: '', sel: 0, text: '', focusText: false, allowText: false,
+        options: [
+          { label: 'The last AI answer', value: 'answer' },
+          { label: 'The entire conversation transcript', value: 'transcript' },
+          { label: 'Cancel', value: null },
+        ],
+      });
+      return;
+    }
+
+    // ── Local git repo ──
+    if (q === '/git' || q.startsWith('/git ')) {
+      const args = q.slice('/git'.length).trim();
+      if (!args) { push({ type: 'notice', text: 'Usage: /git <status | log | commit -m "msg" | push | diff | remote add origin <url>>' }); return; }
+      gitCmd(cfg, splitArgs(args)).then((r) => {
+        const body = (r.stdout || '').trim() || (r.stderr || '').trim() || (r.ok ? '(done)' : '(no output)');
+        push({ type: 'notice', text: `$ git ${args}\n${body.slice(0, 3500)}`, color: r.ok ? undefined : C.red });
+      });
+      return;
+    }
+
     let question = q;
+    const opts = {};
     if (q.startsWith('/')) {
       const mapped = slashToQuestion(q);
-      if (mapped) question = mapped;
-      else { push({ type: 'notice', text: `Unknown command: ${q}. Type /help.` }); return; }
+      if (mapped) {
+        question = mapped;
+        if (q === '/backup' || q.startsWith('/backup ')) {
+          opts.archive = 'backup';
+          opts.label = q.slice('/backup'.length).trim() || 'fleet';
+        }
+      } else { push({ type: 'notice', text: `Unknown command: ${q}. Type /help.` }); return; }
     }
-    runTurn(question);
-  }, [doExit, push, runTurn, onExternal, setAutopilotMode, model, cfg]);
+    runTurn(question, opts);
+  }, [doExit, push, runTurn, onExternal, setAutopilotMode, model, cfg, doGist]);
 
   // Interactive prompt/choice handling (owns the keyboard while open).
   const pickChoice = useCallback((value) => {
+    const act = choiceActionRef.current;
+    choiceActionRef.current = null;
     setChoice(null);
+    if (act) { if (value != null) act(value); else push({ type: 'notice', text: 'Cancelled.', color: C.gray }); return; }
     if (value == null) { push({ type: 'notice', text: 'Dismissed.', color: C.gray }); return; }
     runTurn(String(value));
   }, [push, runTurn]);

package/src/tui/composer.js

@@ -1,7 +1,7 @@
 // Bottom-pinned input composer with cursor editing, input history, readline
 // key bindings and a Copilot-style slash-command palette that appears ABOVE
 // the input and is navigable with the arrow keys.
-import { html, useState, useEffect, useCallback } from './dom.js';
+import { html, useState, useEffect, useCallback, useRef } from './dom.js';
 import { Box, Text, useInput } from 'ink';
 import { C, glyphs, borderStyle } from './theme.js';
 import { SLASH_COMMANDS } from '../commands.js';
@@ -27,6 +27,39 @@ export function Composer({ onSubmit, busy, width = 80 }) {
   const [histIdx, setHistIdx] = useState(-1);
   const [sel, setSel] = useState(0);
 
+  // Undo/redo history: snapshots of { value, cursor }. Consecutive typing is
+  // coalesced into a single undo step via `lastMut`.
+  const undoRef = useRef([]);
+  const redoRef = useRef([]);
+  const lastMut = useRef('');
+  const snapshot = (kind) => {
+    if (kind === 'type' && lastMut.current === 'type') return; // coalesce a typing run
+    undoRef.current.push({ value, cursor });
+    if (undoRef.current.length > 200) undoRef.current.shift();
+    redoRef.current = [];
+    lastMut.current = kind;
+  };
+
+  // Bracketed-paste assembly. A right-click / Cmd+V paste is wrapped by the
+  // terminal in \x1b[200~ … \x1b[201~ and can arrive split across several
+  // reads, so we buffer until the end marker before inserting.
+  const pasteRef = useRef({ active: false, buf: '' });
+
+  // Insert pasted text at the cursor, PRESERVING newlines so multi-line pastes
+  // (configs, logs) keep their structure. Tabs → 2 spaces; other control chars
+  // and the bracketed-paste markers are dropped.
+  const insertPaste = (raw) => {
+    const text = raw
+      .replace(/\x1b?\[20[01]~/g, '')
+      .replace(/\r\n?/g, '\n')
+      .replace(/\t/g, '  ')
+      .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
+    if (!text) return;
+    snapshot('paste');
+    setValue((v) => v.slice(0, cursor) + text + v.slice(cursor));
+    setCursor((c) => c + text.length);
+  };
+
   // Determine the token being typed at the cursor to drive the palette.
   const upto = value.slice(0, cursor);
   const tokStart = Math.max(upto.lastIndexOf(' '), upto.lastIndexOf('\n')) + 1;
@@ -45,6 +78,7 @@ export function Composer({ onSubmit, busy, width = 80 }) {
   const submit = useCallback((text) => {
     const q = text.trim();
     setValue(''); setCursor(0); setHistIdx(-1); setSel(0);
+    undoRef.current = []; redoRef.current = []; lastMut.current = '';
     if (q) {
       setHistory((h) => (h[h.length - 1] === q ? h : [...h, q]));
       onSubmit(q);
@@ -65,20 +99,49 @@ export function Composer({ onSubmit, busy, width = 80 }) {
   useInput((input, key) => {
     if (busy) return; // ignore edits while a turn streams (App handles Ctrl+C/Esc)
 
+    // ── Bracketed paste (mouse right-click / Cmd+V), possibly split reads ──
+    // Ink strips the leading ESC, so the terminal's \x1b[200~ … \x1b[201~
+    // wrappers arrive as the marker text "[200~" / "[201~" (sometimes as their
+    // own useInput calls). Buffer everything between them so embedded newlines
+    // are never treated as Enter, then insert the whole block at once.
+    const START = '[200~';
+    const END = '[201~';
+    if (pasteRef.current.active || input.includes(START)) {
+      pasteRef.current.active = true;
+      pasteRef.current.buf += input;
+      const e = pasteRef.current.buf.indexOf(END);
+      if (e === -1) return; // still receiving the paste
+      const s = pasteRef.current.buf.indexOf(START);
+      const raw = pasteRef.current.buf.slice(s + START.length, e);
+      pasteRef.current = { active: false, buf: '' };
+      insertPaste(raw);
+      return;
+    }
+
     // ── Submit / complete ──
-    if (key.return) {
+    // Some terminals/PTYs deliver Enter as input="\r" without key.return, so
+    // treat a lone CR/LF as Enter too (a paste is a longer chunk, never "\r").
+    const enter = key.return || input === '\r' || input === '\n';
+    if (enter) {
       // In slash mode Enter runs the command; in mention mode it completes.
       if (menuOpen && slashMode) { submit(matches[sel].cmd); return; }
       if (menuOpen && mentionMode) { complete(); return; }
       submit(value);
       return;
     }
-    if (input && /[\r\n]/.test(input)) {
-      const first = input.split(/[\r\n]/)[0];
-      submit(value.slice(0, cursor) + first + value.slice(cursor));
+    if (key.tab && !key.shift) { complete(); return; }
+
+    // ── Undo / redo ──
+    if (key.ctrl && input === 'z') {
+      const prev = undoRef.current.pop();
+      if (prev) { redoRef.current.push({ value, cursor }); setValue(prev.value); setCursor(prev.cursor); lastMut.current = 'undo'; }
+      return;
+    }
+    if (key.ctrl && (input === 'y' || (input === 'z' && key.shift))) {
+      const nx = redoRef.current.pop();
+      if (nx) { undoRef.current.push({ value, cursor }); setValue(nx.value); setCursor(nx.cursor); lastMut.current = 'redo'; }
       return;
     }
-    if (key.tab && !key.shift) { complete(); return; }
 
     // ── Menu / history navigation ──
     if (key.upArrow) {
@@ -115,31 +178,39 @@ export function Composer({ onSubmit, busy, width = 80 }) {
 
     // ── Deletion ──
     if (key.backspace || key.delete) {
-      if (cursor > 0) { setValue((v) => v.slice(0, cursor - 1) + v.slice(cursor)); setCursor((c) => c - 1); }
+      if (cursor > 0) { snapshot('del'); setValue((v) => v.slice(0, cursor - 1) + v.slice(cursor)); setCursor((c) => c - 1); }
       return;
     }
-    if (key.ctrl && input === 'u') { setValue(value.slice(cursor)); setCursor(0); return; }        // to start
-    if (key.ctrl && input === 'k') { setValue(value.slice(0, cursor)); return; }                    // to end
+    if (key.ctrl && input === 'u') { snapshot('cut'); setValue(value.slice(cursor)); setCursor(0); return; }        // to start
+    if (key.ctrl && input === 'k') { snapshot('cut'); setValue(value.slice(0, cursor)); return; }                    // to end
     if (key.ctrl && input === 'w') {                                                                // prev word
       let i = cursor;
       while (i > 0 && value[i - 1] === ' ') i--;
       while (i > 0 && value[i - 1] !== ' ') i--;
+      snapshot('cut');
       setValue(value.slice(0, i) + value.slice(cursor)); setCursor(i);
       return;
     }
 
-    // ── Printable input ──
+    // ── Printable input & paste ──
     if (input && !key.ctrl && !key.meta) {
-      const printable = input.replace(/[\x00-\x1f\x7f]/g, '');
-      if (!printable) return;
-      setValue((v) => v.slice(0, cursor) + printable + v.slice(cursor));
-      setCursor((c) => c + printable.length);
+      // A multi-char chunk or one containing newlines/tabs is a non-bracketed
+      // paste (terminal without bracketed-paste support): keep its newlines.
+      if (input.length > 1 || /[\r\n\t]/.test(input)) { insertPaste(input); return; }
+      const text = input.replace(/[\x00-\x1f\x7f]/g, '');
+      if (!text) return;
+      snapshot('type');
+      setValue((v) => v.slice(0, cursor) + text + v.slice(cursor));
+      setCursor((c) => c + text.length);
     }
   });
 
   const before = value.slice(0, cursor);
-  const at = value[cursor] ?? ' ';
-  const after = value.slice(cursor + 1);
+  const rawAt = value[cursor];
+  // When the cursor sits on a newline, show an inverse space and keep the line
+  // break in `after` so the buffer still renders across multiple lines.
+  const at = (rawAt === undefined || rawAt === '\n') ? ' ' : rawAt;
+  const after = rawAt === '\n' ? '\n' + value.slice(cursor + 1) : value.slice(cursor + 1);
   const empty = value.length === 0;
   const sugTok = menuOpen && matches[sel] ? (slashMode ? matches[sel].cmd : matches[sel].tag) : '';
   const ghost = sugTok && sugTok.startsWith(token) && cursor >= value.length ? sugTok.slice(token.length) : '';

package/src/userdir.js

@@ -0,0 +1,18 @@
+import { mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const BASE = join(homedir(), '.config', 'ispbills-icli');
+
+/** A filesystem-safe key identifying the logged-in IspBills user. */
+export function userKey(cfg) {
+  const raw = cfg?.user?.email || cfg?.user?.name || (cfg?.user?.id != null ? 'id-' + cfg.user.id : '') || 'default';
+  return String(raw).toLowerCase().replace(/[^a-z0-9._-]+/g, '_').slice(0, 64) || 'default';
+}
+
+/** Ensure and return a per-user subdirectory under the config dir. */
+export function userDir(cfg, ...parts) {
+  const dir = join(BASE, ...parts, userKey(cfg));
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}