@vierratale/ai 0.1.0-beta.7 → 0.1.0-beta.9

package/src/providers/openai.js

@@ -57,7 +57,7 @@ export class OpenAIProvider extends BaseProvider {
 
   async *stream(messages, options = {}) {
     const key = Config.get('openaiApiKey');
-    if (!key) throw new Error('Cloud API key not configured');
+    if (!key) throw new Error('[ERR-0004] Cloud API key not configured. Add it to the config and try again.');
 
     const model = this._resolveModel(options);
     const systemPrompt = options.systemPrompt || '';
@@ -70,47 +70,78 @@ export class OpenAIProvider extends BaseProvider {
       apiMessages.push({ role: msg.role, content: msg.content });
     }
 
-    const resp = await fetch('https://api.openai.com/v1/chat/completions', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${key}`,
-      },
-      body: JSON.stringify({
-        model,
-        messages: apiMessages,
-        stream: true,
-        temperature: options.temperature || Config.get('temperature'),
-        max_tokens: options.maxTokens || Config.get('maxTokens'),
-      }),
-    });
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 240000);
+
+    let resp;
+    try {
+      resp = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${key}`,
+        },
+        body: JSON.stringify({
+          model,
+          messages: apiMessages,
+          stream: true,
+          temperature: options.temperature || Config.get('temperature'),
+          max_tokens: options.maxTokens || Config.get('maxTokens'),
+        }),
+        signal: controller.signal,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error('[ERR-0001] Could not reach the API (no response within 60s). Check your network connection.');
+      }
+      throw new Error('[ERR-0001] Could not reach the API (no response). Check your network connection.');
+    } finally {
+      clearTimeout(connectTimer);
+    }
 
     if (!resp.ok) {
-      throw new Error('Failed to connect to cloud engine');
+      throw new Error('[ERR-0003] The cloud provider returned HTTP ' + resp.status + '. Check your API key in config.');
     }
 
     const reader = resp.body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
-
-      for (const line of lines) {
-        if (!line.startsWith('data: ')) continue;
-        const data = line.slice(6);
-        if (data === '[DONE]') return;
+    let idle = null;
+    const settle = () => {
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), 240000);
+    };
+    settle();
+    try {
+      while (true) {
+        let value, done;
         try {
-          const json = JSON.parse(data);
-          const content = json.choices?.[0]?.delta?.content;
-          if (content) yield content;
-        } catch {}
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (err.name === 'AbortError') {
+            throw new Error('[ERR-0001] Lost the connection to the cloud API (no data for 60s).');
+          }
+          throw err;
+        }
+        if (done) break;
+        settle();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6);
+          if (data === '[DONE]') return;
+          try {
+            const json = JSON.parse(data);
+            const content = json.choices?.[0]?.delta?.content;
+            if (content) yield content;
+          } catch {}
+        }
       }
+    } finally {
+      if (idle) clearTimeout(idle);
     }
   }
 }

package/src/session.js

@@ -1,16 +1,141 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { Config } from './config.js';
 
-const SESSION_FILE = join(Config.getConfigDir(), 'history.json');
+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 {
-      if (existsSync(SESSION_FILE)) {
-        const raw = readFileSync(SESSION_FILE, 'utf-8');
-        const data = JSON.parse(raw || '[]');
+      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 {}
@@ -19,23 +144,78 @@ export const Session = {
 
   save(messages) {
     try {
-      const dir = Config.getConfigDir();
-      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-      writeFileSync(SESSION_FILE, JSON.stringify(messages.slice(-MAX_MESSAGES), null, 2));
+      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 {
-      if (existsSync(SESSION_FILE)) writeFileSync(SESSION_FILE, '[]');
+      ensureDir();
+      writeFileSync(pathFor(this.activeName()), '[]');
     } catch {}
   },
 
   hasHistory() {
-    try {
-      return existsSync(SESSION_FILE) && (JSON.parse(readFileSync(SESSION_FILE, 'utf-8') || '[]').length > 0);
-    } catch {
-      return false;
-    }
+    return this.loadActive().length > 0;
   },
-};
+};

package/src/ui/branding.js

@@ -1,6 +1,6 @@
 export const Branding = {
   APP_NAME: 'VierrataleAI',
-  VERSION: '0.1.0-beta.6',
+  VERSION: '0.1.0-beta.9',
 
   colors: {
     primary: '\x1b[38;2;124;58;237m',

package/src/ui/chatbox.js

@@ -0,0 +1,271 @@
+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.
+function columnWidth(termWidth) {
+  const w = termWidth && termWidth > 44 ? termWidth : 96;
+  return Math.max(40, Math.min(100, w - 8));
+}
+
+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;
+  }
+
+  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 rows = process.stdout.isTTY && process.stdout.rows > 8 ? process.stdout.rows : 999;
+    const lines = out.join('\n').split('\n').slice(1);
+    const body = lines.length > rows ? lines.slice(lines.length - rows) : lines;
+    process.stdout.write('\x1b[2J\x1b[H' + body.join('\n') + '\n');
+  }
+}