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

package/src/installer.js

@@ -1,5 +1,7 @@
 import { execSync, exec } from 'child_process';
-import { existsSync } from 'fs';
+import { existsSync, mkdirSync, symlinkSync, chmodSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir, platform } from 'os';
 import { Catalog } from './catalog.js';
 import { Config } from './config.js';
 
@@ -9,13 +11,13 @@ 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' });
     return true;
@@ -24,8 +26,9 @@ function isOllamaInstalled() {
   return paths.some((p) => existsSync(p));
 }
 
-async function installOllama() {
+async function installEngine() {
   await runSilent('curl -fsSL https://ollama.com/install.sh | sh');
+  return isEngineInstalled();
 }
 
 async function pullModel(host, model) {
@@ -53,27 +56,136 @@ async function getInstalledModels(host) {
   }
 }
 
+// Scripts in the same model family share a base name before any variant
+// suffix (e.g. qwen2.5-coder:1.5b is the sibling of qwen2.5:1.5b).
+function familyOf(model) {
+  return model
+    .split(':')[0]
+    .toLowerCase()
+    .replace(/-(coder|instruct|reasoning|chat|base|tiny|nano)$/, '');
+}
+
+function sizeOf(model) {
+  const size = model.split(':')[1] || '';
+  const match = size.match(/(\d+(?:\.\d+)?)(m|b)/i);
+  if (!match) return Number.POSITIVE_INFINITY;
+  const value = parseFloat(match[1]);
+  return match[2].toLowerCase() === 'b' ? value * 1000 : value;
+}
+
+// Find the already-installed model that best matches the requested one.
+// Prefers an exact match, then any same-family sibling (closest size).
+function chooseModel(installed, realModel) {
+  if (installed.includes(realModel)) {
+    return { model: realModel, substituted: false, reason: null };
+  }
+  const fam = familyOf(realModel);
+  let best = null;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (const m of installed) {
+    if (familyOf(m) !== fam) continue;
+    const dist = Math.abs(sizeOf(m) - sizeOf(realModel)) + 0.5;
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = m;
+    }
+  }
+  if (best) {
+    return {
+      model: best,
+      substituted: true,
+      reason: `"${realModel}" is not installed; using ${best} (same family)`,
+    };
+  }
+  return { model: null, substituted: true, reason: `"${realModel}" is not installed` };
+}
+
+async function resolveModel(host, realModel) {
+  const installed = await getInstalledModels(host);
+  return chooseModel(installed, realModel);
+}
+
+// Best local bin dir for a globally-callable command on this platform.
+function localBinDir() {
+  if (process.env.XDG_BIN_HOME) return process.env.XDG_BIN_HOME;
+  if (process.env.HOME) return join(homedir(), '.local', 'bin');
+  return '/usr/local/bin';
+}
+
+function installAppCommand() {
+  try {
+    const dir = localBinDir();
+    mkdirSync(dir, { recursive: true, mode: 0o755 });
+    const launcherPath = join(dir, 'vierrataleai');
+    if (platform() === 'win32') {
+      if (existsSync(launcherPath)) return launcherPath;
+      writeFileSync(launcherPath, `@echo off\r\nnode "${process.argv[1]}" %*\r\n`);
+      return launcherPath;
+    }
+    // Prefer a real symlink; fall back to a small shim that calls the node bin.
+    if (existsSync(launcherPath)) return launcherPath;
+    const target = process.argv[1] && existsSync(process.argv[1]) ? process.argv[1] : join(Config.getConfigDir(), '..', '..', 'src', 'cli.js');
+    try {
+      symlinkSync(target, launcherPath);
+      chmodSync(launcherPath, 0o755);
+    } catch {
+      writeFileSync(launcherPath, `#!/bin/sh\nnode "${target}" "$@"\n`);
+      chmodSync(launcherPath, 0o755);
+    }
+    return launcherPath;
+  } catch {
+    return null;
+  }
+}
+
 export const Installer = {
+  async pullModel(host, model) {
+    return pullModel(host, model);
+  },
+
+  async getInstalledModels(host) {
+    return getInstalledModels(host);
+  },
+
+  async resolveModel(host, realModel) {
+    return resolveModel(host, realModel);
+  },
+
+  async firstInstalled(host) {
+    const installed = await getInstalledModels(host);
+    return installed[0] || null;
+  },
+
+  chooseModel,
+
   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' });
-        await new Promise((r) => setTimeout(r, 3000));
+        // No systemd available here, so launch the daemon directly, detached,
+        // and poll until it responds instead of relying on a service manager.
+        const child = exec('ollama serve', {
+          stdio: 'ignore',
+          detached: true,
+        });
+        if (child.unref) child.unref();
+        for (let i = 0; i < 30; i++) {
+          await new Promise((r) => setTimeout(r, 1000));
+          if (await isEngineRunning(host)) break;
+        }
       } 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])
-    );
+    const resolved = chooseModel(installed, realModel);
+    const needsPull = resolved.model == null;
 
     if (needsPull) {
       await pullModel(host, realModel);
@@ -83,7 +195,39 @@ export const Installer = {
   },
 
   async isReady() {
-    const host = Config.get('ollamaHost');
-    return isOllamaRunning(host);
+    const host = Config.get('engineHost');
+    return isEngineRunning(host);
+  },
+
+  // Full install: engine + model + a global "vierrataleai" command.
+  async install({ includeCommand = true } = {}) {
+    const host = Config.get('engineHost');
+
+    if (!isEngineInstalled()) {
+      await installEngine();
+    }
+
+    const running = await isEngineRunning(host);
+    if (!running) {
+      try {
+        const child = exec('ollama serve', { stdio: 'ignore', detached: true });
+        if (child.unref) child.unref();
+        for (let i = 0; i < 30; i++) {
+          await new Promise((r) => setTimeout(r, 1000));
+          if (await isEngineRunning(host)) break;
+        }
+      } catch {}
+    }
+
+    const realModel = Catalog.getRealModel(Config.get('model'));
+    const installed = await getInstalledModels(host);
+    const resolved = chooseModel(installed, realModel);
+    if (resolved.model == null) {
+      await pullModel(host, realModel);
+    }
+
+    let command = null;
+    if (includeCommand) command = installAppCommand();
+    return { installed: await isEngineInstalled(), running: await isEngineRunning(host), command };
   },
 };

package/src/prompts/system.json

@@ -1,3 +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."
-}
+  "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. You CAN write files and folders directly to the user's disk. When the user asks you to create, save, or generate code, configs, scripts, projects, web pages, or any other files, DO NOT refuse — answer with the FILE:/FOLDER: format instead. Use this exact format for EACH file: a line \"FILE: relative/path/to/file\" on its own line, immediately followed by a markdown code fence containing the file content. This works for any file type, including JSON config files and HTML pages: write a config as \"FILE: config.json\" followed by a ```json fence, and a web page as \"FILE: index.html\" followed by a ```html fence with the full <!doctype html>... markup inside. Use paths relative to the user's working directory. Emit one FILE: block per file; nested folders are created automatically. If you need an empty folder, emit \"FOLDER: relative/path\" on its own line. When asked for a story, folk tale, legend, or myth, give the real, well-known version using the web search results you were given when available, and also save the full story to a .txt file using FILE: <title>.txt followed by a ```text fence. Keep any explanation short and outside of the FILE:/FOLDER: blocks."
+}

package/src/prompts/system.md

@@ -13,3 +13,45 @@ You are **VierrataleAI**, an intelligent AI assistant created by Vierratale.
 - 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.
+
+## Writing Files and Folders
+
+You CAN write files and folders directly to the user's disk. When the user asks
+you to create, save, or generate code, configs, scripts, projects, or any other
+files, DO NOT refuse — answer with the format below. Use this exact format for
+EACH file:
+
+    FILE: relative/path/to/file.js
+    ```js
+    // file content here
+    ```
+
+This works for any file type, including JSON and HTML. For example, write a
+config file exactly like this:
+
+    FILE: config.json
+    ```json
+    {
+      "name": "my-app",
+      "port": 3000
+    }
+    ```
+
+And a web page like this:
+
+    FILE: index.html
+    ```html
+    <!doctype html>
+    <html>
+    <head><title>My Page</title></head>
+    <body><h1>Hello</h1></body>
+    </html>
+    ```
+
+Rules:
+- Put `FILE: <path>` on its own line, immediately followed by a markdown code fence containing the file content. No text between the header and the fence.
+- Use paths relative to the user's working directory (e.g. `src/app.js`, `config.json`).
+- Emit one `FILE:` block per file; nested folders are created automatically.
+- If you need an empty folder, emit `FOLDER: <path>` on its own line.
+- When asked for a story, folk tale, legend, or myth, give the real, well-known version — use the web search results you were given when available — and also save the full story to a .txt file using `FILE: <title>.txt` followed by a ```text fence.
+- Keep any explanation short and outside of the `FILE:`/`FOLDER:` blocks.

package/src/providers/anthropic.js

@@ -0,0 +1,130 @@
+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('[ERR-0004] Cloud API key not configured. Add it to the config and try again.');
+
+    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 controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 240000);
+
+    let resp;
+    try {
+      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'),
+        }),
+        signal: controller.signal,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error('[ERR-0001] Could not reach the API (no response within 60s). Check your network connection.');
+      }
+      throw new Error('[ERR-0001] Could not reach the API (no response). Check your network connection.');
+    } finally {
+      clearTimeout(connectTimer);
+    }
+
+    if (!resp.ok) {
+      throw new Error('[ERR-0003] The cloud provider returned HTTP ' + resp.status + '. Check your API key in config.');
+    }
+
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let idle = null;
+    const settle = () => {
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), 240000);
+    };
+    settle();
+    try {
+      while (true) {
+        let value, done;
+        try {
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (err.name === 'AbortError') {
+            throw new Error('[ERR-0001] Lost the connection to the cloud API (no data for 60s).');
+          }
+          throw err;
+        }
+        if (done) break;
+        settle();
+        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 {}
+        }
+      }
+    } finally {
+      if (idle) clearTimeout(idle);
+    }
+  }
+}

package/src/providers/base.js

@@ -3,10 +3,28 @@ export class BaseProvider {
     this.name = name;
   }
 
+  get displayName() {
+    return 'Cortex';
+  }
+
+  get isLocal() {
+    return false;
+  }
+
   async *stream(messages, options = {}) {
     throw new Error('stream() must be implemented');
   }
 
+  // Non-streaming convenience: collects the stream. Providers may override
+  // with a proper single-shot request (see CortexProvider).
+  async complete(messages, options = {}) {
+    let out = '';
+    for await (const chunk of this.stream(messages, options)) {
+      out += chunk;
+    }
+    return out;
+  }
+
   async listModels() {
     throw new Error('listModels() must be implemented');
   }