@vierratale/ai 0.1.0-beta.1 → 0.1.0-beta.10

package/src/session.js

@@ -0,0 +1,221 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { Config } from './config.js';
+
+const ROOT = join(Config.getConfigDir(), 'sessions');
+const ACTIVE_FILE = join(ROOT, '.active');
+const MIGRATED_FLAG = join(ROOT, '.migrated');
+const MAX_MESSAGES = 20;
+
+const sanitize = (name) =>
+  String(name || '').replace(/[^A-Za-z0-9._-]/g, '-').replace(/^-+|-+$/g, '').slice(0, 60) || 'default';
+
+const pathFor = (name) => join(ROOT, `${sanitize(name)}.json`);
+const backupPathFor = (name) => join(ROOT, `${sanitize(name)}.bak.json`);
+
+const autoName = () => {
+  const d = new Date();
+  const p = (n) => String(n).padStart(2, '0');
+  return `session-${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${p(d.getMilliseconds())}`;
+};
+
+function ensureDir() {
+  if (!existsSync(ROOT)) mkdirSync(ROOT, { recursive: true });
+}
+
+function migrateLegacy() {
+  // One-time move of the old single history.json into a session named "default".
+  // The .migrated flag guarantees the legacy file can never resurrect a deleted
+  // "default" session on later runs.
+  try {
+    const legacy = join(Config.getConfigDir(), 'history.json');
+    if (existsSync(legacy) && !existsSync(MIGRATED_FLAG)) {
+      if (!existsSync(pathFor('default'))) {
+        const data = JSON.parse(readFileSync(legacy, 'utf-8') || '[]');
+        if (Array.isArray(data) && data.length) {
+          writeFileSync(pathFor('default'), JSON.stringify(data.slice(-MAX_MESSAGES), null, 2));
+        }
+      }
+      writeFileSync(MIGRATED_FLAG, new Date().toISOString());
+    }
+  } catch {}
+}
+
+export const Session = {
+  activeName() {
+    ensureDir();
+    migrateLegacy();
+    try {
+      if (existsSync(ACTIVE_FILE)) {
+        const name = readFileSync(ACTIVE_FILE, 'utf-8').trim();
+        if (name && existsSync(pathFor(name))) return name;
+      }
+    } catch {}
+    if (!existsSync(pathFor('default'))) writeFileSync(pathFor('default'), '[]');
+    writeFileSync(ACTIVE_FILE, 'default');
+    return 'default';
+  },
+
+  list() {
+    ensureDir();
+    migrateLegacy();
+    const out = [];
+    const active = this.activeName();
+    for (const f of readdirSync(ROOT)) {
+      if (!f.endsWith('.json')) continue;
+      const name = f.slice(0, -5);
+      try {
+        const msgs = JSON.parse(readFileSync(join(ROOT, f), 'utf-8') || '[]');
+        const first = msgs.find((m) => m.role === 'user');
+        out.push({
+          name,
+          count: msgs.length,
+          preview: first ? String(first.content).slice(0, 60) : '(empty)',
+          updated: statSync(join(ROOT, f)).mtimeMs,
+          active: name === active,
+        });
+      } catch {}
+    }
+    out.sort((a, b) => b.updated - a.updated);
+    return out;
+  },
+
+  create(name) {
+    ensureDir();
+    const safe = sanitize(name || autoName());
+    writeFileSync(pathFor(safe), '[]');
+    writeFileSync(ACTIVE_FILE, safe);
+    return safe;
+  },
+
+  open(name) {
+    const sessions = this.list();
+    let target = name;
+    if (/^#\d+$/.test(name)) {
+      const idx = parseInt(name.slice(1), 10);
+      const s = sessions[idx - 1];
+      if (!s) return null;
+      target = s.name;
+    }
+    const safe = sanitize(target);
+    if (!existsSync(pathFor(safe))) return null;
+    writeFileSync(ACTIVE_FILE, safe);
+    return safe;
+  },
+
+  remove(name) {
+    const sessions = this.list();
+    let target = name;
+    if (/^#\d+$/.test(name)) {
+      const idx = parseInt(name.slice(1), 10);
+      const s = sessions[idx - 1];
+      if (!s) return null;
+      target = s.name;
+    }
+    const safe = sanitize(target);
+    const file = pathFor(safe);
+    if (!existsSync(file)) return null;
+    if (safe === this.activeName()) {
+      const others = sessions.filter((s) => s.name !== safe);
+      if (others.length) {
+        writeFileSync(ACTIVE_FILE, others[0].name);
+      } else {
+        writeFileSync(ACTIVE_FILE, this.create(null));
+      }
+    }
+    try { unlinkSync(file); } catch {}
+    return safe;
+  },
+
+  load() {
+    return this.loadActive();
+  },
+
+  loadActive() {
+    try {
+      const path = pathFor(this.activeName());
+      if (existsSync(path)) {
+        const data = JSON.parse(readFileSync(path, 'utf-8') || '[]');
+        if (Array.isArray(data)) return data.slice(-MAX_MESSAGES);
+      }
+    } catch {}
+    return [];
+  },
+
+  save(messages) {
+    try {
+      ensureDir();
+      writeFileSync(pathFor(this.activeName()), JSON.stringify(messages.slice(-MAX_MESSAGES), null, 2));
+    } catch {}
+  },
+
+  // Snapshot the active session to a timestamped .bak.json before it is
+  // replaced or cleared, so a fresh-start or /new never loses the old talk.
+  autoBackup() {
+    try {
+      ensureDir();
+      const name = this.activeName();
+      const src = pathFor(name);
+      if (!existsSync(src)) return null;
+      const msgs = JSON.parse(readFileSync(src, 'utf-8') || '[]');
+      if (!Array.isArray(msgs) || msgs.length === 0) return null;
+      const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const dest = backupPathFor(`${name}.${stamp}`);
+      writeFileSync(dest, JSON.stringify(msgs, null, 2));
+      return `${name}.${stamp}.bak.json`;
+    } catch { return null; }
+  },
+
+  backup() {
+    return this.autoBackup();
+  },
+
+  // List .bak.json recovery copies for the sessions UI.
+  listBackups() {
+    ensureDir();
+    const out = [];
+    for (const f of readdirSync(ROOT)) {
+      if (!f.endsWith('.bak.json')) continue;
+      const name = f.slice(0, -'.bak.json'.length);
+      try {
+        out.push({ name, file: f, updated: statSync(join(ROOT, f)).mtimeMs });
+      } catch {}
+    }
+    out.sort((a, b) => b.updated - a.updated);
+    return out;
+  },
+
+  // Restore a backup: copy the .bak.json content back into a normal session file
+  // (creating <name>-restored if the original still exists) and switch to it.
+  restoreBackup(file) {
+    try {
+      ensureDir();
+      let fname = String(file || '').trim();
+      if (!fname.endsWith('.bak.json')) {
+        if (!fname.endsWith('.json')) fname += '.bak.json';
+      }
+      const safe = sanitize(fname.replace(/\.bak\.json$/, ''));
+      const src = backupPathFor(safe);
+      if (!existsSync(src)) return null;
+      const msgs = JSON.parse(readFileSync(src, 'utf-8') || '[]');
+      if (!Array.isArray(msgs)) return null;
+      const base = sanitize(safe.replace(/\.\d{4}-\d{2}-\d{2}T[\d-]+$/, ''));
+      let target = base;
+      if (existsSync(pathFor(target))) target = `${base}-restored`;
+      writeFileSync(pathFor(target), JSON.stringify(msgs.slice(-MAX_MESSAGES), null, 2));
+      writeFileSync(ACTIVE_FILE, target);
+      return target;
+    } catch { return null; }
+  },
+
+  clear() {
+    try {
+      ensureDir();
+      writeFileSync(pathFor(this.activeName()), '[]');
+    } catch {}
+  },
+
+  hasHistory() {
+    return this.loadActive().length > 0;
+  },
+};

package/src/ui/banner.js

@@ -2,10 +2,14 @@ import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { Branding } from './branding.js';
+import { Terminal } from './terminal.js';
+import { Config } from '../config.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 export function loadSystemPrompt() {
+  const custom = Config.get('systemPrompt');
+  if (custom) return custom;
   try {
     const jsonPath = join(__dirname, '..', 'prompts', 'system.json');
     const data = JSON.parse(readFileSync(jsonPath, 'utf-8'));
@@ -15,17 +19,24 @@ export function loadSystemPrompt() {
   }
 }
 
-export function showBanner(provider, model) {
-  console.log(Branding.colors.primary + Branding.BANNER + Branding.colors.reset);
-  console.log(
-    `  ${Branding.colors.dim}Intelligent Terminal Assistant${Branding.colors.reset}`
-  );
-  console.log(
-    `  ${Branding.colors.accent}Model:${Branding.colors.reset} ${model}  ` +
-    `${Branding.colors.accent}Engine:${Branding.colors.reset} ${provider}`
-  );
-  console.log(
-    `  ${Branding.colors.dim}Type /help for commands, /quit to exit${Branding.colors.reset}`
-  );
+export function showBanner(providerName, model, providerDisplayName) {
+  const C = Branding.colors;
+  const width = 44;
+  const border = `  ╔${'═'.repeat(width)}╗`;
+  const visible = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+  const pad = (s) => s + ' '.repeat(Math.max(1, width - visible(s).length));
+
+  console.log();
+  console.log(`${C.primary}${Branding.BANNER}${C.reset}`);
+  console.log(`  ${C.bold}${C.accent}▸ Vierratale AI ▸ ${providerDisplayName || 'Cortex'} Engine${C.reset}`);
+  console.log();
+  console.log(border);
+  console.log(`  ║${pad('  ' + C.bold + C.primary + 'Model' + C.reset)}║`);
+  console.log(`  ║${pad('   ' + C.accent + model + C.reset)}║`);
+  console.log(`  ║${pad('  ' + C.bold + C.primary + 'Engine' + C.reset)}║`);
+  console.log(`  ║${pad('   ' + C.accent + (providerDisplayName || 'Cortex') + C.reset)}║`);
+  console.log(`  ╚${'═'.repeat(width)}╝`);
+  console.log();
+  console.log(`  ${C.dim}Type /help for commands · /quit to exit${C.reset}`);
   console.log();
 }

package/src/ui/branding.js

@@ -1,6 +1,6 @@
 export const Branding = {
   APP_NAME: 'VierrataleAI',
-  VERSION: '0.1.0-beta.1',
+  VERSION: '0.1.0-beta.10',
 
   colors: {
     primary: '\x1b[38;2;124;58;237m',
@@ -14,14 +14,13 @@ export const Branding = {
   },
 
   BANNER: [
-    '',
-    '  ██╗   ██╗██╗██████╗ ███████╗',
-    '  ██║   ██║██║██╔══██╗██╔════╝',
-    '  ██║   ██║██║██████╔╝█████╗  ',
-    '  ╚██╗ ██╔╝██║██╔══██╗██╔══╝  ',
-    '   ╚████╔╝ ██║██████╔╝███████╗',
-    '    ╚═══╝  ╚═╝╚═════╝ ╚══════╝',
-    '',
+    '               _',
+    '  _   _ _                      / \\ _______',
+    ' | | | |                      / _ \\\\_  _ /',
+    ' | | | |_  ___ _ __ _ __ __ _/ /_\\ \\ | |  ',
+    ' | | | | |/ _ \\ \'__| \'__/ _` |  _  | | |  ',
+    ' \\ \\_/ / |  __/ |  | | | (_| | | | |_| |_ ',
+    '  \\___/|_|\\___|_|  |_|  \\__,_|_| |_/\\___/ ',
   ].join('\n'),
 
   USER_PROMPT: 'You',

package/src/ui/chatbox.js

@@ -0,0 +1,280 @@
+import { Branding } from './branding.js';
+
+const C = Branding.colors;
+
+const visible = (s) => s.replace(/\x1b\[[0-9;]*m/g, '').length;
+
+function padRight(text, width) {
+  const t = String(text ?? '');
+  return t + ' '.repeat(Math.max(0, width - visible(t)));
+}
+
+function wrapLines(text, width) {
+  const out = [];
+  const src = String(text ?? '');
+  for (const raw of src.split('\n')) {
+    if (!raw.trim()) {
+      out.push('');
+      continue;
+    }
+    const words = raw.split(/\s+/).filter(Boolean);
+    let cur = '';
+    for (const word of words) {
+      if (word.length >= width) {
+        if (cur) {
+          out.push(cur);
+          cur = '';
+        }
+        for (let i = 0; i < word.length; i += width) out.push(word.slice(i, i + width));
+        continue;
+      }
+      const next = cur ? `${cur} ${word}` : word;
+      if (visible(next) > width) {
+        if (cur) out.push(cur);
+        cur = word;
+      } else {
+        cur = next;
+      }
+    }
+    if (cur) out.push(cur);
+  }
+  return out;
+}
+
+function hardWrap(text, width) {
+  const out = [];
+  const src = String(text ?? '').replace(/\t/g, '  ');
+  for (const raw of src.split('\n')) {
+    if (visible(raw) <= width) {
+      out.push(raw);
+    } else {
+      for (let i = 0; i < raw.length; i += width) out.push(raw.slice(i, i + width));
+    }
+  }
+  return out;
+}
+
+// Column geometry: true-full width, then a centered column like opencode.
+export function columnWidth(termWidth) {
+  const w = termWidth && termWidth > 44 ? termWidth : 96;
+  return Math.max(40, Math.min(100, w - 8));
+}
+
+export function centerPad(col, termWidth) {
+  const w = termWidth && termWidth > 44 ? termWidth : 96;
+  const pad = Math.max(0, Math.floor((w - col) / 2));
+  return ' '.repeat(pad);
+}
+
+function highlight(text) {
+  return String(text)
+    .replace(/\*\*([^*]+)\*\*/g, `${C.bold}$1${C.reset}`)
+    .replace(/`([^`]+)`/g, `${C.accent}$1${C.reset}`);
+}
+
+function splitBlocks(text) {
+  const blocks = [];
+  const re = /```([\w./+-]*)[^\n]*\n?([\s\S]*?)(?:```|$)/g;
+  let last = 0;
+  let m;
+  while ((m = re.exec(String(text)))) {
+    if (m.index > last) blocks.push({ code: false, text: text.slice(last, m.index) });
+    blocks.push({ code: true, lang: m[1] || 'code', content: m[2] });
+    last = m.index + m[0].length;
+  }
+  if (last < text.length) blocks.push({ code: false, text: text.slice(last) });
+  return blocks;
+}
+
+export class FrameThrottle {
+  constructor(render, min = 40) {
+    this.render = render;
+    this.min = min;
+    this.last = 0;
+  }
+
+  schedule() {
+    const now = performance.now();
+    if (now - this.last >= this.min) {
+      this.last = now;
+      this.render();
+    }
+  }
+
+  flush() {
+    this.render();
+  }
+}
+
+export class ChatUI {
+  constructor({ model = '', engine = '' } = {}) {
+    this.model = model;
+    this.engine = engine;
+    this.status = '';
+    this.notices = [];
+    this.streaming = null;
+    this.thinking = false;
+    this.compositor = null;
+  }
+
+  setCompositor(fn) {
+    this.compositor = fn;
+  }
+
+  width() {
+    const w = process.stdout.columns;
+    return w && w > 44 ? w : 96;
+  }
+
+  setModel(model, engine) {
+    this.model = model;
+    this.engine = engine;
+  }
+
+  setStatus(text) {
+    this.status = String(text ?? '');
+  }
+
+  setThinking(flag) {
+    this.thinking = !!flag;
+    this.streaming = null;
+  }
+
+  setStreaming(text) {
+    this.streaming = String(text ?? '');
+    this.thinking = false;
+  }
+
+  notify(text) {
+    if (text) this.notices.push(String(text));
+  }
+
+  clearNotices() {
+    this.notices = [];
+  }
+
+  _codeBox(lang, content, w) {
+    const out = [];
+    const c = C.success;
+    // The box lives inside the centered column and carries its own 4-space
+    // indent, so draw it at (w - 4) to stay inside the column.
+    const box = Math.max(8, w - 4);
+    const inner = Math.max(1, box - 8);
+    const head = `    ${c}╭─${C.reset} ${C.bold}${c}${lang || 'code'}${C.reset}${c} `;
+    const fill = Math.max(0, box - visible(head) - 1);
+    out.push(`${head}${'─'.repeat(fill)}╮${C.reset}`);
+    const lines = hardWrap(content, inner);
+    while (lines.length && lines[lines.length - 1].trim() === '') lines.pop();
+    if (!lines.length) lines.push('');
+    for (const line of lines) {
+      out.push(`    ${c}│${C.reset} ${padRight(line, inner)} ${c}│${C.reset}`);
+    }
+    out.push(`    ${c}╰${'─'.repeat(Math.max(0, box - 6))}╯${C.reset}`);
+    return out;
+  }
+
+  _contentRows(content, w) {
+    const rows = [];
+    const width = Math.max(20, w - 4);
+    const blocks = splitBlocks(content);
+    for (const b of blocks) {
+      if (b.code) {
+        rows.push(...this._codeBox(b.lang, b.content, w));
+      } else {
+        const lines = wrapLines(b.text, width);
+        if (lines.length === 0) lines.push('');
+        for (const line of lines) {
+          rows.push(line.trim() === '' ? '' : `    ${highlight(line)}`);
+        }
+      }
+    }
+    return rows;
+  }
+
+  _centered(row) {
+    return `${centerPad(columnWidth(process.stdout.columns), process.stdout.columns)}${row}`;
+  }
+
+  // Banner drawn as part of the full clear+draw cycle so it can never be
+  // wiped by a later render (the old showBanner() was erased instantly).
+  _bannerRows(col) {
+    const out = [];
+    // Center the art as a BLOCK: pad every line to the widest one, then use a
+    // single shared left indent so the llama's rows stay glued together.
+    const art = Branding.BANNER.split('\n').map((l) => l.trimEnd());
+    const artW = Math.max(...art.map((l) => visible(l)));
+    const padL = Math.max(0, Math.floor((col - artW) / 2));
+    for (const line of art) {
+      out.push(`${' '.repeat(padL)}${C.primary}${line}${C.reset}`);
+    }
+    const center = (s) => {
+      const p = Math.max(0, Math.floor((col - visible(s)) / 2));
+      return `${' '.repeat(p)}${s}`;
+    };
+    out.push(center(`${C.bold}${C.accent}▸ ${Branding.APP_NAME} · ${this.model} · ${this.engine}${C.reset}`));
+    out.push('');
+    const box = Math.max(24, col - 6);
+    const padR = (s) => s + ' '.repeat(Math.max(1, box - visible(s)));
+    // Border is `  ┌` + (box+2) dashes + `┐` = box+6 wide, matching every row.
+    const borderLine = `  ${C.primary}┌${'─'.repeat(box + 2)}┐${C.reset}`;
+    out.push(center(borderLine));
+    out.push(center(`  ${C.primary}│${C.reset} ${padR('  ' + C.bold + C.primary + 'Model' + C.reset)} ${C.primary}│${C.reset}`));
+    out.push(center(`  ${C.primary}│${C.reset} ${padR('   ' + C.accent + this.model + C.reset)} ${C.primary}│${C.reset}`));
+    out.push(center(`  ${C.primary}│${C.reset} ${padR('  ' + C.bold + C.primary + 'Engine' + C.reset)} ${C.primary}│${C.reset}`));
+    out.push(center(`  ${C.primary}│${C.reset} ${padR('   ' + C.accent + this.engine + C.reset)} ${C.primary}│${C.reset}`));
+    out.push(center(`  ${C.primary}└${'─'.repeat(box + 2)}┘${C.reset}`));
+    out.push('');
+    out.push(center(`${C.dim}Type /help for commands · /quit to exit${C.reset}`));
+    out.push('');
+    return out;
+  }
+
+  render(messages) {
+    const w = this.width();
+    const col = columnWidth(w);
+    const out = [];
+    out.push(`\x1b[2J\x1b[H`);
+    // Banner (opencode style header) at the top of the centered column.
+    out.push(...this._bannerRows(col));
+    if (this.status) out.push(this._centered(`  ${C.dim}${this.status}${C.reset}`));
+    out.push('');
+
+    for (const m of messages || []) {
+      if (!m || m.hidden || !m.content) continue;
+      const title = m.role === 'user' ? 'You' : Branding.AI_PROMPT;
+      const color = m.role === 'user' ? C.accent : C.primary;
+      out.push(this._centered(`  ${C.bold}${color}${title}${C.reset}`));
+      for (const row of this._contentRows(m.content, col)) {
+        out.push(this._centered(row));
+      }
+      out.push('');
+    }
+
+    if (this.thinking) {
+      out.push(this._centered(`  ${C.bold}${C.primary}${Branding.AI_PROMPT}${C.reset}`));
+      out.push(this._centered(`    ${C.dim}···${C.reset}`));
+      out.push('');
+    } else if (this.streaming !== null) {
+      out.push(this._centered(`  ${C.bold}${C.primary}${Branding.AI_PROMPT}${C.reset}`));
+      const rows = this._contentRows(this.streaming, col);
+      for (const r of rows.length ? rows : ['    ']) out.push(this._centered(r));
+      out.push('');
+    }
+
+    for (const n of this.notices) {
+      for (const line of wrapLines(n, col - 4)) out.push(this._centered(`  ${C.dim}${line}${C.reset}`));
+    }
+    if (this.notices.length) out.push('');
+
+    // Keep the latest content pinned to the bottom of the terminal so streaming
+    // never re-scrolls through older messages (which caused a flash).
+    const isTty = process.stdout.isTTY && process.stdout.rows > 8;
+    const rows = isTty ? process.stdout.rows : 999;
+    const reserved = this.compositor ? Math.max(0, this.compositor.reservedRows()) : 0;
+    const available = Math.max(3, rows - reserved);
+    const lines = out.join('\n').split('\n').slice(1);
+    const body = lines.length > available ? lines.slice(lines.length - available) : lines;
+    process.stdout.write('\x1b[2J\x1b[H' + body.join('\n') + '\n');
+    if (this.compositor) this.compositor.draw();
+  }
+}