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

package/README.md

@@ -12,27 +12,43 @@ npm install -g @vierratale/ai
 npx @vierratale/ai
 ```
 
+The first launch detects and, if needed, installs and starts the local engine
+(**Cortex** - "secretly" Ollama under the hood), then pulls the model you use.
+
 ## Usage
 
 ```bash
 vierrataleai                          # Start chat (auto-detect provider)
 vierrataleai --provider cortex        # Use local models
-vierrataleai --provider openai        # Use cloud models
+vierrataleai --provider openai        # Use cloud models (OpenAI)
+vierrataleai --provider anthropic     # Use cloud models (Claude)
+vierrataleai --provider gemini        # Use cloud models (Gemini)
 vierrataleai --model vierratale-pro   # Use specific model
 ```
 
 ## Models
 
-| Model | Description |
-|-------|-------------|
-| vierratale-lite | Minimal, fast responses |
-| vierratale-fast | Fast, balanced quality |
-| vierratale-small | Small, efficient |
-| vierratale-balanced | Balanced performance |
-| vierratale-plus | Enhanced capability |
-| vierratale-pro | Professional grade |
-| vierratale-cloud | Cloud-powered |
-| vierratale-cloud-pro | Cloud professional |
+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 |
+
+Cloud models are available when the matching provider + API key is configured:
+
+| Model | Backend |
+|-------|---------|
+| vierratale-cloud-mini | gpt-4o-mini (OpenAI) |
+| vierratale-cloud | gpt-4o (OpenAI) |
+| vierratale-cloud-fast | claude-3-5-haiku-20241022 (Anthropic) |
+| vierratale-cloud-pro | claude-sonnet-4-20250514 (Anthropic) |
+| vierratale-cloud-lite | gemini-2.0-flash (Gemini) |
+| vierratale-cloud-plus | gemini-1.5-pro (Gemini) |
 
 ## Commands
 
@@ -40,6 +56,7 @@ vierrataleai --model vierratale-pro   # Use specific model
 - `/model [name]` - Switch model
 - `/provider [name]` - Switch provider
 - `/models` - List available models
+- `/system [text]` - Set a custom system prompt / persona
 - `/search <query>` - Search the web and summarize with AI
 - `/clear` - Clear screen
 - `/new` - Start a new conversation (clear memory)
@@ -67,9 +84,11 @@ you can continue where you left off. Use `/new` to start fresh.
 Config file: `~/.config/vierrataleai/config.json`
 
 Environment variables:
-- `VIERRATALE_PROVIDER` - Default provider
+- `VIERRATALE_PROVIDER` - Default provider (auto/cortex/openai/anthropic/gemini)
 - `VIERRATALE_MODEL` - Default model
-- `OPENAI_API_KEY` - OpenAI API key (for cloud models)
+- `OPENAI_API_KEY` - OpenAI API key (openai provider)
+- `ANTHROPIC_API_KEY` - Anthropic API key (anthropic provider)
+- `GEMINI_API_KEY` - Google AI API key (gemini provider)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vierratale/ai",
-  "version": "0.1.0-beta.4",
+  "version": "0.1.0-beta.6",
   "description": "VierrataleAI - Intelligent terminal assistant",
   "type": "module",
   "bin": {
@@ -11,7 +11,9 @@
     ".": "./src/index.js"
   },
   "scripts": {
-    "start": "node bin/vierrataleai.js"
+    "start": "node bin/vierrataleai.js",
+    "test": "node --test test/",
+    "postinstall": "node scripts/postinstall.js"
   },
   "keywords": ["ai", "chatbot", "terminal", "assistant", "llm"],
   "author": "Vierratale",

package/scripts/postinstall.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// Optional engine setup after install. Never fails the package install.
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+
+const isInstalled = () => {
+  try {
+    execSync('which ollama 2>/dev/null', { stdio: 'ignore' });
+    return true;
+  } catch {}
+  return existsSync('/usr/local/bin/ollama') || existsSync('/usr/bin/ollama');
+};
+
+try {
+  if (isInstalled()) {
+    process.exit(0);
+  }
+
+  const nonInteractive =
+    !process.stdout.isTTY || process.env.CI || process.env.NODE_ENV === 'test';
+
+  // Only auto-install when explicitly requested. Otherwise just inform the user
+  // that the engine will be installed on first launch.
+  if (process.env.VIERRATALE_INSTALL_ENGINE === '1' && !nonInteractive) {
+    execSync('curl -fsSL https://ollama.com/install.sh | sh', { stdio: 'inherit' });
+  } else {
+    console.log(
+      '\n[vierrataleai] The local engine (ollama) was not detected.\n' +
+        '  - Run the CLI: it will attempt to install and start the engine automatically.\n' +
+        '  - Or install it yourself: curl -fsSL https://ollama.com/install.sh | sh\n'
+    );
+  }
+} catch {
+  // Never fail the install because of engine setup.
+}

package/src/catalog.js

@@ -60,6 +60,26 @@ export const Catalog = {
     return 'vierratale-fast';
   },
 
+  getDefaultCloudModel() {
+    return 'vierratale-cloud-mini';
+  },
+
+  isLocalModel(displayName) {
+    return LOCAL_MODELS.includes(displayName);
+  },
+
+  isCloudModel(displayName) {
+    return CLOUD_MODELS.includes(displayName);
+  },
+
+  getVendorForCloudModel(displayName) {
+    const real = REVERSE[displayName];
+    if (real && real.startsWith('claude-')) return 'anthropic';
+    if (real && real.startsWith('gemini-')) return 'gemini';
+    if (real && real.startsWith('gpt-')) return 'openai';
+    return 'openai';
+  },
+
   getModelInfo(displayName) {
     const real = REVERSE[displayName];
     if (!real) return null;

package/src/cli.js

@@ -72,7 +72,7 @@ async function answerWithSearch(messages, provider, query, systemPrompt) {
   let response = '';
   try {
     for await (const chunk of provider.stream(messages, {
-      model: Config.get('model'),
+      model: Config.getEffectiveModel(provider.name),
       systemPrompt,
     })) {
       Terminal.printAIChunk(chunk);
@@ -85,6 +85,7 @@ async function answerWithSearch(messages, provider, query, systemPrompt) {
   if (response) {
     messages.push({ role: 'assistant', content: response });
   }
+  Session.save(messages);
 }
 
 async function chat(provider, systemPrompt) {
@@ -139,7 +140,7 @@ async function chat(provider, systemPrompt) {
 
     if (cmd === '/clear') {
       Terminal.clear();
-      showBanner(provider.name, Config.get('model'), provider.displayName);
+      showBanner(provider.name, Config.getEffectiveModel(provider.name), provider.displayName);
       continue;
     }
 
@@ -156,13 +157,13 @@ async function chat(provider, systemPrompt) {
     }
 
     if (cmd === '/models') {
-      const models = provider.name === 'cortex'
+      const models = provider.isLocal
         ? Catalog.getLocalModels()
         : Catalog.getCloudModels();
       Terminal.printInfo('Available models:');
       for (const m of models) {
         const info = Catalog.getModelInfo(m);
-        const current = m === Config.get('model') ? ' (active)' : '';
+        const current = m === Config.getEffectiveModel(provider.name) ? ' (active)' : '';
         console.log(`  ${Branding.colors.accent}${m}${Branding.colors.dim}${current} - ${info.tier}${Branding.colors.reset}`);
       }
       continue;
@@ -173,6 +174,7 @@ async function chat(provider, systemPrompt) {
       if (modelName) {
         if (Catalog.getModelInfo(modelName)) {
           Config.save({ model: modelName });
+          Config.setProviderModel(provider.name, modelName);
           Terminal.printSuccess(`Model: ${modelName}`);
         } else {
           Terminal.printError(`Unknown model: ${modelName}`);
@@ -182,15 +184,21 @@ async function chat(provider, systemPrompt) {
     }
 
     if (cmd === '/model') {
-      Terminal.printInfo(`Current model: ${Config.get('model')}`);
+      Terminal.printInfo(`Current model: ${Config.getEffectiveModel(provider.name)}`);
       continue;
     }
 
     if (cmd.startsWith('/provider ')) {
       const prov = cmd.split(' ')[1];
-      if (['cortex', 'openai'].includes(prov)) {
+      if (['cortex', 'openai', 'anthropic', 'gemini'].includes(prov)) {
         Config.save({ provider: prov });
-        Terminal.printSuccess(`Provider: ${prov}`);
+        const next = ProviderFactory.create(prov);
+        if (next && await next.isAvailable()) {
+          provider = next;
+          Terminal.printSuccess(`Provider: ${prov}`);
+        } else {
+          Terminal.printWarning(`Provider saved, but ${prov} is not available right now. Will apply on restart.`);
+        }
       } else {
         Terminal.printError(`Unknown provider: ${prov}`);
       }
@@ -202,6 +210,22 @@ async function chat(provider, systemPrompt) {
       continue;
     }
 
+    if (cmd.startsWith('/system')) {
+      const prompt = trimmed.slice(7).trim();
+      if (prompt.toLowerCase() === 'reset') {
+        Config.save({ systemPrompt: '' });
+        systemPrompt = loadSystemPrompt();
+        Terminal.printSuccess('System prompt reset to default.');
+      } else if (prompt) {
+        Config.save({ systemPrompt: prompt });
+        systemPrompt = prompt;
+        Terminal.printSuccess('System prompt updated.');
+      } else {
+        Terminal.printInfo(`Current system prompt: ${systemPrompt}`);
+      }
+      continue;
+    }
+
     if (cmd.startsWith('/search ')) {
       const query = trimmed.slice(8).trim();
       if (!query) {
@@ -226,7 +250,7 @@ async function chat(provider, systemPrompt) {
     let response = '';
     try {
       for await (const chunk of provider.stream(messages, {
-        model: Config.get('model'),
+        model: Config.getEffectiveModel(provider.name),
         systemPrompt,
       })) {
         Terminal.printAIChunk(chunk);
@@ -273,7 +297,7 @@ export async function run() {
   Config.save({ provider: provider.name });
 
   if (args.clear) Terminal.clear();
-  showBanner(provider.name, Config.get('model'), provider.displayName);
+  showBanner(provider.name, Config.getEffectiveModel(provider.name), provider.displayName);
 
   const systemPrompt = loadSystemPrompt();
   await chat(provider, systemPrompt);

package/src/config.js

@@ -44,6 +44,9 @@ export const Config = {
       maxTokens: parseInt(getEnv('VIERRATALE_MAX_TOKENS', String(file.maxTokens || DEFAULTS.maxTokens))),
       openaiApiKey: getEnv('OPENAI_API_KEY', file.openaiApiKey || ''),
       anthropicApiKey: getEnv('ANTHROPIC_API_KEY', file.anthropicApiKey || ''),
+      geminiApiKey: getEnv('GEMINI_API_KEY', file.geminiApiKey || ''),
+      systemPrompt: file.systemPrompt || '',
+      providerModels: file.providerModels || {},
     };
     return this._config;
   },
@@ -58,6 +61,22 @@ export const Config = {
     return { ...this._config };
   },
 
+  getProviderModel(provider) {
+    if (!this._config) this.load();
+    return this._config.providerModels?.[provider] || null;
+  },
+
+  setProviderModel(provider, model) {
+    if (!this._config) this.load();
+    this._config.providerModels = this._config.providerModels || {};
+    this._config.providerModels[provider] = model;
+    this.save();
+  },
+
+  getEffectiveModel(provider) {
+    return this.getProviderModel(provider) || this.get('model');
+  },
+
   save(overrides = {}) {
     if (!existsSync(CONFIG_DIR)) {
       mkdirSync(CONFIG_DIR, { recursive: true });

package/src/installer.js

@@ -17,15 +17,16 @@ function isEngineRunning(host) {
 
 function isEngineInstalled() {
   try {
-    execSync('which cortex 2>/dev/null', { stdio: 'ignore' });
+    execSync('which ollama 2>/dev/null', { stdio: 'ignore' });
     return true;
   } catch {}
-  const paths = ['/usr/local/bin/cortex', '/usr/bin/cortex'];
+  const paths = ['/usr/local/bin/ollama', '/usr/bin/ollama'];
   return paths.some((p) => existsSync(p));
 }
 
 async function installEngine() {
-  await runSilent('curl -fsSL https://cortex.com/install.sh | sh');
+  await runSilent('curl -fsSL https://ollama.com/install.sh | sh');
+  return isEngineInstalled();
 }
 
 async function pullModel(host, model) {
@@ -64,7 +65,7 @@ export const Installer = {
     const running = await isEngineRunning(host);
     if (!running) {
       try {
-        execSync('cortex serve &', { stdio: 'ignore' });
+        execSync('ollama serve &', { stdio: 'ignore' });
         await new Promise((r) => setTimeout(r, 3000));
       } catch {}
     }

package/src/providers/anthropic.js

@@ -0,0 +1,99 @@
+import { BaseProvider } from './base.js';
+import { Catalog } from '../catalog.js';
+import { Config } from '../config.js';
+
+const ANTHROPIC_URL = 'https://api.anthropic.com/v1/messages';
+
+export class AnthropicProvider extends BaseProvider {
+  constructor() {
+    super('anthropic');
+  }
+
+  get displayName() {
+    return 'Nebula';
+  }
+
+  _resolveModel(options) {
+    const requested = options.model || Config.get('model');
+    if (Catalog.isLocalModel(requested) || !Catalog.isCloudModel(requested)) {
+      return Catalog.getRealModel(Catalog.getDefaultCloudModel());
+    }
+    const real = Catalog.getRealModel(requested);
+    return real.startsWith('claude-') ? real : 'claude-3-5-haiku-20241022';
+  }
+
+  async isAvailable() {
+    const key = Config.get('anthropicApiKey');
+    return Boolean(key);
+  }
+
+  async listModels() {
+    const key = Config.get('anthropicApiKey');
+    if (!key) return [];
+    const models = Object.keys(Catalog.getAllModels()).filter((m) => m.startsWith('claude-'));
+    return models.map((real) => ({
+      realName: real,
+      displayName: Catalog.getDisplayName(real),
+    }));
+  }
+
+  async *stream(messages, options = {}) {
+    const key = Config.get('anthropicApiKey');
+    if (!key) throw new Error('Anthropic API key not configured');
+
+    const model = this._resolveModel(options);
+    const systemPrompt = options.systemPrompt || '';
+
+    const system = [];
+    if (systemPrompt) system.push({ type: 'text', text: systemPrompt });
+    const apiMessages = messages.map((m) => ({
+      role: m.role === 'assistant' ? 'assistant' : 'user',
+      content: m.content,
+    }));
+
+    const resp = await fetch(ANTHROPIC_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': key,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({
+        model,
+        system: system.length ? system : undefined,
+        messages: apiMessages,
+        max_tokens: options.maxTokens || Config.get('maxTokens'),
+        stream: true,
+        temperature: options.temperature || Config.get('temperature'),
+      }),
+    });
+
+    if (!resp.ok) {
+      throw new Error('Failed to connect to cloud engine');
+    }
+
+    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);
+        try {
+          const json = JSON.parse(data);
+          if (json.type === 'content_block_delta' && json.delta?.text) {
+            yield json.delta.text;
+          }
+        } catch {}
+      }
+    }
+  }
+}

package/src/providers/base.js

@@ -7,6 +7,10 @@ export class BaseProvider {
     return 'Cortex';
   }
 
+  get isLocal() {
+    return false;
+  }
+
   async *stream(messages, options = {}) {
     throw new Error('stream() must be implemented');
   }

package/src/providers/cortex.js

@@ -12,6 +12,10 @@ export class CortexProvider extends BaseProvider {
     return 'Cortex';
   }
 
+  get isLocal() {
+    return true;
+  }
+
   async isAvailable() {
     try {
       const resp = await fetch(`${this.host}/api/tags`, { signal: AbortSignal.timeout(3000) });

package/src/providers/gemini.js

@@ -0,0 +1,97 @@
+import { BaseProvider } from './base.js';
+import { Catalog } from '../catalog.js';
+import { Config } from '../config.js';
+
+const GEMINI_URL = 'https://generativelanguage.googleapis.com/v1beta/models';
+
+export class GeminiProvider extends BaseProvider {
+  constructor() {
+    super('gemini');
+  }
+
+  get displayName() {
+    return 'Nebula';
+  }
+
+  _resolveModel(options) {
+    const requested = options.model || Config.get('model');
+    if (Catalog.isLocalModel(requested) || !Catalog.isCloudModel(requested)) {
+      return Catalog.getRealModel(Catalog.getDefaultCloudModel());
+    }
+    const real = Catalog.getRealModel(requested);
+    return real.startsWith('gemini-') ? real : 'gemini-2.0-flash';
+  }
+
+  async isAvailable() {
+    const key = Config.get('geminiApiKey');
+    return Boolean(key);
+  }
+
+  async listModels() {
+    const key = Config.get('geminiApiKey');
+    if (!key) return [];
+    const models = Object.keys(Catalog.getAllModels()).filter((m) => m.startsWith('gemini-'));
+    return models.map((real) => ({
+      realName: real,
+      displayName: Catalog.getDisplayName(real),
+    }));
+  }
+
+  async *stream(messages, options = {}) {
+    const key = Config.get('geminiApiKey');
+    if (!key) throw new Error('Gemini API key not configured');
+
+    const model = this._resolveModel(options);
+    const systemPrompt = options.systemPrompt || '';
+
+    const contents = messages.map((m) => ({
+      role: m.role === 'assistant' ? 'model' : 'user',
+      parts: [{ text: m.content }],
+    }));
+    if (systemPrompt) {
+      contents.unshift({ role: 'user', parts: [{ text: `System: ${systemPrompt}` }] });
+    }
+
+    const resp = await fetch(
+      `${GEMINI_URL}/${model}:streamGenerateContent?key=${key}&alt=sse`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          contents,
+          generationConfig: {
+            temperature: options.temperature || Config.get('temperature'),
+            maxOutputTokens: options.maxTokens || Config.get('maxTokens'),
+          },
+        }),
+      }
+    );
+
+    if (!resp.ok) {
+      throw new Error('Failed to connect to cloud engine');
+    }
+
+    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);
+        try {
+          const json = JSON.parse(data);
+          const text = json.candidates?.[0]?.content?.parts?.[0]?.text;
+          if (text) yield text;
+        } catch {}
+      }
+    }
+  }
+}

package/src/providers/index.js

@@ -1,5 +1,7 @@
 import { CortexProvider } from './cortex.js';
 import { OpenAIProvider } from './openai.js';
+import { AnthropicProvider } from './anthropic.js';
+import { GeminiProvider } from './gemini.js';
 import { Config } from '../config.js';
 
 let providers = {};
@@ -9,6 +11,8 @@ function getProviders() {
     providers = {
       cortex: new CortexProvider(),
       openai: new OpenAIProvider(),
+      anthropic: new AnthropicProvider(),
+      gemini: new GeminiProvider(),
     };
   }
   return providers;
@@ -23,7 +27,7 @@ export const ProviderFactory = {
       if (await ps[requested].isAvailable()) return ps[requested];
     }
 
-    for (const name of ['cortex', 'openai']) {
+    for (const name of ['cortex', 'openai', 'anthropic', 'gemini']) {
       if (await ps[name].isAvailable()) return ps[name];
     }
 

package/src/providers/openai.js

@@ -45,11 +45,21 @@ export class OpenAIProvider extends BaseProvider {
     }
   }
 
+  // If the configured model is a local (ollama) model, use a cloud default so
+  // we never send a qwen model name to the OpenAI API.
+  _resolveModel(options) {
+    const requested = options.model || Config.get('model');
+    if (Catalog.isLocalModel(requested) || !Catalog.isCloudModel(requested)) {
+      return Catalog.getRealModel(Catalog.getDefaultCloudModel());
+    }
+    return Catalog.getRealModel(requested);
+  }
+
   async *stream(messages, options = {}) {
     const key = Config.get('openaiApiKey');
     if (!key) throw new Error('Cloud API key not configured');
 
-    const model = Catalog.getRealModel(options.model || Config.get('model'));
+    const model = this._resolveModel(options);
     const systemPrompt = options.systemPrompt || '';
 
     const apiMessages = [];

package/src/ui/banner.js

@@ -3,10 +3,13 @@ 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'));
@@ -20,16 +23,18 @@ 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 ▸ Cortex Engine${C.reset}`);
+  console.log(`  ${C.bold}${C.accent}▸ Vierratale AI ▸ ${providerDisplayName || 'Cortex'} Engine${C.reset}`);
   console.log();
   console.log(border);
-  console.log(`  ║  ${C.bold}${C.primary}Model${C.reset}${' '.repeat(width - 12)}║`);
-  console.log(`  ║   ${C.accent}${model}${C.reset}${' '.repeat(Math.max(1, width - 5 - model.length))}║`);
-  console.log(`  ║  ${C.bold}${C.primary}Engine${C.reset}${' '.repeat(width - 13)}║`);
-  console.log(`  ║   ${C.accent}${providerDisplayName || 'Cortex'}${C.reset}${' '.repeat(Math.max(1, width - 7 - (providerDisplayName || 'Cortex').length))}║`);
+  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}`);

package/src/ui/branding.js

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