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

package/package.json

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

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();
@@ -236,6 +297,16 @@ 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 === 'knowledge') {
       Terminal.printSuccess(`Auto-search: "${trimmed}"`);
@@ -243,6 +314,16 @@ async function chat(provider, 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.printAIStart();

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/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'),

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();
+  }
+}