@vierratale/ai 0.1.0-beta.1 → 0.1.0-beta.11

package/README.md

@@ -12,27 +12,47 @@ 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 ollama        # Use local models
-vierrataleai --provider openai        # Use cloud models
-vierrataleai --model vierratale-pro   # Use specific model
+vierrataleai --provider cortex        # Use local models
+vierrataleai --provider openai        # Use cloud models (OpenAI)
+vierrataleai --provider anthropic     # Use cloud models (Claude)
+vierrataleai --provider gemini        # Use cloud models (Gemini)
+vierrataleai --model VRTL-6.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 |
+|-------|---------|
+| VRTL-1.lite | qwen3:0.6b |
+| VRTL-2.fast | gemma3:1b |
+| VRTL-3.small | llama3.2:1b |
+| VRTL-4.balanced | qwen2.5:1.5b |
+| VRTL-5.plus | qwen3:1.7b |
+| VRTL-6.pro | qwen2.5:3b |
+
+Cloud models are available when the matching provider + API key is configured:
+
+| Model | Backend |
+|-------|---------|
+| VRTL-7.cloud-mini | gpt-4o-mini (OpenAI) |
+| VRTL-8.cloud | gpt-4o (OpenAI) |
+| VRTL-9.cloud-fast | claude-3-5-haiku-20241022 (Anthropic) |
+| VRTL-10.cloud-pro | claude-sonnet-4-20250514 (Anthropic) |
+| VRTL-11.cloud-lite | gemini-2.0-flash (Gemini) |
+| VRTL-12.cloud-plus | gemini-1.5-pro (Gemini) |
+
+> Legacy `vierratale-*` model names (e.g. `vierratale-fast`, `vierratale-cloud`)
+
+> still work and are stored as VRTL names.
 
 ## Commands
 
@@ -40,17 +60,139 @@ 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
+- `/fetch <url>` - Open a link and summarize its content
+- `/log [n|path]` - Show the last n log entries (default 30) or the log file path
 - `/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. Bare mentions of specific topics also
+trigger a search — e.g. `timun mas from indonesia`, `the legend of roro
+jonggrang`. For example:
+
+```
+> Who is Cristiano Ronaldo?
+> timun mas from indonesia
+```
+
+triggers a live web search and answers from the results. If no web results come
+back, the AI answers from its own knowledge instead of going quiet. Use
+`/search <query>` to force a search explicitly.
+
+Story requests about any subject work the same way — no matter how they're
+phrased (`a story about X`, `the legend of X`, `tell me about X`, `narrate the
+tale of X`, `write X into a txt file`). The subject is pulled out of the
+sentence, searched first, and the reply is saved to a `<subject>.txt` file.
+A generic `tell me a story` (no subject) is told directly from the model — and
+is also saved to a `.txt` file.
+
+Greetings (`hi`, `hello`, `hey`, `good morning`, ...) are answered instantly
+with a short fixed reply — they never reach the model.
+
+## Writing Files
+
+Ask the AI to create code, configs, scripts, web pages, or a whole project. When it
+responds, it lists each file with a `FILE: <path>` header followed by a code
+fence (and `FOLDER: <path>` for empty folders) — just running in the chat writes
+them to your disk in the current working directory. Any file type is supported,
+including JSON config files and HTML pages. Nested folders are created automatically, existing
+files are skipped unless you confirm to overwrite, and nothing is ever written
+outside the working directory.
+
+If the AI ever answers with the code but forgets the `FILE:` header (or writes an
+HTML page without a fence), the assistant rescues it: any `FILE: <path>` line in
+the reply is honored even without a fence, otherwise the request is used to
+infer a filename and the code block is saved anyway. Filename inference covers
+many formats, not just web pages:
+
+| Request contains… | Saved as |
+|--------------------|----------|
+| `html` / `webpage` / `website` / `page` | `index.html` |
+| `css` | `style.css` |
+| `python` / `py` | `script.py` |
+| `flask` / `django` / `fastapi` / `streamlit` / `app` | `app.py` |
+| `javascript` / `js` / `script` | `script.js` |
+| `typescript` / `ts` | `script.ts` |
+| `bash` / `zsh` / `shell` | `script.sh` |
+| `json` / `yaml` / `yml` / `csv` / `sql` | `output.json` / `.yml` / `.csv` / `.sql` |
+
+When the request has no hint at all, the fence language in the reply picks the
+name (```python → `script.py`, ```css → `style.css`, …). Saving also kicks in
+whenever the reply itself contains a `FILE:`/`FOLDER:` line, or when a reply is
+basically just one substantial code block, even if the request phrasing wasn't
+matched.
+
+For file requests, a short format instruction is silently attached to your
+message so the model emits complete `FILE:` blocks with closed fences. And if
+the model ever answers a file request *without any code* (free-style prose,
+interrupted before a fence), nothing is saved and you get a notice telling you
+to ask again — a `.py` file full of chatter is never created.
+
+Example of what the AI emits:
+
+```
+FILE: config.json
+```json
+{
+  "name": "my-app",
+  "port": 3000
+}
+```
+
+FILE: index.html
+```html
+<!doctype html>
+<html><body>Hello</body></html>
+```
+
+FILE: src/hello.js
+```js
+console.log('Hello VierrataleAI');
+```
+
+## Chat UI
+
+The chat runs in a clean, minimal full-screen interface: your turns are labelled
+`You` and the assistant's `AI`, with plain wrapped text in between. Code blocks
+are the exception — they render inside a green bordered box with their language
+tag (`╭─ html ─╮`), so files stand out at a glance. The latest reply stays pinned
+to the bottom of the terminal while it streams in (no screen flashing), and
+internal search/fetch context stays hidden.
+
+## Automatic Logging
+
+Everything that happens in a session is written automatically to a per-day log
+file in `~/.config/vierrataleai/logs/` (e.g. `vierrataleai-20260101.log`):
+app/session start, every user message, every AI reply, every file write or
+skip, and any errors — with a timestamp. The logs are plain text and safe to
+grep. To inspect them from inside the chat:
+
+```
+/log          # show the last 30 entries
+/log 100      # show the last 100 entries
+/log path     # print the log file path
+```
+
+## 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`
 
 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/bin/vierrataleai.js

@@ -1,3 +1,76 @@
 #!/usr/bin/env node
+// VierrataleAI launcher + installer.
+//
+// Running without flags starts the assistant (same as before).
+// Running with --install (or --setup / install) installs the engine + model and
+// creates a global "vierrataleai" command, then starts the assistant.
+//
+// Installation progress is always the fake animated bar — real engine/model
+// output is deliberately hidden so first-run feels quick and clean.
 import { run } from '../src/cli.js';
-run();
+import { Installer } from '../src/installer.js';
+import { Config } from '../src/config.js';
+import { Branding } from '../src/ui/branding.js';
+import { Terminal } from '../src/ui/terminal.js';
+
+const C = Branding.colors;
+
+const INSTALL_STEPS = [
+  'Checking the AI engine',
+  'Installing dependencies',
+  'Downloading the model',
+  'Linking the vierrataleai command',
+  'Optimizing for this device',
+];
+
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function fakeProgress(steps, work) {
+  const frames = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+  let i = 0;
+  const tty = process.stdout.isTTY;
+  const timer = setInterval(() => {
+    if (!tty) return;
+    i++;
+    const stage = steps[Math.floor((i / 10) % steps.length)];
+    const pct = String(8 + ((i * 7) % 85)).padStart(3, ' ');
+    const bar = frames[i % frames.length];
+    const fillLen = 1 + (i % 20);
+    const fill = '█'.repeat(fillLen) + '░'.repeat(Math.max(0, 20 - fillLen));
+    process.stdout.write(`\r  ${C.accent}${bar}${C.reset} ${C.bold}${pct}%${C.reset} ${C.dim}${stage}${C.reset} [${C.accent}${fill}${C.reset}]`);
+  }, 110);
+  try {
+    return await work;
+  } finally {
+    clearInterval(timer);
+    if (tty) process.stdout.write('\r\x1b[2K');
+    process.stdout.write(`  ${C.success}✔${C.reset} ${C.bold}${C.dim}100%${C.reset} ${C.dim}Ready${C.reset}\n`);
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const doInstall = args.includes('--install') || args.includes('--setup') || args.includes('install');
+
+  Config.load();
+
+  if (doInstall) {
+    console.log(`\n  ${C.bold}${C.primary}${Branding.APP_NAME} ${Branding.VERSION}${C.reset} ${C.dim}— installer${C.reset}\n`);
+    const result = await fakeProgress(INSTALL_STEPS, Installer.install());
+    if (!result.command) {
+      Terminal.printInfo('Could not create a global "vierrataleai" command; run it via the bin script.');
+    } else {
+      Terminal.printSuccess(`Engine + model installed; "vierrataleai" command available at ${result.command}`);
+    }
+    console.log();
+  }
+
+  return run();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "@vierratale/ai",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.11",
   "description": "VierrataleAI - Intelligent terminal assistant",
   "type": "module",
+  "files": [
+    "bin/",
+    "scripts/",
+    "src/",
+    "README.md"
+  ],
   "bin": {
     "vierrataleai": "./bin/vierrataleai.js"
   },
@@ -11,7 +17,9 @@
     ".": "./src/index.js"
   },
   "scripts": {
-    "start": "node bin/vierrataleai.js"
+    "start": "node bin/vierrataleai.js",
+    "test": "node --test \"test/*.test.js\"",
+    "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

@@ -1,16 +1,36 @@
+// Model catalog. Display names use the countable VRTL branding:
+// VRTL-<number>.<word>, e.g. VRTL-2.fast, VRTL-7.cloud-mini.
 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',
-  'gpt-4o-mini': 'vierratale-cloud-mini',
-  'gpt-4o': 'vierratale-cloud',
-  'claude-3-5-haiku-20241022': 'vierratale-cloud-fast',
-  'claude-sonnet-4-20250514': 'vierratale-cloud-pro',
-  'gemini-2.0-flash': 'vierratale-cloud-lite',
-  'gemini-1.5-pro': 'vierratale-cloud-plus',
+  'qwen3:0.6b': 'VRTL-1.lite',
+  'gemma3:1b': 'VRTL-2.fast',
+  'llama3.2:1b': 'VRTL-3.small',
+  'qwen2.5:1.5b': 'VRTL-4.balanced',
+  'qwen2.5-coder:1.5b': 'VRTL-4.coder',
+  'qwen3:1.7b': 'VRTL-5.plus',
+  'qwen2.5:3b': 'VRTL-6.pro',
+  'gpt-4o-mini': 'VRTL-7.cloud-mini',
+  'gpt-4o': 'VRTL-8.cloud',
+  'claude-3-5-haiku-20241022': 'VRTL-9.cloud-fast',
+  'claude-sonnet-4-20250514': 'VRTL-10.cloud-pro',
+  'gemini-2.0-flash': 'VRTL-11.cloud-lite',
+  'gemini-1.5-pro': 'VRTL-12.cloud-plus',
+};
+
+// Older `vierratale-<word>` names, accepted everywhere for backwards
+// compatibility (existing config files may still contain them).
+const LEGACY_DISPLAY = {
+  'vierratale-lite': 'VRTL-1.lite',
+  'vierratale-fast': 'VRTL-2.fast',
+  'vierratale-small': 'VRTL-3.small',
+  'vierratale-balanced': 'VRTL-4.balanced',
+  'vierratale-plus': 'VRTL-5.plus',
+  'vierratale-pro': 'VRTL-6.pro',
+  'vierratale-cloud-mini': 'VRTL-7.cloud-mini',
+  'vierratale-cloud': 'VRTL-8.cloud',
+  'vierratale-cloud-fast': 'VRTL-9.cloud-fast',
+  'vierratale-cloud-pro': 'VRTL-10.cloud-pro',
+  'vierratale-cloud-lite': 'VRTL-11.cloud-lite',
+  'vierratale-cloud-plus': 'VRTL-12.cloud-plus',
 };
 
 const REVERSE = Object.fromEntries(
@@ -18,26 +38,48 @@ const REVERSE = Object.fromEntries(
 );
 
 const LOCAL_MODELS = [
-  'vierratale-lite',
-  'vierratale-fast',
-  'vierratale-small',
-  'vierratale-balanced',
-  'vierratale-plus',
-  'vierratale-pro',
+  'VRTL-1.lite',
+  'VRTL-2.fast',
+  'VRTL-3.small',
+  'VRTL-4.balanced',
+  'VRTL-4.coder',
+  'VRTL-5.plus',
+  'VRTL-6.pro',
 ];
 
 const CLOUD_MODELS = [
-  'vierratale-cloud-mini',
-  'vierratale-cloud',
-  'vierratale-cloud-fast',
-  'vierratale-cloud-pro',
-  'vierratale-cloud-lite',
-  'vierratale-cloud-plus',
+  'VRTL-7.cloud-mini',
+  'VRTL-8.cloud',
+  'VRTL-9.cloud-fast',
+  'VRTL-10.cloud-pro',
+  'VRTL-11.cloud-lite',
+  'VRTL-12.cloud-plus',
 ];
 
+const TIERS = {
+  'VRTL-1.lite': 'minimal',
+  'VRTL-2.fast': 'fast',
+  'VRTL-3.small': 'small',
+  'VRTL-4.balanced': 'balanced',
+  'VRTL-4.coder': 'coder',
+  'VRTL-5.plus': 'plus',
+  'VRTL-6.pro': 'professional',
+  'VRTL-7.cloud-mini': 'cloud-mini',
+  'VRTL-8.cloud': 'cloud',
+  'VRTL-9.cloud-fast': 'cloud-fast',
+  'VRTL-10.cloud-pro': 'cloud-pro',
+  'VRTL-11.cloud-lite': 'cloud-lite',
+  'VRTL-12.cloud-plus': 'cloud-plus',
+};
+
 export const Catalog = {
+  // Map any known name (new or legacy) to the current VRTL display name.
+  normalize(displayName) {
+    return LEGACY_DISPLAY[displayName] || displayName;
+  },
+
   getRealModel(displayName) {
-    return REVERSE[displayName] || displayName;
+    return REVERSE[this.normalize(displayName)] || displayName;
   },
 
   getDisplayName(realModel) {
@@ -57,34 +99,41 @@ export const Catalog = {
   },
 
   getDefaultModel() {
-    return 'vierratale-fast';
+    return 'VRTL-2.fast';
+  },
+
+  getDefaultCloudModel() {
+    return 'VRTL-7.cloud-mini';
+  },
+
+  isLocalModel(displayName) {
+    return LOCAL_MODELS.includes(this.normalize(displayName));
+  },
+
+  isCloudModel(displayName) {
+    return CLOUD_MODELS.includes(this.normalize(displayName));
+  },
+
+  getVendorForCloudModel(displayName) {
+    const real = REVERSE[this.normalize(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];
+    const name = this.normalize(displayName);
+    const real = REVERSE[name];
     if (!real) return null;
-    const isLocal = LOCAL_MODELS.includes(displayName);
-    const isCloud = CLOUD_MODELS.includes(displayName);
-    const tiers = {
-      'vierratale-lite': 'minimal',
-      'vierratale-fast': 'fast',
-      'vierratale-small': 'small',
-      'vierratale-balanced': 'balanced',
-      'vierratale-plus': 'plus',
-      'vierratale-pro': 'professional',
-      'vierratale-cloud-mini': 'cloud-mini',
-      'vierratale-cloud': 'cloud',
-      'vierratale-cloud-fast': 'cloud-fast',
-      'vierratale-cloud-pro': 'cloud-pro',
-      'vierratale-cloud-lite': 'cloud-lite',
-      'vierratale-cloud-plus': 'cloud-plus',
-    };
+    const isLocal = LOCAL_MODELS.includes(name);
+    const isCloud = CLOUD_MODELS.includes(name);
     return {
       displayName,
       realModel: real,
       isLocal,
       isCloud,
-      tier: tiers[displayName] || 'unknown',
+      tier: TIERS[name] || 'unknown',
     };
   },
-};
+};