@vierratale/ai 0.1.0-beta.1

package/README.md

@@ -0,0 +1,57 @@
+# VierrataleAI
+
+Intelligent terminal assistant that runs AI models locally and in the cloud.
+
+## Install
+
+```bash
+# From npm
+npm install -g @vierratale/ai
+
+# Or run directly
+npx @vierratale/ai
+```
+
+## 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
+```
+
+## 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 |
+
+## Commands
+
+- `/help` - Show commands
+- `/model [name]` - Switch model
+- `/provider [name]` - Switch provider
+- `/models` - List available models
+- `/clear` - Clear screen
+- `/quit` - Exit
+
+## Configuration
+
+Config file: `~/.config/vierrataleai/config.json`
+
+Environment variables:
+- `VIERRATALE_PROVIDER` - Default provider
+- `VIERRATALE_MODEL` - Default model
+- `OPENAI_API_KEY` - OpenAI API key (for cloud models)
+
+## License
+
+MIT

package/bin/vierrataleai.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { run } from '../src/cli.js';
+run();

package/build.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# Build VierrataleAI Node.js version for packaging
+set -e
+
+cd "$(dirname "$0")"
+
+echo "Installing dependencies..."
+npm install
+
+echo "Testing..."
+node bin/vierrataleai.js --version
+
+echo "Packaging..."
+npm pack
+
+echo "Build complete!"
+echo "To publish: npm publish --tag beta"

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@vierratale/ai",
+  "version": "0.1.0-beta.1",
+  "description": "VierrataleAI - Intelligent terminal assistant",
+  "type": "module",
+  "bin": {
+    "vierrataleai": "./bin/vierrataleai.js"
+  },
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "scripts": {
+    "start": "node bin/vierrataleai.js"
+  },
+  "keywords": ["ai", "chatbot", "terminal", "assistant", "llm"],
+  "author": "Vierratale",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {}
+}

package/src/catalog.js

@@ -0,0 +1,90 @@
+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',
+};
+
+const REVERSE = Object.fromEntries(
+  Object.entries(MODELS).map(([k, v]) => [v, k])
+);
+
+const LOCAL_MODELS = [
+  'vierratale-lite',
+  'vierratale-fast',
+  'vierratale-small',
+  'vierratale-balanced',
+  'vierratale-plus',
+  'vierratale-pro',
+];
+
+const CLOUD_MODELS = [
+  'vierratale-cloud-mini',
+  'vierratale-cloud',
+  'vierratale-cloud-fast',
+  'vierratale-cloud-pro',
+  'vierratale-cloud-lite',
+  'vierratale-cloud-plus',
+];
+
+export const Catalog = {
+  getRealModel(displayName) {
+    return REVERSE[displayName] || displayName;
+  },
+
+  getDisplayName(realModel) {
+    return MODELS[realModel] || realModel;
+  },
+
+  getAllModels() {
+    return { ...MODELS };
+  },
+
+  getLocalModels() {
+    return [...LOCAL_MODELS];
+  },
+
+  getCloudModels() {
+    return [...CLOUD_MODELS];
+  },
+
+  getDefaultModel() {
+    return 'vierratale-fast';
+  },
+
+  getModelInfo(displayName) {
+    const real = REVERSE[displayName];
+    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',
+    };
+    return {
+      displayName,
+      realModel: real,
+      isLocal,
+      isCloud,
+      tier: tiers[displayName] || 'unknown',
+    };
+  },
+};

package/src/cli.js

@@ -0,0 +1,206 @@
+import { createInterface } from 'readline';
+import { Config } from './config.js';
+import { Catalog } from './catalog.js';
+import { Installer } from './installer.js';
+import { ProviderFactory } from './providers/index.js';
+import { Branding } from './ui/branding.js';
+import { Terminal } from './ui/terminal.js';
+import { loadSystemPrompt, showBanner } from './ui/banner.js';
+
+function parseArgs(args) {
+  const parsed = { provider: null, model: null, clear: false, version: false, help: false };
+  for (let i = 2; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--provider' || arg === '-p') parsed.provider = args[++i];
+    else if (arg === '--model' || arg === '-m') parsed.model = args[++i];
+    else if (arg === '--clear') parsed.clear = true;
+    else if (arg === '--version' || arg === '-v') parsed.version = true;
+    else if (arg === '--help' || arg === '-h') parsed.help = true;
+  }
+  return parsed;
+}
+
+function showHelp() {
+  console.log(`
+${Branding.APP_NAME} ${Branding.VERSION}
+Usage: vierrataleai [options]
+
+Options:
+  --provider, -p <name>   Provider: ollama, openai (default: auto-detect)
+  --model, -m <name>      Model: vierratale-lite/fast/balanced/pro/cloud
+  --clear                 Clear screen on start
+  --version, -v           Show version
+  --help, -h              Show this help
+
+Commands (in chat):
+  /help                   Show commands
+  /model [name]           Switch model
+  /provider [name]        Switch provider
+  /models                 List available models
+  /clear                  Clear screen
+  /quit                   Exit
+`);
+}
+
+async function chat(provider, systemPrompt) {
+  const messages = [];
+  let exited = false;
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false,
+  });
+
+  rl.on('close', () => {
+    if (!exited) {
+      exited = true;
+      process.exit(0);
+    }
+  });
+
+  const prompt = () => new Promise((resolve) => {
+    rl.question(
+      `${Branding.colors.bold}${Branding.colors.primary}${Branding.USER_PROMPT} >${Branding.colors.reset} `,
+      resolve
+    );
+  });
+
+  while (!exited) {
+    let input;
+    try {
+      input = await prompt();
+    } catch {
+      break;
+    }
+
+    if (input === undefined || input === null) break;
+
+    const trimmed = input.trim();
+    if (!trimmed) continue;
+
+    const cmd = trimmed.toLowerCase();
+
+    if (cmd === '/quit' || cmd === '/exit' || cmd === '/q') {
+      Terminal.printInfo('Goodbye!');
+      exited = true;
+      rl.close();
+      break;
+    }
+
+    if (cmd === '/clear') {
+      Terminal.clear();
+      showBanner(provider.name, Config.get('model'));
+      continue;
+    }
+
+    if (cmd === '/help') {
+      showHelp();
+      continue;
+    }
+
+    if (cmd === '/models') {
+      const models = provider.name === 'ollama'
+        ? 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)' : '';
+        console.log(`  ${Branding.colors.accent}${m}${Branding.colors.dim}${current} - ${info.tier}${Branding.colors.reset}`);
+      }
+      continue;
+    }
+
+    if (cmd.startsWith('/model ')) {
+      const modelName = cmd.split(' ')[1];
+      if (modelName) {
+        if (Catalog.getModelInfo(modelName)) {
+          Config.save({ model: modelName });
+          Terminal.printSuccess(`Model: ${modelName}`);
+        } else {
+          Terminal.printError(`Unknown model: ${modelName}`);
+        }
+      }
+      continue;
+    }
+
+    if (cmd === '/model') {
+      Terminal.printInfo(`Current model: ${Config.get('model')}`);
+      continue;
+    }
+
+    if (cmd.startsWith('/provider ')) {
+      const prov = cmd.split(' ')[1];
+      if (['ollama', 'openai'].includes(prov)) {
+        Config.save({ provider: prov });
+        Terminal.printSuccess(`Provider: ${prov}`);
+      } else {
+        Terminal.printError(`Unknown provider: ${prov}`);
+      }
+      continue;
+    }
+
+    if (cmd === '/provider') {
+      Terminal.printInfo(`Current provider: ${provider.name}`);
+      continue;
+    }
+
+    messages.push({ role: 'user', content: trimmed });
+    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 });
+    }
+  }
+}
+
+export async function run() {
+  const args = parseArgs(process.argv);
+
+  if (args.version) {
+    console.log(`${Branding.APP_NAME} ${Branding.VERSION}`);
+    return;
+  }
+
+  if (args.help) {
+    showHelp();
+    return;
+  }
+
+  Config.load();
+  if (args.provider) Config.save({ provider: args.provider });
+  if (args.model) Config.save({ model: args.model });
+
+  Terminal.printInfo('Initializing...');
+  await Installer.ensure();
+
+  const provider = await ProviderFactory.autoDetect();
+  if (!provider) {
+    Terminal.printError('No AI engine available. Please install or configure a provider.');
+    process.exit(1);
+  }
+
+  Config.save({ provider: provider.name });
+
+  if (args.clear) Terminal.clear();
+  showBanner(provider.name, Config.get('model'));
+
+  const systemPrompt = loadSystemPrompt();
+  await chat(provider, systemPrompt);
+  process.exit(0);
+}

package/src/config.js

@@ -0,0 +1,72 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const CONFIG_DIR = join(homedir(), '.config', 'vierrataleai');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+const DEFAULTS = {
+  provider: 'auto',
+  model: 'vierratale-fast',
+  ollamaHost: 'http://127.0.0.1:11434',
+  numCtx: 8192,
+  temperature: 0.7,
+  maxTokens: 4096,
+};
+
+function loadConfigFile() {
+  try {
+    if (existsSync(CONFIG_FILE)) {
+      const raw = readFileSync(CONFIG_FILE, 'utf-8');
+      return JSON.parse(raw);
+    }
+  } catch {}
+  return {};
+}
+
+function getEnv(key, fallback) {
+  return process.env[key] || fallback;
+}
+
+export const Config = {
+  _config: null,
+
+  load() {
+    const file = loadConfigFile();
+    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),
+      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))),
+      openaiApiKey: getEnv('OPENAI_API_KEY', file.openaiApiKey || ''),
+      anthropicApiKey: getEnv('ANTHROPIC_API_KEY', file.anthropicApiKey || ''),
+    };
+    return this._config;
+  },
+
+  get(key) {
+    if (!this._config) this.load();
+    return this._config[key];
+  },
+
+  getAll() {
+    if (!this._config) this.load();
+    return { ...this._config };
+  },
+
+  save(overrides = {}) {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const current = this._config || DEFAULTS;
+    const merged = { ...current, ...overrides };
+    writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+    this._config = merged;
+  },
+
+  getConfigDir() {
+    return CONFIG_DIR;
+  },
+};

package/src/index.js

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

package/src/installer.js

@@ -0,0 +1,89 @@
+import { execSync, exec } from 'child_process';
+import { existsSync } from 'fs';
+import { Catalog } from './catalog.js';
+import { Config } from './config.js';
+
+function runSilent(cmd) {
+  return new Promise((resolve) => {
+    exec(cmd, { stdio: 'ignore' }, (err) => resolve(!err));
+  });
+}
+
+function isOllamaRunning(host) {
+  return fetch(`${host}/api/tags`, { signal: AbortSignal.timeout(3000) })
+    .then((r) => r.ok)
+    .catch(() => false);
+}
+
+function isOllamaInstalled() {
+  try {
+    execSync('which ollama 2>/dev/null', { stdio: 'ignore' });
+    return true;
+  } catch {}
+  const paths = ['/usr/local/bin/ollama', '/usr/bin/ollama'];
+  return paths.some((p) => existsSync(p));
+}
+
+async function installOllama() {
+  await runSilent('curl -fsSL https://ollama.com/install.sh | sh');
+}
+
+async function pullModel(host, model) {
+  try {
+    const resp = await fetch(`${host}/api/pull`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: model, stream: false }),
+      signal: AbortSignal.timeout(600000),
+    });
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function getInstalledModels(host) {
+  try {
+    const resp = await fetch(`${host}/api/tags`);
+    if (!resp.ok) return [];
+    const data = await resp.json();
+    return (data.models || []).map((m) => m.name);
+  } catch {
+    return [];
+  }
+}
+
+export const Installer = {
+  async ensure() {
+    const host = Config.get('ollamaHost');
+
+    if (!isOllamaInstalled()) {
+      await installOllama();
+    }
+
+    const running = await isOllamaRunning(host);
+    if (!running) {
+      try {
+        execSync('ollama serve &', { stdio: 'ignore' });
+        await new Promise((r) => setTimeout(r, 3000));
+      } 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])
+    );
+
+    if (needsPull) {
+      await pullModel(host, realModel);
+    }
+
+    return true;
+  },
+
+  async isReady() {
+    const host = Config.get('ollamaHost');
+    return isOllamaRunning(host);
+  },
+};

package/src/prompts/system.json

@@ -0,0 +1,3 @@
+{
+  "system": "You are VierrataleAI, an intelligent AI assistant created by Vierratale. You are helpful, concise, and accurate. You provide clear answers and help users with their questions and tasks. When asked about your identity, always respond that you are VierrataleAI, an AI assistant created by Vierratale."
+}

package/src/prompts/system.md

@@ -0,0 +1,15 @@
+# VierrataleAI System Prompt
+
+You are **VierrataleAI**, an intelligent AI assistant created by Vierratale.
+
+## Identity
+- When asked "who are you" or similar, always respond: "I am VierrataleAI, an AI assistant created by Vierratale."
+- Never mention underlying engines, providers, or model names.
+- Always refer to yourself as VierrataleAI.
+
+## Behavior
+- Be helpful, concise, and accurate.
+- Provide clear answers to questions.
+- Help users with tasks including coding, writing, analysis, and general knowledge.
+- If you don't know something, say so honestly.
+- Use markdown formatting when appropriate for readability.

package/src/providers/base.js

@@ -0,0 +1,17 @@
+export class BaseProvider {
+  constructor(name) {
+    this.name = name;
+  }
+
+  async *stream(messages, options = {}) {
+    throw new Error('stream() must be implemented');
+  }
+
+  async listModels() {
+    throw new Error('listModels() must be implemented');
+  }
+
+  async isAvailable() {
+    return false;
+  }
+}

package/src/providers/index.js

@@ -0,0 +1,41 @@
+import { OllamaProvider } from './ollama.js';
+import { OpenAIProvider } from './openai.js';
+import { Config } from '../config.js';
+
+let providers = {};
+
+function getProviders() {
+  if (Object.keys(providers).length === 0) {
+    providers = {
+      ollama: new OllamaProvider(),
+      openai: new OpenAIProvider(),
+    };
+  }
+  return providers;
+}
+
+export const ProviderFactory = {
+  async autoDetect() {
+    const ps = getProviders();
+    const requested = Config.get('provider');
+
+    if (requested !== 'auto' && ps[requested]) {
+      if (await ps[requested].isAvailable()) return ps[requested];
+    }
+
+    for (const name of ['ollama', 'openai']) {
+      if (await ps[name].isAvailable()) return ps[name];
+    }
+
+    return null;
+  },
+
+  create(name) {
+    const ps = getProviders();
+    return ps[name] || null;
+  },
+
+  getAvailable() {
+    return getProviders();
+  },
+};

package/src/providers/ollama.js

@@ -0,0 +1,89 @@
+import { BaseProvider } from './base.js';
+import { Catalog } from '../catalog.js';
+import { Config } from '../config.js';
+
+export class OllamaProvider extends BaseProvider {
+  constructor() {
+    super('ollama');
+    this.host = Config.get('ollamaHost');
+  }
+
+  async isAvailable() {
+    try {
+      const resp = await fetch(`${this.host}/api/tags`, { signal: AbortSignal.timeout(3000) });
+      return resp.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async listModels() {
+    try {
+      const resp = await fetch(`${this.host}/api/tags`);
+      if (!resp.ok) return [];
+      const data = await resp.json();
+      return (data.models || []).map((m) => ({
+        realName: m.name,
+        displayName: Catalog.getDisplayName(m.name),
+        size: m.size,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  async *stream(messages, options = {}) {
+    const model = Catalog.getRealModel(options.model || Config.get('model'));
+    const systemPrompt = options.systemPrompt || '';
+
+    const ollamaMessages = [];
+    if (systemPrompt) {
+      ollamaMessages.push({ role: 'system', content: systemPrompt });
+    }
+    for (const msg of messages) {
+      ollamaMessages.push({ role: msg.role, content: msg.content });
+    }
+
+    const resp = await fetch(`${this.host}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        messages: ollamaMessages,
+        stream: true,
+        options: {
+          num_ctx: Config.get('numCtx'),
+          temperature: options.temperature || Config.get('temperature'),
+        },
+      }),
+    });
+
+    if (!resp.ok) {
+      throw new Error('Failed to connect to backend 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.trim()) continue;
+        try {
+          const json = JSON.parse(line);
+          if (json.message?.content) {
+            yield json.message.content;
+          }
+          if (json.done) return;
+        } catch {}
+      }
+    }
+  }
+}

package/src/providers/openai.js

@@ -0,0 +1,102 @@
+import { BaseProvider } from './base.js';
+import { Catalog } from '../catalog.js';
+import { Config } from '../config.js';
+
+export class OpenAIProvider extends BaseProvider {
+  constructor() {
+    super('openai');
+  }
+
+  async isAvailable() {
+    const key = Config.get('openaiApiKey');
+    if (!key) return false;
+    try {
+      const resp = await fetch('https://api.openai.com/v1/models', {
+        headers: { Authorization: `Bearer ${key}` },
+        signal: AbortSignal.timeout(5000),
+      });
+      return resp.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async listModels() {
+    const key = Config.get('openaiApiKey');
+    if (!key) return [];
+    try {
+      const resp = await fetch('https://api.openai.com/v1/models', {
+        headers: { Authorization: `Bearer ${key}` },
+      });
+      if (!resp.ok) return [];
+      const data = await resp.json();
+      return (data.data || [])
+        .filter((m) => m.id.startsWith('gpt-'))
+        .map((m) => ({
+          realName: m.id,
+          displayName: Catalog.getDisplayName(m.id),
+        }));
+    } catch {
+      return [];
+    }
+  }
+
+  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 systemPrompt = options.systemPrompt || '';
+
+    const apiMessages = [];
+    if (systemPrompt) {
+      apiMessages.push({ role: 'system', content: systemPrompt });
+    }
+    for (const msg of messages) {
+      apiMessages.push({ role: msg.role, content: msg.content });
+    }
+
+    const resp = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${key}`,
+      },
+      body: JSON.stringify({
+        model,
+        messages: apiMessages,
+        stream: true,
+        temperature: options.temperature || Config.get('temperature'),
+        max_tokens: 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);
+        if (data === '[DONE]') return;
+        try {
+          const json = JSON.parse(data);
+          const content = json.choices?.[0]?.delta?.content;
+          if (content) yield content;
+        } catch {}
+      }
+    }
+  }
+}

package/src/ui/banner.js

@@ -0,0 +1,31 @@
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { Branding } from './branding.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export function loadSystemPrompt() {
+  try {
+    const jsonPath = join(__dirname, '..', 'prompts', 'system.json');
+    const data = JSON.parse(readFileSync(jsonPath, 'utf-8'));
+    return data.system;
+  } catch {
+    return `You are ${Branding.APP_NAME}, an intelligent AI assistant. Be helpful, concise, and accurate.`;
+  }
+}
+
+export function showBanner(provider, model) {
+  console.log(Branding.colors.primary + Branding.BANNER + Branding.colors.reset);
+  console.log(
+    `  ${Branding.colors.dim}Intelligent Terminal Assistant${Branding.colors.reset}`
+  );
+  console.log(
+    `  ${Branding.colors.accent}Model:${Branding.colors.reset} ${model}  ` +
+    `${Branding.colors.accent}Engine:${Branding.colors.reset} ${provider}`
+  );
+  console.log(
+    `  ${Branding.colors.dim}Type /help for commands, /quit to exit${Branding.colors.reset}`
+  );
+  console.log();
+}

package/src/ui/branding.js

@@ -0,0 +1,31 @@
+export const Branding = {
+  APP_NAME: 'VierrataleAI',
+  VERSION: '0.1.0-beta.1',
+
+  colors: {
+    primary: '\x1b[38;2;124;58;237m',
+    accent: '\x1b[38;2;6;182;212m',
+    success: '\x1b[38;2;16;185;129m',
+    warning: '\x1b[38;2;245;158;11m',
+    error: '\x1b[38;2;239;68;68m',
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+    reset: '\x1b[0m',
+  },
+
+  BANNER: [
+    '',
+    '  ██╗   ██╗██╗██████╗ ███████╗',
+    '  ██║   ██║██║██╔══██╗██╔════╝',
+    '  ██║   ██║██║██████╔╝█████╗  ',
+    '  ╚██╗ ██╔╝██║██╔══██╗██╔══╝  ',
+    '   ╚████╔╝ ██║██████╔╝███████╗',
+    '    ╚═══╝  ╚═╝╚═════╝ ╚══════╝',
+    '',
+  ].join('\n'),
+
+  USER_PROMPT: 'You',
+  AI_PROMPT: 'AI',
+
+  SYSTEM_PROMPT_FILE: null,
+};

package/src/ui/terminal.js

@@ -0,0 +1,49 @@
+import { Branding } from './branding.js';
+
+const C = Branding.colors;
+
+export const Terminal = {
+  printUser(text) {
+    console.log(`${C.bold}${C.primary}${Branding.USER_PROMPT} >${C.reset} ${text}`);
+  },
+
+  printAIStart() {
+    process.stdout.write(`${C.bold}${C.accent}${Branding.AI_PROMPT} >${C.reset} `);
+  },
+
+  printAIChunk(text) {
+    process.stdout.write(text);
+  },
+
+  printAIEnd() {
+    console.log();
+    console.log();
+  },
+
+  printError(msg) {
+    console.error(`${C.error}Error: ${msg}${C.reset}`);
+  },
+
+  printInfo(msg) {
+    console.log(`${C.dim}${msg}${C.reset}`);
+  },
+
+  printSuccess(msg) {
+    console.log(`${C.success}${msg}${C.reset}`);
+  },
+
+  printWarning(msg) {
+    console.log(`${C.warning}${msg}${C.reset}`);
+  },
+
+  clear() {
+    process.stdout.write('\x1b[2J\x1b[H');
+  },
+
+  formatMarkdown(text) {
+    return text
+      .replace(/\*\*(.*?)\*\*/g, `${C.bold}$1${C.reset}`)
+      .replace(/`([^`]+)`/g, `${C.accent}\`$1\`${C.reset}`)
+      .replace(/```(\w*)\n([\s\S]*?)```/g, `${C.dim}┌─$1─┐${C.reset}\n$2${C.dim}└─────┘${C.reset}`);
+  },
+};

package/src/utils/http.js

@@ -0,0 +1,29 @@
+export const Http = {
+  async fetch(url, options = {}) {
+    const timeout = options.timeout || 30000;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const resp = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+      });
+      return resp;
+    } finally {
+      clearTimeout(timer);
+    }
+  },
+
+  async post(url, body, options = {}) {
+    return this.fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...options.headers,
+      },
+      body: JSON.stringify(body),
+      ...options,
+    });
+  },
+};

package/src/utils/platform.js

@@ -0,0 +1,32 @@
+import { platform, homedir } from 'os';
+
+export const Platform = {
+  isLinux() {
+    return platform() === 'linux';
+  },
+
+  isMac() {
+    return platform() === 'darwin';
+  },
+
+  isWindows() {
+    return platform() === 'win32';
+  },
+
+  isTermux() {
+    return process.env.TERMUX_VERSION !== undefined || platform().includes('android');
+  },
+
+  getHomeDir() {
+    return homedir();
+  },
+
+  getConfigDir() {
+    const home = homedir();
+    if (this.isTermux()) {
+      return `${home}/.config/vierrataleai`;
+    }
+    const base = process.env.XDG_CONFIG_HOME || `${home}/.config`;
+    return `${base}/vierrataleai`;
+  },
+};