prior-cli 1.0.0

package/bin/prior.js

@@ -0,0 +1,1092 @@
+#!/usr/bin/env node
+'use strict';
+
+const { program } = require('commander');
+const chalk       = require('chalk');
+const readline    = require('readline');
+const path        = require('path');
+const os          = require('os');
+const fs          = require('fs');
+const { version } = require('../package.json');
+
+const api = require('../lib/api');
+const { renderMarkdown } = require('../lib/render');
+const { getToken, getUsername, saveAuth, clearAuth } = require('../lib/config');
+
+// ── Theme ──────────────────────────────────────────────────────
+const THEME = '#9CE2D4';
+const c = {
+  brand:  t => chalk.hex(THEME)(t),
+  bold:   t => chalk.hex(THEME).bold(t),
+  dim:    t => chalk.dim(t),
+  muted:  t => chalk.gray(t),
+  err:    t => chalk.red(t),
+  warn:   t => chalk.yellow(t),
+  ok:     t => chalk.green(t),
+  link:   t => chalk.cyan.underline(t),
+  white:  t => chalk.white(t),
+};
+
+const DIVIDER = c.muted('  ' + '─'.repeat(50));
+
+// ── Spinner ────────────────────────────────────────────────────
+const SPIN_FRAMES = ['◐', '◓', '◑', '◒'];
+let _spinTimer = null;
+let _spinIdx   = 0;
+
+function spinStart(label = '') {
+  spinStop();
+  if (!process.stdout.isTTY) return;
+  _spinTimer = setInterval(() => {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    process.stdout.write(`  ${c.brand(SPIN_FRAMES[_spinIdx++ % 4])}  ${c.dim(label)}`);
+  }, 100);
+}
+
+function spinStop() {
+  if (_spinTimer) { clearInterval(_spinTimer); _spinTimer = null; }
+  if (process.stdout.isTTY) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+  }
+}
+
+// ── Helpers ────────────────────────────────────────────────────
+function requireAuth() {
+  if (!getToken()) {
+    console.error(c.err('  ✗ Not logged in. Run: ') + c.brand('prior login'));
+    process.exit(1);
+  }
+}
+
+function progressBar(pct, width = 22) {
+  const filled = Math.round((pct / 100) * width);
+  return c.brand('█'.repeat(filled)) + c.muted('░'.repeat(width - filled));
+}
+
+function clearLine() {
+  if (process.stdout.isTTY) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+  }
+}
+
+// ── /learn scanner animation ───────────────────────────────────
+async function runLearnAnimation(cwd) {
+  const SKIP = new Set(['node_modules', '.git', '__pycache__', '.next', 'dist', 'build',
+                        '.venv', 'venv', '.cache', 'coverage', '.nyc_output', 'vendor']);
+  const TEXT = new Set(['.js','.ts','.jsx','.tsx','.py','.json','.md','.txt','.html',
+                        '.css','.scss','.yml','.yaml','.sh','.bat','.go','.rs','.java',
+                        '.c','.cpp','.h','.php','.rb','.vue','.svelte','.env','.toml','.ini']);
+
+  const files = [];
+  function walk(dir, depth = 0) {
+    if (depth > 6) return;
+    try {
+      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (e.name.startsWith('.') || SKIP.has(e.name)) continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) walk(full, depth + 1);
+        else files.push({ full, rel: path.relative(cwd, full), ext: path.extname(e.name).toLowerCase() });
+      }
+    } catch {}
+  }
+  walk(cwd);
+  if (!files.length) return 0;
+
+  const HEIGHT = 8;
+  const cols   = Math.min(process.stdout.columns || 100, 120);
+  const delay  = Math.max(15, Math.min(90, 3200 / files.length));
+  const window = [];
+
+  // Reserve space
+  process.stdout.write('\n'.repeat(HEIGHT));
+  process.stdout.write(`\x1b[${HEIGHT}A\x1b[s`);
+
+  for (let i = 0; i < files.length; i++) {
+    const f = files[i];
+
+    // Read snippet for text files only
+    if (TEXT.has(f.ext)) {
+      try {
+        if (fs.statSync(f.full).size < 150 * 1024) {
+          f.snippet = fs.readFileSync(f.full, 'utf8').replace(/\s+/g, ' ').trim().slice(0, 70);
+        }
+      } catch {}
+    }
+
+    window.push(f);
+    if (window.length > HEIGHT - 1) window.shift();
+
+    process.stdout.write('\x1b[u');
+
+    // Header
+    const spin = SPIN_FRAMES[Math.floor(i / 2) % 4];
+    const pct  = Math.round(((i + 1) / files.length) * 100);
+    const bar  = progressBar(pct, 14);
+    process.stdout.write(`\x1b[2K  ${c.brand(spin)}  ${c.bold('Learning directory')}  ${bar}  ${c.muted(`${i + 1}/${files.length}`)}\n`);
+
+    // File lines
+    for (let j = 0; j < HEIGHT - 1; j++) {
+      process.stdout.write('\x1b[2K');
+      const entry = window[j];
+      if (!entry) { process.stdout.write('\n'); continue; }
+
+      const isActive  = j === window.length - 1;
+      const connector = isActive ? '└' : '├';
+      const maxName   = 30;
+      const name      = entry.rel.length > maxName
+        ? '…' + entry.rel.slice(-(maxName - 1))
+        : entry.rel;
+      const snipLen   = cols - maxName - 16;
+      const snippet   = (entry.snippet || '').slice(0, snipLen);
+
+      if (isActive) {
+        process.stdout.write(`  ${c.brand(connector)} ${c.bold(name.padEnd(maxName))}  ${c.muted(snippet)}\n`);
+      } else {
+        process.stdout.write(`  ${c.muted(connector)} ${c.muted(name.padEnd(maxName))}  ${c.dim(snippet.slice(0, 35))}\n`);
+      }
+    }
+
+    await new Promise(r => setTimeout(r, delay));
+  }
+
+  // Final frame — full bar
+  process.stdout.write('\x1b[u');
+  process.stdout.write(`\x1b[2K  ${c.brand('◈')}  ${c.bold('Learning directory')}  ${progressBar(100, 14)}  ${c.ok(`${files.length} files`)}\n`);
+  for (let i = 0; i < HEIGHT - 1; i++) process.stdout.write('\x1b[2K\n');
+  process.stdout.write('\x1b[u');
+  await new Promise(r => setTimeout(r, 400));
+
+  // Clear
+  for (let i = 0; i < HEIGHT; i++) process.stdout.write('\x1b[2K\n');
+  process.stdout.write(`\x1b[${HEIGHT}A`);
+
+  return files.length;
+}
+
+function promptPassword(question) {
+  return new Promise(resolve => {
+    if (!process.stdin.isTTY) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question(question, ans => { rl.close(); resolve(ans.trim()); });
+      return;
+    }
+    process.stdout.write(question);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    let input = '';
+    function handler(ch) {
+      switch (ch) {
+        case '\n': case '\r': case '\u0004':
+          process.stdin.setRawMode(false);
+          process.stdin.removeListener('data', handler);
+          process.stdin.pause();
+          process.stdout.write('\n');
+          resolve(input);
+          break;
+        case '\u0003': process.exit(); break;
+        case '\u007f':
+          if (input.length) { input = input.slice(0, -1); process.stdout.write('\b \b'); }
+          break;
+        default:
+          input += ch;
+          process.stdout.write('*');
+      }
+    }
+    process.stdin.on('data', handler);
+  });
+}
+
+function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, ans => resolve(ans.trim())));
+}
+
+function banner() {
+  console.log('');
+  console.log(c.brand('  ██████╗ ██████╗ ██╗ ██████╗ ██████╗ '));
+  console.log(c.brand('  ██╔══██╗██╔══██╗██║██╔═══██╗██╔══██╗'));
+  console.log(c.brand('  ██████╔╝██████╔╝██║██║   ██║██████╔╝'));
+  console.log(c.brand('  ██╔═══╝ ██╔══██╗██║██║   ██║██╔══██╗'));
+  console.log(c.brand('  ██║     ██║  ██║██║╚██████╔╝██║  ██║'));
+  console.log(c.brand('  ╚═╝     ╚═╝  ╚═╝╚═╝ ╚═════╝ ╚═╝  ╚═╝'));
+  console.log('');
+  console.log(c.muted(`  v${version}  ·  prior.ngrok.app`));
+  console.log('');
+}
+
+// ── Time helpers ───────────────────────────────────────────────
+function timeNow() {
+  return new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: true });
+}
+function elapsed(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+// ── Tool call display ──────────────────────────────────────────
+const TOOL_ICONS = {
+  file_read:       '📄',
+  file_write:      '✏️ ',
+  file_append:     '📝',
+  file_list:       '📁',
+  file_delete:     '🗑 ',
+  web_search:      '🔍',
+  url_fetch:       '🌐',
+  run_command:     '⚡',
+  clipboard_read:  '📋',
+  clipboard_write: '📋',
+  generate_image:  '🎨',
+  prior_feed:      '📰',
+  prior_profile:   '👤',
+};
+
+function toolIcon(name) {
+  return TOOL_ICONS[name] || '⎔ ';
+}
+
+let _toolStartTime = 0;
+
+function renderToolStart(name, args) {
+  _toolStartTime = Date.now();
+  const icon    = toolIcon(name);
+  const label   = c.bold(name.padEnd(16));
+  const preview = Object.values(args || {})[0];
+  const hint    = preview ? c.muted(String(preview).slice(0, 80)) : '';
+  process.stdout.write(`  ${icon}  ${label} ${hint}\n`);
+}
+
+function hyperlink(text, url) {
+  return `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\`;
+}
+
+function renderToolDone(name, summary) {
+  const took  = _toolStartTime ? c.dim(` · ${elapsed(Date.now() - _toolStartTime)}`) : '';
+  const label = c.muted(name.padEnd(16));
+  let display = summary || '';
+  if (/^[a-zA-Z]:[/\\]/.test(display) || display.startsWith('/')) {
+    const fileUrl = 'file:///' + display.replace(/\\/g, '/');
+    display = hyperlink(c.dim(display), fileUrl);
+  } else {
+    display = c.dim(display);
+  }
+  process.stdout.write(`  ${c.ok('✓')}  ${label} ${display}${took}\n`);
+}
+
+function renderToolError(name, error) {
+  const took  = _toolStartTime ? c.dim(` · ${elapsed(Date.now() - _toolStartTime)}`) : '';
+  const label = c.muted(name.padEnd(16));
+  process.stdout.write(`  ${c.err('✗')}  ${label} ${c.err(error || 'failed')}${took}\n`);
+}
+
+// ── Browser login via public URL ───────────────────────────────
+async function loginViaBrowser() {
+  const open   = require('open');
+  const crypto = require('crypto');
+
+  // Generate a random state token to match the browser session to this CLI wait
+  const state = crypto.randomBytes(16).toString('hex');
+  const url   = `https://prior.ngrok.app/cli-auth?state=${state}`;
+
+  await open(url).catch(() => {
+    process.stdout.write('\n');
+    console.log(c.muted(`  Open in browser: ${url}\n`));
+  });
+
+  // Long-poll the CLI backend until browser completes login (3 min timeout handled server-side)
+  const fetch = require('node-fetch');
+  const res = await fetch(`http://127.0.0.1:7100/wait?state=${state}`, {
+    timeout: 185000,
+  });
+
+  if (!res.ok) throw new Error('Login timed out or was cancelled');
+  const data = await res.json();
+  if (!data.token) throw new Error('No token received');
+  return { token: data.token, username: data.username };
+}
+
+// ── Inline login flow ──────────────────────────────────────────
+async function doLoginFlow() {
+  console.log(c.bold('  Sign in\n'));
+  console.log(`  ${c.brand('[1]')}  Login manually`);
+  console.log(`  ${c.brand('[2]')}  Login in browser`);
+  console.log('');
+
+  const choiceRl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const choice   = await ask(choiceRl, c.muted('  Choice [1/2] : '));
+  choiceRl.close();
+  console.log('');
+
+  if (choice === '2') {
+    process.stdout.write(c.dim('  Opening browser…'));
+    try {
+      const { token, username } = await loginViaBrowser();
+      saveAuth(token, username);
+      clearLine();
+      console.log(c.ok('  ✓ Logged in as ') + c.bold(username));
+      console.log('');
+      return username;
+    } catch (err) {
+      clearLine();
+      throw err;
+    }
+  }
+
+  // Default: manual
+  const manualRl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const username = await ask(manualRl, c.muted('  Username : '));
+  manualRl.close();
+  const password = await promptPassword(c.muted('  Password : '));
+  console.log('');
+  process.stdout.write(c.dim('  Authenticating…'));
+  const data = await api.login(username, password);
+  saveAuth(data.token, username);
+  clearLine();
+  console.log(c.ok('  ✓ Logged in as ') + c.bold(username));
+  console.log('');
+  return username;
+}
+
+// ── Interactive Chat ───────────────────────────────────────────
+async function startChat(opts = {}) {
+  // If not logged in, prompt inline instead of erroring out
+  if (!getToken()) {
+    banner();
+    try {
+      await doLoginFlow();
+    } catch (err) {
+      clearLine();
+      console.error(c.err(`  ✗ ${err.message}`));
+      process.exit(1);
+    }
+  }
+
+  const user = getUsername();
+
+  // Check if agent backend is running
+  spinStart('connecting…');
+  const backendHealth = await api.checkBackend();
+  spinStop();
+
+  const agentMode = !!backendHealth;
+
+  console.clear();
+  banner();
+  console.log(DIVIDER);
+
+  // Header row
+  const modelLabel = opts.model || 'default';
+  const cwdShort   = process.cwd().replace(os.homedir(), '~');
+  console.log(
+    c.brand('  Prior AI') +
+    c.muted('  ·  ') +
+    c.bold(`@${user}`) +
+    c.muted(`  ·  ${modelLabel}`)
+  );
+  console.log(c.muted(`  ${cwdShort}`));
+
+  if (agentMode) {
+    console.log(c.ok('  ◉') + c.muted('  Agent mode  ') + c.dim('· file  web  shell  image  prior-network'));
+  } else {
+    console.log(c.warn('  ◎') + c.muted('  Basic mode  ') + c.dim('· run prior-cli-backend for agent mode'));
+  }
+
+  if (opts.uncensored) console.log(c.warn('  ⚠  Uncensored mode active'));
+  console.log(DIVIDER);
+  console.log(c.muted('  /help  /clear  /model <name>  /tools  /uncensored  /exit'));
+  console.log(DIVIDER);
+  console.log('');
+
+  // Conversation history (for agent mode, keeps full multi-turn context)
+  const chatHistory = [];
+  let currentModel = opts.model || null;
+  let uncensored   = opts.uncensored || false;
+
+  const rl = readline.createInterface({
+    input:    process.stdin,
+    output:   process.stdout,
+    terminal: true,
+    historySize: 100,
+    completer: line => {
+      const cmds = ['/help', '/clear', '/model ', '/tools', '/uncensored', '/censored', '/login', '/logout', '/exit'];
+      if (!line.startsWith('/')) return [[], line];
+      const hits = cmds.filter(cmd => cmd.startsWith(line));
+      return [hits, line];
+    },
+  });
+
+  // ── Live slash-command suggestions ──────────────────────────
+  let clearSuggestions = () => {};
+
+  if (process.stdout.isTTY) {
+    readline.emitKeypressEvents(process.stdin, rl);
+
+    const SLASH_CMDS = [
+      { cmd: '/help',        desc: 'Show help'         },
+      { cmd: '/clear',       desc: 'Clear screen'      },
+      { cmd: '/model',       desc: 'Switch model'      },
+      { cmd: '/tools',       desc: 'List tools'        },
+      { cmd: '/uncensored',  desc: 'Uncensored mode'   },
+      { cmd: '/censored',    desc: 'Standard mode'     },
+      { cmd: '/usage',       desc: 'Token usage today' },
+      { cmd: '/learn',       desc: 'Learn this directory → prior.md' },
+      { cmd: '/login',       desc: 'Sign in'           },
+      { cmd: '/logout',      desc: 'Sign out'          },
+      { cmd: '/exit',        desc: 'Exit'              },
+    ];
+
+    let _suggCount = 0;
+    let _suggTimer = null;
+
+    clearSuggestions = function () {
+      if (_suggCount === 0) return;
+      process.stdout.write('\x1b[s');
+      for (let i = 0; i < _suggCount; i++) process.stdout.write('\x1b[B\r\x1b[2K');
+      process.stdout.write('\x1b[u');
+      _suggCount = 0;
+    };
+
+    function renderSuggestions(matches) {
+      clearSuggestions();
+      if (!matches.length) return;
+      _suggCount = matches.length;
+      // Print newlines to scroll terminal and guarantee room below the prompt
+      process.stdout.write('\n'.repeat(matches.length));
+      process.stdout.write(`\x1b[${matches.length}A`); // move cursor back up
+      process.stdout.write('\x1b[s');                   // save cursor (now at prompt line)
+      for (const { cmd, desc } of matches) {
+        process.stdout.write(`\x1b[B\r\x1b[2K${c.brand('  ' + cmd.padEnd(14))}${c.dim(desc)}`);
+      }
+      process.stdout.write('\x1b[u');
+    }
+
+    process.stdin.on('keypress', (ch, key) => {
+      if (!key) return;
+
+      if (_suggTimer) { clearTimeout(_suggTimer); _suggTimer = null; }
+
+      if (key.name === 'return' || key.name === 'enter' || (key.ctrl && key.name === 'c')) {
+        clearSuggestions();
+        return;
+      }
+
+      _suggTimer = setTimeout(() => {
+        _suggTimer = null;
+        const line = rl.line || '';
+        if (!line.startsWith('/')) {
+          clearSuggestions();
+          return;
+        }
+        const word    = line.split(' ')[0];
+        const matches = SLASH_CMDS.filter(({ cmd }) => cmd.startsWith(word));
+        renderSuggestions(matches);
+      }, 50);
+    });
+  }
+
+  // ── Load prior.md if present ────────────────────────────────
+  const priorMdPath = path.join(process.cwd(), 'prior.md');
+  let projectContext = null;
+  try {
+    projectContext = fs.readFileSync(priorMdPath, 'utf8');
+    console.log(c.brand('  ◈') + c.muted('  prior.md loaded — project context active'));
+    console.log('');
+  } catch { /* no prior.md, fine */ }
+
+  let restarting   = false;
+  let msgCount     = 0;
+  const sessionStart = Date.now();
+
+  rl.on('close', () => {
+    if (restarting) return;
+    const dur = elapsed(Date.now() - sessionStart);
+    console.log('');
+    console.log(c.muted(`  ─────────────────────────────────────────────────`));
+    console.log(c.muted(`  Session ended  ·  ${msgCount} message${msgCount !== 1 ? 's' : ''}  ·  ${dur}`));
+    console.log('');
+    process.exit(0);
+  });
+
+  const PROMPT = () => c.brand('  ❯ ');
+
+  const loop = () => {
+    rl.question(PROMPT(), async raw => {
+      clearSuggestions();
+      const input = raw.trim();
+      if (!input) return loop();
+
+      // ── Slash commands ──────────────────────────────────────
+      if (input.startsWith('/')) {
+        const [cmd, ...args] = input.split(' ');
+        switch (cmd) {
+
+          case '/exit':
+          case '/quit':
+            return rl.close();
+
+          case '/login': {
+            restarting = true;
+            rl.close();
+            console.log('');
+            try {
+              await doLoginFlow();
+            } catch (err) {
+              clearLine();
+              console.error(c.err(`  ✗ ${err.message}\n`));
+            }
+            return startChat({ model: currentModel, uncensored });
+          }
+
+          case '/logout':
+            clearAuth();
+            console.log(c.ok('  ✓ Logged out.\n'));
+            return loop();
+
+          case '/clear':
+            console.clear();
+            banner();
+            console.log(DIVIDER);
+            console.log(c.brand('  Prior AI') + c.muted('  ·  ') + c.muted(`@${user}`));
+            if (agentMode) console.log(c.ok('  ◉') + c.muted('  Agent mode'));
+            console.log(DIVIDER);
+            console.log('');
+            return loop();
+
+          case '/uncensored':
+            uncensored = true;
+            console.log(c.warn('  ⚠  Uncensored mode enabled\n'));
+            return loop();
+
+          case '/censored':
+            uncensored = false;
+            console.log(c.ok('  ✓  Standard mode restored\n'));
+            return loop();
+
+          case '/model':
+            if (args[0]) {
+              currentModel = args[0];
+              console.log(c.ok(`  ✓  Model → ${currentModel}\n`));
+            } else {
+              console.log(c.muted(`  Current model: ${currentModel || 'default'}\n`));
+            }
+            return loop();
+
+          case '/tools':
+            console.log('');
+            console.log(c.bold('  Tools available in agent mode\n'));
+            const tools = [
+              ['file_read',       'Read a file'],
+              ['file_write',      'Create or overwrite a file'],
+              ['file_append',     'Append to a file'],
+              ['file_list',       'List directory contents'],
+              ['file_delete',     'Delete a file'],
+              ['web_search',      'Search the web (Google)'],
+              ['url_fetch',       'Fetch a webpage (Puppeteer)'],
+              ['run_command',     'Execute a shell command'],
+              ['clipboard_read',  'Read from clipboard'],
+              ['clipboard_write', 'Write to clipboard'],
+              ['generate_image',  'Generate an image (Prior Diffusion)'],
+              ['prior_feed',      'Get Prior Network feed'],
+              ['prior_profile',   'Get your Prior Network profile'],
+            ];
+            tools.forEach(([name, desc]) => {
+              console.log(`  ${c.brand('▸')} ${c.bold(name.padEnd(16))} ${c.muted(desc)}`);
+            });
+            console.log('');
+            if (!agentMode) console.log(c.warn('  ⚠  Backend offline — start prior-cli-backend to enable\n'));
+            return loop();
+
+          case '/learn': {
+            // Sanity check — warn if not a project directory
+            const cwdBase = path.basename(process.cwd()).toLowerCase();
+            const NON_PROJECT = ['downloads', 'desktop', 'documents', 'pictures', 'videos', 'music', 'temp', 'tmp'];
+            if (NON_PROJECT.includes(cwdBase)) {
+              console.log('');
+              console.log(c.warn(`  ⚠  You're in "${path.basename(process.cwd())}" — this doesn't look like a project directory.`));
+              console.log(c.muted('     cd into your project folder first, then run /learn.'));
+              console.log('');
+              return loop();
+            }
+
+            console.log('');
+            await runLearnAnimation(process.cwd());
+            console.log('');
+
+            // ── Build flat file list ──────────────────────────
+            const flatFiles = [];
+            function collectFiles(dir, depth = 0) {
+              if (depth > 4) return;
+              const SKIP = new Set(['node_modules','.git','__pycache__','.next','dist','build','.venv','venv','.cache']);
+              try {
+                for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+                  if (e.name.startsWith('.') || SKIP.has(e.name)) continue;
+                  const full = path.join(dir, e.name);
+                  const rel  = path.relative(process.cwd(), full).replace(/\\/g, '/');
+                  if (e.isDirectory()) collectFiles(full, depth + 1);
+                  else flatFiles.push(rel);
+                }
+              } catch {}
+            }
+            collectFiles(process.cwd());
+
+            // ── Read key files locally (no agent tool calls needed) ──
+            const KEY_NAMES = ['package.json','README.md','readme.md','README.txt',
+                               'server.js','Server.js','app.js','App.js','index.js',
+                               'main.js','main.py','app.py','index.ts','main.ts',
+                               'pyproject.toml','requirements.txt','Cargo.toml','go.mod'];
+
+            const readSnippets = [];
+            const MAX_READ = 6;
+            const MAX_BYTES = 2000;
+
+            // First pass: exact key name matches at root or one level deep
+            const keyMatches = flatFiles.filter(f => {
+              const base = path.basename(f);
+              return KEY_NAMES.includes(base);
+            }).slice(0, MAX_READ);
+
+            for (const rel of keyMatches) {
+              try {
+                const full    = path.join(process.cwd(), rel);
+                const content = fs.readFileSync(full, 'utf8').slice(0, MAX_BYTES);
+                readSnippets.push(`### ${rel}\n\`\`\`\n${content}\n\`\`\``);
+              } catch {}
+            }
+
+            const fileList = flatFiles.slice(0, 120).join('\n');
+
+            const learnPrompt = `You are analyzing a project directory. Based on the file list and file contents below, write a prior.md file that documents this project.
+
+## File list
+${fileList}${flatFiles.length > 120 ? `\n… (${flatFiles.length - 120} more files)` : ''}
+
+## Key file contents
+${readSnippets.length ? readSnippets.join('\n\n') : '(no key files found)'}
+
+## Instructions
+Write prior.md immediately using the <write path="prior.md"> tag. Include:
+- Project name and purpose (1-2 sentences)
+- Tech stack (languages, frameworks, key libraries)
+- Key files and what they do
+- Any important conventions or notes
+
+Keep it under 350 words. Write prior.md now.`;
+
+            let learnTextBuffer = '';
+
+            try {
+              await api.agentChat(
+                [{ role: 'user', content: learnPrompt }],
+                { model: currentModel, uncensored, cwd: process.cwd() },
+                ev => {
+                  switch (ev.type) {
+                    case 'thinking':   spinStart('writing…'); break;
+                    case 'tool_start':
+                      spinStop();
+                      renderToolStart(ev.name, ev.args);
+                      spinStart('working…');
+                      break;
+                    case 'tool_done':  spinStop(); renderToolDone(ev.name, ev.summary); break;
+                    case 'tool_error': spinStop(); renderToolError(ev.name, ev.error); break;
+                    case 'text':
+                      spinStop();
+                      learnTextBuffer += (ev.content || '');
+                      break;
+                    case 'done': spinStop(); break;
+                    case 'error': spinStop(); console.error(c.err(`  ✗ ${ev.message}`)); break;
+                  }
+                }
+              );
+
+              // Text fallback: if model returned markdown content but didn't use write tag
+              if (!fs.existsSync(priorMdPath) && learnTextBuffer.length > 80) {
+                try { fs.writeFileSync(priorMdPath, learnTextBuffer, 'utf8'); } catch {}
+              }
+
+              // Reload prior.md into context
+              try {
+                projectContext = fs.readFileSync(priorMdPath, 'utf8');
+                console.log(c.ok('  ✓') + c.muted('  prior.md written — context active for this session'));
+              } catch {
+                console.log(c.warn('  ⚠  prior.md was not created'));
+              }
+            } catch (err) {
+              spinStop();
+              console.error(c.err(`  ✗ ${err.message}`));
+            }
+            console.log('');
+            return loop();
+          }
+
+          case '/usage': {
+            try {
+              const data  = await api.getUsage();
+              const used  = data.used ?? data.tokens_used ?? data.tokensUsed ?? data.totalTokens ?? 0;
+              const limit = data.limit ?? data.token_limit ?? data.dailyLimit ?? null;
+              const pct   = limit ? Math.min(100, Math.round((used / limit) * 100)) : null;
+              console.log('');
+              if (pct !== null) {
+                console.log(`  ${progressBar(pct)}`);
+                console.log(`  ${c.bold(used.toLocaleString())} ${c.muted('/')} ${limit.toLocaleString()} tokens  ${c.muted(`(${pct}%)`)}`);
+              } else {
+                console.log(`  ${c.bold(used.toLocaleString())} tokens used today`);
+              }
+              console.log('');
+            } catch (err) {
+              console.error(c.err(`  ✗ ${err.message}\n`));
+            }
+            return loop();
+          }
+
+          case '/help':
+            console.log('');
+            console.log(c.bold('  Commands'));
+            console.log(c.muted('  /clear               ') + 'Clear screen');
+            console.log(c.muted('  /model <name>        ') + 'Switch AI model');
+            console.log(c.muted('  /tools               ') + 'List available tools');
+            console.log(c.muted('  /uncensored          ') + 'Enable uncensored mode');
+            console.log(c.muted('  /censored            ') + 'Disable uncensored mode');
+            console.log(c.muted('  /usage               ') + 'Token usage for today');
+            console.log(c.muted('  /learn               ') + 'Scan directory and write prior.md context file');
+            console.log(c.muted('  /login               ') + 'Sign in to a different account');
+            console.log(c.muted('  /logout              ') + 'Sign out');
+            console.log(c.muted('  /exit                ') + 'Exit Prior');
+            console.log(c.muted('  ↑ ↓                  ') + 'Browse message history');
+            console.log('');
+            console.log(c.bold('  Other commands  ') + c.muted('(run outside chat)'));
+            console.log(c.muted('  prior imagine <prompt>  ') + 'Generate an image');
+            console.log(c.muted('  prior models            ') + 'List AI models');
+            console.log(c.muted('  prior history           ') + 'Chat history');
+            console.log(c.muted('  prior usage             ') + 'Token usage');
+            console.log(c.muted('  prior weather <city>    ') + 'Weather');
+            console.log('');
+            return loop();
+
+          default:
+            console.log(c.err(`  Unknown command: ${cmd}\n`));
+            return loop();
+        }
+      }
+
+      // ── Send message ────────────────────────────────────────
+      msgCount++;
+      console.log('');
+
+      if (agentMode) {
+        // ── Agent mode: full tool loop ──────────────────────
+        let responseText      = '';
+        let responseStarted   = false;
+        let _progressStarted  = false;
+        const _thinkStart     = Date.now();
+
+        spinStart('thinking…');
+
+        try {
+          await api.agentChat(
+            [...chatHistory, { role: 'user', content: input }],
+            { model: currentModel, uncensored, cwd: process.cwd(), projectContext },
+            ev => {
+              switch (ev.type) {
+
+                case 'thinking':
+                  spinStart('thinking…');
+                  break;
+
+                case 'tool_start':
+                  spinStop();
+                  _progressStarted = false;
+                  renderToolStart(ev.name, ev.args);
+                  spinStart('working…');
+                  break;
+
+                case 'tool_progress': {
+                  if (!_progressStarted) {
+                    spinStop();
+                    process.stdout.write('\n');
+                    _progressStarted = true;
+                  } else {
+                    process.stdout.clearLine(0);
+                    process.stdout.cursorTo(0);
+                  }
+                  const pct = ev.percent || 0;
+                  const bar = progressBar(pct, 20);
+                  process.stdout.write(`  ${c.brand('◈')}  ${bar}  ${c.muted(`${ev.step}/${ev.total}`)}  ${c.brand(`${pct}%`)}`);
+                  break;
+                }
+
+                case 'tool_done':
+                  spinStop();
+                  renderToolDone(ev.name, ev.summary);
+                  break;
+
+                case 'tool_error':
+                  spinStop();
+                  renderToolError(ev.name, ev.error);
+                  break;
+
+                case 'text': {
+                  spinStop();
+                  const rendered = renderMarkdown(ev.content);
+                  const thinkTime = elapsed(Date.now() - _thinkStart);
+                  console.log(c.brand('  Prior  ') + c.muted(`·  ${timeNow()}  ·  ${thinkTime}`));
+                  console.log('');
+                  console.log(rendered);
+                  responseText += ev.content;
+                  responseStarted = true;
+                  break;
+                }
+
+                case 'done':
+                  spinStop();
+                  break;
+
+                case 'error':
+                  spinStop();
+                  process.stdout.write('\n');
+                  console.error(c.err(`  ✗ ${ev.message}`));
+                  break;
+              }
+            }
+          );
+        } catch (err) {
+          spinStop();
+          console.error(c.err(`  ✗ ${err.message}`));
+        }
+
+        // Update history
+        chatHistory.push({ role: 'user', content: input });
+        if (responseText) chatHistory.push({ role: 'assistant', content: responseText });
+
+        process.stdout.write('\n');
+
+      } else {
+        // ── Basic mode: direct API, no tools ───────────────
+        process.stdout.write(c.brand('  Prior  ') + c.muted('· '));
+
+        try {
+          await api.generate(input, { model: currentModel, uncensored }, chunk => {
+            process.stdout.write(chunk);
+          });
+        } catch (err) {
+          process.stdout.write('\n');
+          console.error(c.err(`  ✗ ${err.message}`));
+        }
+
+        process.stdout.write('\n\n');
+      }
+
+      loop();
+    });
+  };
+
+  loop();
+}
+
+// ── LOGIN ──────────────────────────────────────────────────────
+program
+  .command('login')
+  .description('Log in to your Prior Network account')
+  .action(async () => {
+    banner();
+    console.log(c.bold('  Sign in\n'));
+    const rl       = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const username = await ask(rl, c.muted('  Username : '));
+    rl.close();
+    const password = await promptPassword(c.muted('  Password : '));
+    console.log('');
+    process.stdout.write(c.dim('  Authenticating…'));
+    try {
+      const data = await api.login(username, password);
+      saveAuth(data.token, username);
+      clearLine();
+      console.log(c.ok('  ✓ Logged in as ') + c.bold(username));
+      console.log(c.muted('\n  Run "prior" to start chatting.\n'));
+    } catch (err) {
+      clearLine();
+      console.error(c.err(`  ✗ ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+// ── LOGOUT ─────────────────────────────────────────────────────
+program
+  .command('logout')
+  .description('Log out and clear saved credentials')
+  .action(() => {
+    clearAuth();
+    console.log(c.ok('  ✓ Logged out.'));
+  });
+
+// ── WHOAMI ─────────────────────────────────────────────────────
+program
+  .command('whoami')
+  .description('Show currently logged-in user')
+  .action(() => {
+    const user = getUsername();
+    console.log('');
+    if (!user) console.log(c.muted('  Not logged in.'));
+    else       console.log(`  ${c.bold(user)}`);
+    console.log('');
+  });
+
+// ── CHAT ───────────────────────────────────────────────────────
+program
+  .command('chat', { isDefault: false })
+  .description('Open Prior AI chat session (default when no command given)')
+  .option('-m, --model <model>', 'Model to use')
+  .option('-u, --uncensored',    'Enable uncensored mode')
+  .action(opts => startChat(opts));
+
+// ── IMAGINE ────────────────────────────────────────────────────
+program
+  .command('imagine <prompt>')
+  .description('Generate an image with Prior Diffusion')
+  .option('-s, --size <WxH>', 'Resolution e.g. 1024x1024', '896x896')
+  .option('--steps <n>',      'Diffusion steps', '20')
+  .option('--open',           'Open saved image when done')
+  .action(async (prompt, opts) => {
+    requireAuth();
+    const fs   = require('fs');
+    const [width, height] = (opts.size || '896x896').split('x').map(Number);
+    const steps = parseInt(opts.steps) || 20;
+    console.log('');
+    console.log(c.bold('  Prior Diffusion'));
+    console.log(c.muted('  Prompt : ') + c.white(`"${prompt}"`));
+    console.log(c.muted(`  Size   : ${width}×${height}  ·  Steps: ${steps}`));
+    console.log('');
+    try {
+      const { promptId } = await api.generateImage(prompt, { width, height, steps });
+      if (!promptId) throw new Error('No promptId returned.');
+      let done = false;
+      while (!done) {
+        await new Promise(r => setTimeout(r, 900));
+        try {
+          const p = await api.pollImageProgress(promptId);
+          clearLine();
+          process.stdout.write(`  ${progressBar(p.percent ?? 0)} ${String(p.percent ?? 0).padStart(3)}%`);
+          if (p.status === 'complete' || p.filename) {
+            done = true;
+            clearLine();
+            const downloadsDir = path.join(os.homedir(), 'Downloads');
+            const savePath = path.join(downloadsDir, p.filename);
+            process.stdout.write(c.dim('  Downloading…'));
+            try {
+              const imgRes = await api.downloadImage(p.filename);
+              const buf = await imgRes.buffer();
+              fs.writeFileSync(savePath, buf);
+              clearLine();
+              console.log(c.ok('  ✓ Saved  ') + c.white(savePath));
+            } catch (dlErr) {
+              clearLine();
+              console.log(c.ok('  ✓ Done!'));
+              console.log(c.warn(`  ⚠  Could not save: ${dlErr.message}`));
+            }
+            console.log('');
+            if (opts.open) { const open = require('open'); await open(savePath); }
+          } else if (p.status === 'error') {
+            done = true; clearLine();
+            console.error(c.err('  ✗ Generation failed.'));
+          }
+        } catch { /* keep polling */ }
+      }
+    } catch (err) {
+      console.error(c.err(`  ✗ ${err.message}`));
+    }
+  });
+
+// ── MODELS ─────────────────────────────────────────────────────
+program
+  .command('models')
+  .description('List available AI models')
+  .action(async () => {
+    requireAuth();
+    try {
+      const data   = await api.getModels();
+      const models = data.models || data;
+      console.log('');
+      console.log(c.bold('  Available Models\n'));
+      (Array.isArray(models) ? models : []).forEach(m => {
+        const name = typeof m === 'string' ? m : (m.name || m.model || '');
+        console.log(`  ${c.brand('▸')} ${name}`);
+      });
+      console.log('');
+    } catch (err) { console.error(c.err(`  ✗ ${err.message}`)); }
+  });
+
+// ── HISTORY ────────────────────────────────────────────────────
+program
+  .command('history')
+  .description('List recent chat sessions')
+  .option('-n, --limit <n>', 'Number to show', '20')
+  .action(async opts => {
+    requireAuth();
+    try {
+      const data  = await api.getChats();
+      const chats = (data.chats || data || []).slice(0, parseInt(opts.limit));
+      console.log('');
+      console.log(c.bold('  Chat History\n'));
+      if (!chats.length) { console.log(c.muted('  No chats yet.')); }
+      else chats.forEach((ch, i) => {
+        const title = (ch.title || 'Untitled').slice(0, 50);
+        const msgs  = ch.message_count ? c.muted(` ${ch.message_count} msgs`) : '';
+        const date  = ch.updated_at ? c.muted(' · ' + new Date(ch.updated_at).toLocaleDateString()) : '';
+        console.log(`  ${c.muted(String(i + 1).padStart(3))}  ${c.white(title)}${msgs}${date}`);
+      });
+      console.log('');
+    } catch (err) { console.error(c.err(`  ✗ ${err.message}`)); }
+  });
+
+// ── USAGE ──────────────────────────────────────────────────────
+program
+  .command('usage')
+  .description('Show token usage for today')
+  .action(async () => {
+    requireAuth();
+    try {
+      const data  = await api.getUsage();
+      const used  = data.used ?? data.tokens_used ?? data.tokensUsed ?? 0;
+      const limit = data.limit ?? data.token_limit ?? data.dailyLimit ?? null;
+      const pct   = limit ? Math.min(100, Math.round((used / limit) * 100)) : null;
+      console.log('');
+      console.log(c.bold('  Token Usage — Today\n'));
+      if (pct !== null) {
+        console.log(`  ${progressBar(pct)}`);
+        console.log(`  ${c.bold(used.toLocaleString())} / ${limit.toLocaleString()} tokens  ${c.muted(`(${pct}%)`)}`);
+      } else {
+        console.log(`  ${c.bold(used.toLocaleString())} tokens used today`);
+      }
+      console.log('');
+    } catch (err) { console.error(c.err(`  ✗ ${err.message}`)); }
+  });
+
+// ── WEATHER ────────────────────────────────────────────────────
+program
+  .command('weather <location>')
+  .description('Get weather for a location')
+  .action(async location => {
+    requireAuth();
+    try {
+      const data   = await api.getWeather(location);
+      const pretty = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+      console.log('');
+      console.log(c.bold(`  Weather — ${location}\n`));
+      console.log('  ' + pretty.split('\n').join('\n  '));
+      console.log('');
+    } catch (err) { console.error(c.err(`  ✗ ${err.message}`)); }
+  });
+
+// ── Entry point ────────────────────────────────────────────────
+program
+  .name('prior')
+  .description('Prior Network — AI command-line interface')
+  .version(version, '-v, --version', 'Print version');
+
+const args = process.argv.slice(2);
+
+if (args.length === 0 || (args.length === 1 && args[0].startsWith('-') && args[0] !== '--help' && args[0] !== '-h')) {
+  startChat();
+} else {
+  program.parse(process.argv);
+}