@vierratale/ai 0.1.0-beta.2 → 0.1.0-beta.4

package/README.md

@@ -16,7 +16,7 @@ npx @vierratale/ai
 
 ```bash
 vierrataleai                          # Start chat (auto-detect provider)
-vierrataleai --provider ollama        # Use local models
+vierrataleai --provider cortex        # Use local models
 vierrataleai --provider openai        # Use cloud models
 vierrataleai --model vierratale-pro   # Use specific model
 ```
@@ -42,8 +42,26 @@ vierrataleai --model vierratale-pro   # Use specific model
 - `/models` - List available models
 - `/search <query>` - Search the web and summarize with AI
 - `/clear` - Clear screen
+- `/new` - Start a new conversation (clear memory)
 - `/quit` - Exit
 
+## Smart Search
+
+Asking a question (Who/What/When/Where/Why/How...?) automatically searches the
+web and summarizes the results with AI. For example:
+
+```
+> Who is Cristiano Ronaldo?
+```
+
+triggers a live web search and answers from the results. Use `/search <query>`
+to force a search explicitly.
+
+## Conversation Memory
+
+Your conversation is saved automatically and restored on the next launch, so
+you can continue where you left off. Use `/new` to start fresh.
+
 ## Configuration
 
 Config file: `~/.config/vierrataleai/config.json`

package/package.json

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

package/src/cli.js

@@ -7,6 +7,8 @@ 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 { detectIntent } from './utils/intents.js';
+import { Session } from './session.js';
 
 function parseArgs(args) {
   const parsed = { provider: null, model: null, clear: false, version: false, help: false };
@@ -27,7 +29,7 @@ ${Branding.APP_NAME} ${Branding.VERSION}
 Usage: vierrataleai [options]
 
 Options:
-  --provider, -p <name>   Provider: ollama, openai (default: auto-detect)
+  --provider, -p <name>   Provider: cortex, openai (default: auto-detect)
   --model, -m <name>      Model: vierratale-lite/fast/balanced/pro/cloud
   --clear                 Clear screen on start
   --version, -v           Show version
@@ -40,14 +42,59 @@ Commands (in chat):
   /models                 List available models
   /search <query>         Search the web and summarize with AI
   /clear                  Clear screen
+  /new                    Start a new conversation (clear memory)
   /quit                   Exit
 `);
 }
 
+async function answerWithSearch(messages, provider, query, systemPrompt) {
+  Terminal.printInfo('Searching the web...');
+  const results = await WebSearch.search(query);
+
+  if (results.length === 0) {
+    Terminal.printError('No results found for the query.');
+    return;
+  }
+
+  Terminal.printSearchResults(results);
+
+  const searchContext = results.map((r, i) =>
+    `${i + 1}. ${r.title}\n   URL: ${r.url}\n   ${r.snippet}`
+  ).join('\n\n');
+
+  messages.push({
+    role: 'user',
+    content: `Web search results for "${query}":\n\n${searchContext}\n\nPlease summarize these results and answer based on them. Be concise.`,
+  });
+  Session.save(messages);
+
+  Terminal.printAIStart();
+  let response = '';
+  try {
+    for await (const chunk of provider.stream(messages, {
+      model: Config.get('model'),
+      systemPrompt,
+    })) {
+      Terminal.printAIChunk(chunk);
+      response += chunk;
+    }
+  } catch (err) {
+    Terminal.printError(err.message || 'Stream error');
+  }
+  Terminal.printAIEnd();
+  if (response) {
+    messages.push({ role: 'assistant', content: response });
+  }
+}
+
 async function chat(provider, systemPrompt) {
-  const messages = [];
+  const messages = Session.load();
   let exited = false;
 
+  if (messages.length > 0) {
+    Terminal.printInfo(`Resumed ${messages.filter((m) => m.role === 'user').length} previous message(s).`);
+  }
+
   const rl = createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -101,8 +148,15 @@ async function chat(provider, systemPrompt) {
       continue;
     }
 
+    if (cmd === '/new') {
+      Session.clear();
+      messages.length = 0;
+      Terminal.printSuccess('Started a new conversation.');
+      continue;
+    }
+
     if (cmd === '/models') {
-      const models = provider.name === 'ollama'
+      const models = provider.name === 'cortex'
         ? Catalog.getLocalModels()
         : Catalog.getCloudModels();
       Terminal.printInfo('Available models:');
@@ -134,7 +188,7 @@ async function chat(provider, systemPrompt) {
 
     if (cmd.startsWith('/provider ')) {
       const prov = cmd.split(' ')[1];
-      if (['ollama', 'openai'].includes(prov)) {
+      if (['cortex', 'openai'].includes(prov)) {
         Config.save({ provider: prov });
         Terminal.printSuccess(`Provider: ${prov}`);
       } else {
@@ -148,53 +202,25 @@ async function chat(provider, systemPrompt) {
       continue;
     }
 
-    if (cmd.startsWith('/search ') || cmd === '/search') {
-      const query = cmd === '/search' ? '' : trimmed.slice(8).trim();
+    if (cmd.startsWith('/search ')) {
+      const query = trimmed.slice(8).trim();
       if (!query) {
         Terminal.printWarning('Usage: /search <query>');
         continue;
       }
+      await answerWithSearch(messages, provider, query, systemPrompt);
+      continue;
+    }
 
-      Terminal.printInfo('Searching the web...');
-      const results = await WebSearch.search(query);
-
-      if (results.length === 0) {
-        Terminal.printError('No results found for the query.');
-        continue;
-      }
-
-      Terminal.printSearchResults(results);
-
-      const searchContext = results.map((r, i) =>
-        `${i + 1}. ${r.title}\n   URL: ${r.url}\n   ${r.snippet}`
-      ).join('\n\n');
-
-      messages.push({
-        role: 'user',
-        content: `Web search results for "${query}":\n\n${searchContext}\n\nPlease summarize these results and answer based on them. Be concise.`,
-      });
-
-      Terminal.printAIStart();
-      let response = '';
-      try {
-        for await (const chunk of provider.stream(messages, {
-          model: Config.get('model'),
-          systemPrompt,
-        })) {
-          Terminal.printAIChunk(chunk);
-          response += chunk;
-        }
-      } catch (err) {
-        Terminal.printError(err.message || 'Stream error');
-      }
-      Terminal.printAIEnd();
-      if (response) {
-        messages.push({ role: 'assistant', content: response });
-      }
+    const intent = detectIntent(trimmed);
+    if (intent.type === 'knowledge') {
+      Terminal.printSuccess(`Auto-search: "${trimmed}"`);
+      await answerWithSearch(messages, provider, trimmed, systemPrompt);
       continue;
     }
 
     messages.push({ role: 'user', content: trimmed });
+    Session.save(messages);
     Terminal.printAIStart();
 
     let response = '';
@@ -214,6 +240,7 @@ async function chat(provider, systemPrompt) {
     if (response) {
       messages.push({ role: 'assistant', content: response });
     }
+    Session.save(messages);
   }
 }
 

package/src/config.js

@@ -8,7 +8,7 @@ const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
 const DEFAULTS = {
   provider: 'auto',
   model: 'vierratale-fast',
-  ollamaHost: 'http://127.0.0.1:11434',
+  engineHost: 'http://127.0.0.1:11434',
   numCtx: 8192,
   temperature: 0.7,
   maxTokens: 4096,
@@ -33,10 +33,12 @@ export const Config = {
 
   load() {
     const file = loadConfigFile();
+    // Migrate legacy 'cortexHost' key to 'engineHost' if present.
+    const engineHost = file.engineHost || file.cortexHost || DEFAULTS.engineHost;
     this._config = {
       provider: getEnv('VIERRATALE_PROVIDER', file.provider || DEFAULTS.provider),
       model: getEnv('VIERRATALE_MODEL', file.model || DEFAULTS.model),
-      ollamaHost: getEnv('VIERRATALE_OLLAMA_HOST', file.ollamaHost || DEFAULTS.ollamaHost),
+      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))),

package/src/index.js

@@ -1,6 +1,6 @@
 export { Catalog } from './catalog.js';
 export { Config } from './config.js';
 export { Installer } from './installer.js';
-export { OllamaProvider } from './providers/ollama.js';
+export { CortexProvider } from './providers/cortex.js';
 export { OpenAIProvider } from './providers/openai.js';
 export { Branding } from './ui/branding.js';

package/src/installer.js

@@ -9,23 +9,23 @@ function runSilent(cmd) {
   });
 }
 
-function isOllamaRunning(host) {
+function isEngineRunning(host) {
   return fetch(`${host}/api/tags`, { signal: AbortSignal.timeout(3000) })
     .then((r) => r.ok)
     .catch(() => false);
 }
 
-function isOllamaInstalled() {
+function isEngineInstalled() {
   try {
-    execSync('which ollama 2>/dev/null', { stdio: 'ignore' });
+    execSync('which cortex 2>/dev/null', { stdio: 'ignore' });
     return true;
   } catch {}
-  const paths = ['/usr/local/bin/ollama', '/usr/bin/ollama'];
+  const paths = ['/usr/local/bin/cortex', '/usr/bin/cortex'];
   return paths.some((p) => existsSync(p));
 }
 
-async function installOllama() {
-  await runSilent('curl -fsSL https://ollama.com/install.sh | sh');
+async function installEngine() {
+  await runSilent('curl -fsSL https://cortex.com/install.sh | sh');
 }
 
 async function pullModel(host, model) {
@@ -55,16 +55,16 @@ async function getInstalledModels(host) {
 
 export const Installer = {
   async ensure() {
-    const host = Config.get('ollamaHost');
+    const host = Config.get('engineHost');
 
-    if (!isOllamaInstalled()) {
-      await installOllama();
+    if (!isEngineInstalled()) {
+      await installEngine();
     }
 
-    const running = await isOllamaRunning(host);
+    const running = await isEngineRunning(host);
     if (!running) {
       try {
-        execSync('ollama serve &', { stdio: 'ignore' });
+        execSync('cortex serve &', { stdio: 'ignore' });
         await new Promise((r) => setTimeout(r, 3000));
       } catch {}
     }
@@ -83,7 +83,7 @@ export const Installer = {
   },
 
   async isReady() {
-    const host = Config.get('ollamaHost');
-    return isOllamaRunning(host);
+    const host = Config.get('engineHost');
+    return isEngineRunning(host);
   },
 };

package/src/providers/{ollama.js → cortex.js}

@@ -2,10 +2,10 @@ import { BaseProvider } from './base.js';
 import { Catalog } from '../catalog.js';
 import { Config } from '../config.js';
 
-export class OllamaProvider extends BaseProvider {
+export class CortexProvider extends BaseProvider {
   constructor() {
-    super('ollama');
-    this.host = Config.get('ollamaHost');
+    super('cortex');
+    this.host = Config.get('engineHost');
   }
 
   get displayName() {
@@ -40,12 +40,12 @@ export class OllamaProvider extends BaseProvider {
     const model = Catalog.getRealModel(options.model || Config.get('model'));
     const systemPrompt = options.systemPrompt || '';
 
-    const ollamaMessages = [];
+    const engineMessages = [];
     if (systemPrompt) {
-      ollamaMessages.push({ role: 'system', content: systemPrompt });
+      engineMessages.push({ role: 'system', content: systemPrompt });
     }
     for (const msg of messages) {
-      ollamaMessages.push({ role: msg.role, content: msg.content });
+      engineMessages.push({ role: msg.role, content: msg.content });
     }
 
     const resp = await fetch(`${this.host}/api/chat`, {
@@ -53,7 +53,7 @@ export class OllamaProvider extends BaseProvider {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
         model,
-        messages: ollamaMessages,
+        messages: engineMessages,
         stream: true,
         options: {
           num_ctx: Config.get('numCtx'),

package/src/providers/index.js

@@ -1,4 +1,4 @@
-import { OllamaProvider } from './ollama.js';
+import { CortexProvider } from './cortex.js';
 import { OpenAIProvider } from './openai.js';
 import { Config } from '../config.js';
 
@@ -7,7 +7,7 @@ let providers = {};
 function getProviders() {
   if (Object.keys(providers).length === 0) {
     providers = {
-      ollama: new OllamaProvider(),
+      cortex: new CortexProvider(),
       openai: new OpenAIProvider(),
     };
   }
@@ -23,7 +23,7 @@ export const ProviderFactory = {
       if (await ps[requested].isAvailable()) return ps[requested];
     }
 
-    for (const name of ['ollama', 'openai']) {
+    for (const name of ['cortex', 'openai']) {
       if (await ps[name].isAvailable()) return ps[name];
     }
 

package/src/session.js

@@ -0,0 +1,41 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { Config } from './config.js';
+
+const SESSION_FILE = join(Config.getConfigDir(), 'history.json');
+const MAX_MESSAGES = 20;
+
+export const Session = {
+  load() {
+    try {
+      if (existsSync(SESSION_FILE)) {
+        const raw = readFileSync(SESSION_FILE, 'utf-8');
+        const data = JSON.parse(raw || '[]');
+        if (Array.isArray(data)) return data.slice(-MAX_MESSAGES);
+      }
+    } catch {}
+    return [];
+  },
+
+  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));
+    } catch {}
+  },
+
+  clear() {
+    try {
+      if (existsSync(SESSION_FILE)) writeFileSync(SESSION_FILE, '[]');
+    } catch {}
+  },
+
+  hasHistory() {
+    try {
+      return existsSync(SESSION_FILE) && (JSON.parse(readFileSync(SESSION_FILE, 'utf-8') || '[]').length > 0);
+    } catch {
+      return false;
+    }
+  },
+};

package/src/ui/branding.js

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

package/src/utils/intents.js

@@ -0,0 +1,30 @@
+const QUESTION_PREFIXES = [
+  'who', 'what', 'when', 'where', 'why', 'how',
+  'which', 'whose', 'whom', 'is', 'are', 'was', 'were',
+  'can', 'could', 'does', 'do', 'did', 'would', 'should', 'will',
+];
+
+const KNOWLEDGE_PREFIXES = [
+  'tell me about', "what is", "what's", "who is", "who's",
+  'what are', 'who was', 'when did', 'when was', 'where is',
+  'where was', 'how did', 'how does', 'how to', 'why did', 'why is',
+  'latest', 'news', 'current',
+];
+
+export function detectIntent(text) {
+  const lower = text.toLowerCase().trim();
+  if (lower.startsWith('/')) return { type: 'command' };
+
+  const isQuestion = /\?$/.test(lower);
+  const firstWord = lower.split(/\s+/)[0] || '';
+
+  let needsWeb = false;
+  if (isQuestion && QUESTION_PREFIXES.includes(firstWord)) {
+    needsWeb = true;
+  }
+  if (KNOWLEDGE_PREFIXES.some((p) => lower.startsWith(p + ' ') || lower === p)) {
+    needsWeb = true;
+  }
+
+  return { type: needsWeb ? 'knowledge' : 'chat' };
+}

package/src/utils/websearch.js

@@ -79,15 +79,15 @@ export class WebSearch {
   }
 
   static _stripTags(text) {
+    const map = {
+      '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"',
+      '&#039;': "'", '&#39;': "'", '&apos;': "'", '&nbsp;': ' ',
+      '&#x27;': "'", '&hellip;': '...',
+    };
     return String(text)
       .replace(/<[^>]*>/g, '')
-      .replace(/&amp;/g, '&')
-      .replace(/&lt;/g, '<')
-      .replace(/&gt;/g, '>')
-      .replace(/&quot;/g, '"')
-      .replace(/&#x27;/g, "'")
-      .replace(/&#39;/g, "'")
-      .replace(/&nbsp;/g, ' ')
+      .replace(/&[a-zA-Z0-9#]+;/g, (m) => map[m] ?? '')
+      .replace(/\s{2,}/g, ' ')
       .trim();
   }
 }