@vierratale/ai 0.1.0-beta.6 → 0.1.0-beta.8

package/README.md

@@ -32,12 +32,12 @@ Local models run through the **Cortex** engine:
 
 | Model | Backend |
 |-------|---------|
-| vierratale-lite | qwen2.5-coder:0.5b |
-| vierratale-fast | qwen2.5-coder:1.5b |
-| vierratale-small | qwen2.5-coder:3b |
-| vierratale-balanced | qwen2.5-coder:7b |
-| vierratale-plus | qwen2.5-coder:14b |
-| vierratale-pro | qwen2.5-coder:32b |
+| vierratale-lite | qwen3:0.6b |
+| vierratale-fast | gemma3:1b |
+| vierratale-small | llama3.2:1b |
+| vierratale-balanced | qwen2.5:1.5b |
+| vierratale-plus | qwen3:1.7b |
+| vierratale-pro | qwen2.5:3b |
 
 Cloud models are available when the matching provider + API key is configured:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vierratale/ai",
-  "version": "0.1.0-beta.6",
+  "version": "0.1.0-beta.8",
   "description": "VierrataleAI - Intelligent terminal assistant",
   "type": "module",
   "bin": {

package/src/catalog.js

@@ -1,10 +1,10 @@
 const MODELS = {
-  'qwen2.5-coder:0.5b': 'vierratale-lite',
-  'qwen2.5-coder:1.5b': 'vierratale-fast',
-  'qwen2.5-coder:3b': 'vierratale-small',
-  'qwen2.5-coder:7b': 'vierratale-balanced',
-  'qwen2.5-coder:14b': 'vierratale-plus',
-  'qwen2.5-coder:32b': 'vierratale-pro',
+  'qwen3:0.6b': 'vierratale-lite',
+  'gemma3:1b': 'vierratale-fast',
+  'llama3.2:1b': 'vierratale-small',
+  'qwen2.5:1.5b': 'vierratale-balanced',
+  'qwen3:1.7b': 'vierratale-plus',
+  'qwen2.5:3b': 'vierratale-pro',
   'gpt-4o-mini': 'vierratale-cloud-mini',
   'gpt-4o': 'vierratale-cloud',
   'claude-3-5-haiku-20241022': 'vierratale-cloud-fast',

package/src/cli.js

@@ -7,6 +7,7 @@ import { Branding } from './ui/branding.js';
 import { Terminal } from './ui/terminal.js';
 import { loadSystemPrompt, showBanner } from './ui/banner.js';
 import { WebSearch } from './utils/websearch.js';
+import { WebFetch } from './utils/webfetch.js';
 import { detectIntent } from './utils/intents.js';
 import { Session } from './session.js';
 
@@ -41,6 +42,7 @@ Commands (in chat):
   /provider [name]        Switch provider
   /models                 List available models
   /search <query>         Search the web and summarize with AI
+  /fetch <url>            Open a link and summarize its content
   /clear                  Clear screen
   /new                    Start a new conversation (clear memory)
   /quit                   Exit
@@ -88,6 +90,54 @@ async function answerWithSearch(messages, provider, query, systemPrompt) {
   Session.save(messages);
 }
 
+function extractUrlFromText(text) {
+  const m = text.match(/https?:\/\/[^\s<>"']+/i);
+  return m ? m[0] : null;
+}
+
+async function answerWithFetch(messages, provider, url, systemPrompt) {
+  Terminal.printInfo(`Opening ${url}...`);
+  let page;
+  try {
+    page = await WebFetch.fetch(url);
+  } catch (err) {
+    Terminal.printError(err.message || 'Could not fetch the link.');
+    return;
+  }
+
+  Terminal.printSuccess(`Opened: ${page.title || page.url}`);
+  const content = page.text.trim();
+  if (!content) {
+    Terminal.printWarning('Nothing readable found on that page.');
+    return;
+  }
+
+  messages.push({
+    role: 'user',
+    content: `Here is the content fetched from the URL "${page.url}" (${page.title || 'no title'}):\n\n${content}\n\nPlease summarize and answer based on this content. Be concise.`,
+  });
+  Session.save(messages);
+
+  Terminal.printAIStart();
+  let response = '';
+  try {
+    for await (const chunk of provider.stream(messages, {
+      model: Config.getEffectiveModel(provider.name),
+      systemPrompt,
+    })) {
+      Terminal.printAIChunk(chunk);
+      response += chunk;
+    }
+  } catch (err) {
+    Terminal.printError(err.message || 'Stream error');
+  }
+  Terminal.printAIEnd();
+  if (response) {
+    messages.push({ role: 'assistant', content: response });
+  }
+  Session.save(messages);
+}
+
 async function chat(provider, systemPrompt) {
   const messages = Session.load();
   let exited = false;
@@ -102,21 +152,32 @@ async function chat(provider, systemPrompt) {
     terminal: false,
   });
 
+  let eof = false;
+  let pendingResolver = null;
+
   rl.on('close', () => {
-    if (!exited) {
-      exited = true;
-      process.exit(0);
+    // Graceful shutdown: don't hard-exit mid-command. Mark EOF so the loop
+    // stops asking for more input, and let any in-flight command finish.
+    eof = true;
+    if (pendingResolver) {
+      pendingResolver(null);
+      pendingResolver = null;
     }
   });
 
   const prompt = () => new Promise((resolve) => {
+    if (eof) return resolve(null);
+    pendingResolver = resolve;
     rl.question(
       `\n${Branding.colors.bold}${Branding.colors.primary}┌ ${Branding.USER_PROMPT}${Branding.colors.reset} `,
-      resolve
+      (ans) => {
+        pendingResolver = null;
+        resolve(ans);
+      }
     );
   });
 
-  while (!exited) {
+  while (!exited && !eof) {
     let input;
     try {
       input = await prompt();
@@ -176,6 +237,7 @@ async function chat(provider, systemPrompt) {
           Config.save({ model: modelName });
           Config.setProviderModel(provider.name, modelName);
           Terminal.printSuccess(`Model: ${modelName}`);
+          await ensureLocalModel(modelName);
         } else {
           Terminal.printError(`Unknown model: ${modelName}`);
         }
@@ -236,16 +298,48 @@ async function chat(provider, systemPrompt) {
       continue;
     }
 
+    if (cmd.startsWith('/fetch ') || cmd === '/fetch') {
+      const urlPart = trimmed.slice(6).trim().split(/\s+/)[0];
+      if (!urlPart) {
+        Terminal.printWarning('Usage: /fetch <url>');
+        continue;
+      }
+      await answerWithFetch(messages, provider, urlPart, systemPrompt);
+      continue;
+    }
+
     const intent = detectIntent(trimmed);
+    if (intent.type === 'self') {
+      const model = Config.getEffectiveModel(provider.name);
+      const info = Catalog.getModelInfo(model);
+      Terminal.printSuccess(
+        `I'm running on ${model} (${info ? info.realModel : model}) via the ${provider.displayName} engine.`
+      );
+      continue;
+    }
+
     if (intent.type === 'knowledge') {
       Terminal.printSuccess(`Auto-search: "${trimmed}"`);
       await answerWithSearch(messages, provider, trimmed, systemPrompt);
       continue;
     }
 
+    // If the message contains a bare URL, open it automatically and ask the AI to summarize.
+    if (/https?:\/\/\S+/i.test(trimmed)) {
+      const url = extractUrlFromText(trimmed);
+      if (url) {
+        Terminal.printSuccess(`Auto-open link detected. Fetching...`);
+        await answerWithFetch(messages, provider, url, systemPrompt);
+        continue;
+      }
+    }
+
     messages.push({ role: 'user', content: trimmed });
     Session.save(messages);
+    Terminal.printUser(trimmed);
     Terminal.printAIStart();
+    Terminal.beginThinking();
+    Terminal._thinking = true;
 
     let response = '';
     try {
@@ -268,6 +362,21 @@ async function chat(provider, systemPrompt) {
   }
 }
 
+async function ensureLocalModel(modelName) {
+  const info = Catalog.getModelInfo(modelName);
+  if (!info || !info.isLocal) return;
+  const host = Config.get('engineHost');
+  try {
+    const installed = await Installer.getInstalledModels(host);
+    if (installed.includes(info.realModel)) return;
+    Terminal.printInfo(`Downloading ${info.realModel} for "${modelName}"…`);
+    await Installer.pullModel(host, info.realModel);
+    Terminal.printSuccess(`Model ${info.realModel} ready.`);
+  } catch (err) {
+    Terminal.printError(`Could not download model: ${err.message}`);
+  }
+}
+
 export async function run() {
   const args = parseArgs(process.argv);
 
@@ -285,8 +394,12 @@ export async function run() {
   if (args.provider) Config.save({ provider: args.provider });
   if (args.model) Config.save({ model: args.model });
 
-  Terminal.printInfo('Initializing...');
-  await Installer.ensure();
+  await Terminal.showProgress(
+    ['Checking engine', 'Installing dependencies', 'Downloading model', 'Optimizing'],
+    () => Installer.ensure()
+  );
+
+  await ensureLocalModel(Config.get('model'));
 
   const provider = await ProviderFactory.autoDetect();
   if (!provider) {
@@ -296,6 +409,8 @@ export async function run() {
 
   Config.save({ provider: provider.name });
 
+  if (provider.warmup) provider.warmup();
+
   if (args.clear) Terminal.clear();
   showBanner(provider.name, Config.getEffectiveModel(provider.name), provider.displayName);
 

package/src/config.js

@@ -9,9 +9,10 @@ const DEFAULTS = {
   provider: 'auto',
   model: 'vierratale-fast',
   engineHost: 'http://127.0.0.1:11434',
-  numCtx: 8192,
+  numCtx: 2048,
   temperature: 0.7,
   maxTokens: 4096,
+  keepAlive: '5m',
 };
 
 function loadConfigFile() {
@@ -39,9 +40,10 @@ export const Config = {
       provider: getEnv('VIERRATALE_PROVIDER', file.provider || DEFAULTS.provider),
       model: getEnv('VIERRATALE_MODEL', file.model || DEFAULTS.model),
       engineHost: getEnv('VIERRATALE_ENGINE_HOST', engineHost),
-      numCtx: parseInt(getEnv('VIERRATALE_NUM_CTX', String(file.numCtx || DEFAULTS.numCtx))),
-      temperature: parseFloat(getEnv('VIERRATALE_TEMPERATURE', String(file.temperature || DEFAULTS.temperature))),
-      maxTokens: parseInt(getEnv('VIERRATALE_MAX_TOKENS', String(file.maxTokens || DEFAULTS.maxTokens))),
+      numCtx: parseInt(getEnv('VIERRATALE_NUM_CTX', String(file.numCtx ?? DEFAULTS.numCtx))),
+      temperature: parseFloat(getEnv('VIERRATALE_TEMPERATURE', String(file.temperature ?? DEFAULTS.temperature))),
+      maxTokens: parseInt(getEnv('VIERRATALE_MAX_TOKENS', String(file.maxTokens ?? DEFAULTS.maxTokens))),
+      keepAlive: getEnv('VIERRATALE_KEEP_ALIVE', file.keepAlive ?? DEFAULTS.keepAlive),
       openaiApiKey: getEnv('OPENAI_API_KEY', file.openaiApiKey || ''),
       anthropicApiKey: getEnv('ANTHROPIC_API_KEY', file.anthropicApiKey || ''),
       geminiApiKey: getEnv('GEMINI_API_KEY', file.geminiApiKey || ''),

package/src/installer.js

@@ -55,6 +55,14 @@ async function getInstalledModels(host) {
 }
 
 export const Installer = {
+  async pullModel(host, model) {
+    return pullModel(host, model);
+  },
+
+  async getInstalledModels(host) {
+    return getInstalledModels(host);
+  },
+
   async ensure() {
     const host = Config.get('engineHost');
 
@@ -65,16 +73,23 @@ export const Installer = {
     const running = await isEngineRunning(host);
     if (!running) {
       try {
-        execSync('ollama serve &', { stdio: 'ignore' });
-        await new Promise((r) => setTimeout(r, 3000));
+        // No systemd available here, so launch the daemon directly, detached,
+        // and poll until it responds instead of relying on a service manager.
+        const child = exec('ollama serve', {
+          stdio: 'ignore',
+          detached: true,
+        });
+        if (child.unref) child.unref();
+        for (let i = 0; i < 30; i++) {
+          await new Promise((r) => setTimeout(r, 1000));
+          if (await isEngineRunning(host)) break;
+        }
       } catch {}
     }
 
     const realModel = Catalog.getRealModel(Config.get('model'));
     const installed = await getInstalledModels(host);
-    const needsPull = !installed.some(
-      (m) => m === realModel || m.startsWith(realModel.split(':')[0])
-    );
+    const needsPull = !installed.includes(realModel);
 
     if (needsPull) {
       await pullModel(host, realModel);

package/src/providers/cortex.js

@@ -59,6 +59,7 @@ export class CortexProvider extends BaseProvider {
         model,
         messages: engineMessages,
         stream: true,
+        keep_alive: Config.get('keepAlive'),
         options: {
           num_ctx: Config.get('numCtx'),
           temperature: options.temperature || Config.get('temperature'),
@@ -94,4 +95,21 @@ export class CortexProvider extends BaseProvider {
       }
     }
   }
+
+  async warmup() {
+    // Fire-and-forget: send a tiny request so ollama loads the model into
+    // memory eagerly, so the first real query doesn't pay the cold-load cost.
+    const model = Catalog.getRealModel(Config.get('model'));
+    fetch(`${this.host}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: 'user', content: 'hi' }],
+        stream: false,
+        keep_alive: Config.get('keepAlive'),
+        options: { num_ctx: Config.get('numCtx') },
+      }),
+    }).catch(() => {});
+  }
 }

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.8',
 
   colors: {
     primary: '\x1b[38;2;124;58;237m',

package/src/ui/terminal.js

@@ -9,25 +9,40 @@ export const Terminal = {
 
   printUser(text) {
     const time = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    process.stdout.write('\r\x1b[K');
+    console.log();
+    console.log(`  ${C.bold}${C.primary}You${C.reset}  ${C.dim}${time}${C.reset}`);
+    console.log(`  ${text}`);
     console.log();
-    console.log(`${this.divider('─', 4)} ${C.bold}${C.primary}YOU${C.reset} ${C.dim}${time}${C.reset} ${this.divider('─', 34)}`);
-    console.log(`${C.primary}┃${C.reset} ${text}`);
   },
 
   printAIStart() {
     const time = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
-    this.spinner = { frame: 0, timer: null };
     console.log();
-    console.log(`${this.divider('─', 4)} ${C.bold}${C.accent}${Branding.AI_PROMPT}${C.reset} ${C.dim}${time}${C.reset} ${this.divider('─', 34)}`);
+    console.log(`  ${C.bold}${C.accent}${Branding.AI_PROMPT}${C.reset}  ${C.dim}${time}${C.reset}`);
     this.curLine = '';
     this._printPrefix();
   },
 
   _printPrefix() {
-    process.stdout.write(`${C.accent}┃ ${C.reset}`);
+    process.stdout.write(`  ${C.accent}│${C.reset} `);
+  },
+
+  beginThinking() {
+    process.stdout.write(`${C.dim}· · ·${C.reset}`);
+  },
+
+  endThinking() {
+    process.stdout.write('\r\x1b[2K');
+    this._printPrefix();
   },
 
   printAIChunk(text) {
+    this._thinking = this._thinking || false;
+    if (this._thinking) {
+      this.endThinking();
+      this._thinking = false;
+    }
     this.curLine = (this.curLine || '') + text;
     process.stdout.write(text);
     this._maybeWrap();
@@ -39,7 +54,7 @@ export const Terminal = {
       if (words.length > 1) {
         const lastWord = words[words.length - 1];
         const rest = this.curLine.slice(0, this.curLine.length - lastWord.length).trimEnd();
-        process.stdout.write(`\n${C.accent}┃ ${C.reset}`);
+        process.stdout.write(`\n${C.accent}│${C.reset} `);
         this.curLine = lastWord;
       }
     }
@@ -47,36 +62,54 @@ export const Terminal = {
 
   printAIEnd() {
     process.stdout.write('\n');
-    console.log(`${C.accent}┗${C.reset}${this.divider('─', 44)}`);
     console.log();
   },
 
   printError(msg) {
-    console.log(`${C.error}✖ ${msg}${C.reset}`);
+    console.log(`  ${C.error}✖${C.reset} ${msg}`);
   },
 
   printInfo(msg) {
-    console.log(`${C.dim}${msg}${C.reset}`);
+    console.log(`  ${C.dim}${msg}${C.reset}`);
   },
 
   printSuccess(msg) {
-    console.log(`${C.success}✔ ${msg}${C.reset}`);
+    console.log(`  ${C.success}✔${C.reset} ${msg}`);
   },
 
   printWarning(msg) {
-    console.log(`${C.warning}⚠ ${msg}${C.reset}`);
+    console.log(`  ${C.warning}⚠${C.reset} ${msg}`);
   },
 
   printSearchResults(results) {
-    console.log(`${C.warning}┌── Web Search Results ──${C.reset}`);
+    console.log(`  ${C.warning}Web Search Results${C.reset}`);
     results.forEach((r, i) => {
-      console.log(
-        `  ${C.warning}${i + 1}.${C.reset} ${C.bold}${r.title}${C.reset}`
-      );
+      console.log(`  ${C.warning}${i + 1}.${C.reset} ${C.bold}${r.title}${C.reset}`);
       console.log(`     ${C.dim}${r.url}${C.reset}`);
       if (r.snippet) console.log(`     ${r.snippet.slice(0, 120)}`);
     });
-    console.log(`${C.warning}└──${C.reset}`);
+  },
+
+  async showProgress(steps, work) {
+    // Hidden real progress: the work() task runs silently while we paint a
+    // fake animated progress line so the install feels alive.
+    const frames = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+    let i = 0;
+    const timer = setInterval(() => {
+      i++;
+      const stage = steps[Math.floor((i / 8) % steps.length)];
+      const bar = frames[i % frames.length];
+      const fill = '='.repeat(1 + (i % 18)) + '>' + ' '.repeat(18 - (i % 18));
+      process.stdout.write(`\r  ${C.accent}${bar}${C.reset} ${C.dim}${stage}${C.reset} [${C.accent}${fill}${C.reset}]`);
+    }, 100);
+    try {
+      await work();
+    } finally {
+      clearInterval(timer);
+      process.stdout.write('\r\x1b[2K');
+      console.log(`  ${C.success}✔${C.reset} ${C.dim}Ready${C.reset}`);
+      console.log();
+    }
   },
 
   clear() {

package/src/utils/intents.js

@@ -11,10 +11,22 @@ const KNOWLEDGE_PREFIXES = [
   'latest', 'news', 'current',
 ];
 
+const SELF_PHRASES = [
+  'what model', 'which model', 'what model are you', 'which model are you',
+  'what are you', 'who are you', "what's your name", 'what is your name',
+  'what language model', 'what llm', 'what ai model', 'what ai are you',
+  'your model', 'what model do you use', 'what model you use',
+  'what engine', 'which engine', 'are you gpt', 'are you chatgpt',
+];
+
 export function detectIntent(text) {
   const lower = text.toLowerCase().trim();
   if (lower.startsWith('/')) return { type: 'command' };
 
+  if (SELF_PHRASES.some((p) => lower.includes(p))) {
+    return { type: 'self' };
+  }
+
   const isQuestion = /\?$/.test(lower);
   const firstWord = lower.split(/\s+/)[0] || '';
 

package/src/utils/webfetch.js

@@ -0,0 +1,115 @@
+const UA = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36';
+
+const MAX_BYTES = 200000; // 200KB cap
+const MAX_TEXT = 8000;    // ~8k chars of readable text
+
+const BLOCK_TAGS = new Set([
+  'script', 'style', 'noscript', 'svg', 'head', 'title',
+  'nav', 'footer', 'aside', 'iframe', 'form', 'button', 'noscript',
+]);
+
+export class WebFetch {
+  static normalizeUrl(input) {
+    const trimmed = (input || '').trim();
+    if (!trimmed) return null;
+    let url = trimmed;
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) {
+      // Already has an explicit scheme — must be http(s).
+      if (!/^https?:\/\//i.test(url)) return null;
+    } else if (!/^https?:\/\//i.test(url)) {
+      url = `https://${url}`;
+    }
+    try {
+      const u = new URL(url);
+      if (u.protocol !== 'http:' && u.protocol !== 'https:') return null;
+      return u.toString();
+    } catch {
+      return null;
+    }
+  }
+
+  static async fetch(rawUrl, maxText = MAX_TEXT) {
+    const url = this.normalizeUrl(rawUrl);
+    if (!url) {
+      throw new Error('Invalid URL. Provide a valid http(s) address.');
+    }
+
+    let resp;
+    try {
+      resp = await fetch(url, {
+        headers: { 'User-Agent': UA, Accept: 'text/html,application/xhtml+xml' },
+        redirect: 'follow',
+        signal: AbortSignal.timeout(15000),
+      });
+    } catch {
+      throw new Error(`Could not reach ${url}`);
+    }
+
+    if (!resp.ok) {
+      throw new Error(`Request failed (${resp.status}) for ${url}`);
+    }
+
+    // Refuse to read the whole body past the cap.
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder('utf-8', { fatal: false });
+    let html = '';
+    let received = 0;
+    while (received < MAX_BYTES) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      received += value.length;
+      html += decoder.decode(value, { stream: true });
+    }
+    reader.cancel();
+    html += decoder.decode();
+
+    return {
+      url: resp.url || url,
+      title: this._extractTitle(html),
+      text: this._extractText(html).slice(0, maxText),
+    };
+  }
+
+  static _extractTitle(html) {
+    const m = /<title[^>]*>([^<]*)<\/title>/i.exec(html);
+    return m ? this._stripEntities(m[1].trim()) : '';
+  }
+
+  static _extractText(html) {
+    // Strip block tags' contents that add no readable value.
+    let s = html.replace(/<(script|style|noscript|svg|head|iframe|form|nav|footer|aside)[^>]*>[\s\S]*?<\/\1>/gi, ' ');
+
+    // Force spacing around block-level elements so words don't merge.
+    s = s.replace(/<\/(p|div|h[1-6]|li|tr|br|section|article)>/gi, '\n');
+    s = s.replace(/<(br|li|tr)[^>]*>/gi, '\n');
+
+    // Remove remaining tags.
+    s = s.replace(/<[^>]+>/g, ' ');
+
+    // College entities.
+    s = this._stripEntities(s);
+
+    // Collapse whitespace and trim lines.
+    return s
+      .replace(/[ \t]+/g, ' ')
+      .replace(/ *\n */g, '\n')
+      .replace(/\n{3,}/g, '\n\n')
+      .replace(/[ \t]+/g, ' ')
+      .replace(/\u00a0/g, ' ')
+      .trim();
+  }
+
+  static _stripEntities(text) {
+    const map = {
+      '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"',
+      '&#39;': "'", '&#039;': "'", '&apos;': "'", '&nbsp;': ' ',
+      '&ndash;': '–', '&mdash;': '—', '&hellip;': '...', '&copy;': '©',
+      '&#x27;': "'", '&rsquo;': '’', '&lsquo;': '‘', '&ldquo;': '“', '&rdquo;': '”',
+    };
+    return String(text)
+      .replace(/<[^>]*>/g, '')
+      .replace(/&[a-zA-Z0-9#]+;/g, (m) => map[m] ?? '')
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
+}