@vierratale/ai 0.1.0-beta.13 → 0.1.0-beta.14

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vierratale
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/vierrataleai.js

@@ -9,11 +9,9 @@
 // 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';
-import { Installer } from '../src/installer.js';
+import { Engine } from '../src/engine.js';
 import { Config } from '../src/config.js';
 import { Branding } from '../src/ui/branding.js';
-import { Terminal } from '../src/ui/terminal.js';
-import { dirname } from 'path';
 
 const C = Branding.colors;
 
@@ -63,19 +61,11 @@ async function main() {
 
   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 command; run it via the bin script.');
-    } else {
-      Terminal.printSuccess(`Engine + model installed; "vierrataleai" (or "vierratale") command available at ${result.commandAlias || result.command}`);
-      if (!result.commandOnPath) {
-        Terminal.printInfo(`"vierrataleai" won't resolve in a new shell: add ${dirname(result.command)} to PATH, e.g. export PATH="$HOME/.local/bin:$PATH", then reopen the terminal.`);
-      }
-    }
+    await fakeProgress(INSTALL_STEPS, Engine.ensure());
     console.log();
   } else if (!quick) {
     // Auto-detect: install anything that's missing (engine, model) before starting.
-    await fakeProgress(READY_STEPS, Installer.ensure());
+    await fakeProgress(READY_STEPS, Engine.ensure());
     console.log();
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vierratale/ai",
-  "version": "0.1.0-beta.13",
+  "version": "0.1.0-beta.14",
   "description": "VierrataleAI - Intelligent terminal assistant",
   "type": "module",
   "license": "MIT",
@@ -18,6 +18,7 @@
     "bin",
     "src",
     "scripts",
+    "LICENSE",
     "README.md"
   ],
   "keywords": [

package/src/cli.js

@@ -2,7 +2,7 @@ import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { Config } from './config.js';
 import { Catalog } from './catalog.js';
-import { Installer } from './installer.js';
+import { Engine } from './engine.js';
 import { ProviderFactory } from './providers/index.js';
 import { Branding } from './ui/branding.js';
 import { Terminal } from './ui/terminal.js';
@@ -811,7 +811,7 @@ async function chat(provider, systemPrompt) {
         : Catalog.getCloudModels();
       const installedSet = new Set();
       if (provider.isLocal) {
-        for (const m of await Installer.getInstalledModels(Config.get('engineHost'))) {
+        for (const m of await Engine.getInstalledModels(Config.get('engineHost'))) {
           installedSet.add(m);
         }
       }
@@ -1114,18 +1114,18 @@ async function ensureLocalModel(modelName, notify) {
 // dead-ends while at least one local model exists.
 async function ensureRawLocalModel(realModel, notify) {
   const host = Config.get('engineHost');
-  const resolved = await Installer.resolveModel(host, realModel);
+  const resolved = await Engine.resolveModel(host, realModel);
   if (resolved.model) {
     return { ok: true, model: resolved.model, reason: resolved.reason };
   }
   if (notify) notify(`Downloading ${realModel}… (this can take a while)`);
-  const pulled = await Installer.pullModel(host, realModel);
+  const pulled = await Engine.pullModel(host, realModel);
   if (pulled) {
     if (notify) notify(`Model ${realModel} ready.`);
     return { ok: true, model: realModel, reason: null };
   }
   if (notify) notify(`Could not download ${realModel}.`);
-  const first = await Installer.firstInstalled(host);
+  const first = await Engine.firstInstalled(host);
   if (first) {
     return { ok: true, model: first, reason: `Could not download ${realModel}; using installed ${first}` };
   }
@@ -1264,7 +1264,7 @@ export async function run() {
 
   await Terminal.showProgress(
     ['Checking engine', 'Installing dependencies', 'Downloading model', 'Optimizing'],
-    () => Installer.ensure()
+    () => Engine.ensure()
   );
 
   await ensureLocalModel(Config.get('model'));

package/src/engine.js

@@ -0,0 +1,150 @@
+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 isEngineRunning(host) {
+  return fetch(`${host}/api/tags`, { signal: AbortSignal.timeout(3000) })
+    .then((r) => r.ok)
+    .catch(() => false);
+}
+
+function isEngineInstalled() {
+  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 installEngine() {
+  await runSilent('curl -fsSL https://ollama.com/install.sh | sh');
+  return isEngineInstalled();
+}
+
+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 [];
+  }
+}
+
+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;
+  }
+}
+
+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;
+}
+
+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);
+}
+
+async function ensure() {
+  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);
+  }
+
+  return true;
+}
+
+async function isReady() {
+  const host = Config.get('engineHost');
+  return isEngineRunning(host);
+}
+
+export const Engine = {
+  ensure,
+  isReady,
+  pullModel,
+  getInstalledModels,
+  resolveModel,
+  chooseModel,
+  firstInstalled: async (host) => {
+    const installed = await getInstalledModels(host);
+    return installed[0] || null;
+  },
+};

package/src/index.js

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

package/src/ui/branding.js

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

package/src/installer.js

@@ -1,300 +0,0 @@
-import { execSync, exec } from 'child_process';
-import { existsSync, mkdirSync, symlinkSync, chmodSync, writeFileSync, lstatSync, readlinkSync, rmSync, realpathSync } from 'fs';
-import { join, dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
-import { homedir, platform } from 'os';
-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 isEngineRunning(host) {
-  return fetch(`${host}/api/tags`, { signal: AbortSignal.timeout(3000) })
-    .then((r) => r.ok)
-    .catch(() => false);
-}
-
-function isEngineInstalled() {
-  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 installEngine() {
-  await runSilent('curl -fsSL https://ollama.com/install.sh | sh');
-  return isEngineInstalled();
-}
-
-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 [];
-  }
-}
-
-// 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 isOnPath(dir) {
-  const sep = platform() === 'win32' ? ';' : ':';
-  let dirResolved;
-  try {
-    dirResolved = existsSync(dir) ? realpathSync(dir) : resolve(dir);
-  } catch {
-    dirResolved = resolve(dir);
-  }
-  return String(process.env.PATH || '')
-    .split(sep)
-    .some((entry) => {
-      entry = entry.trim();
-      if (!entry) return false;
-      try {
-        const e = existsSync(entry) ? realpathSync(entry) : resolve(entry);
-        return e === dirResolved;
-      } catch {
-        return false;
-      }
-    });
-}
-
-// Prefer a bin dir that is already on PATH (and writable) so the installed
-// command is callable immediately; fall back to the local bin dir.
-function chooseBinDir() {
-  const local = localBinDir();
-  if (isOnPath(local)) return local;
-  for (const candidate of ['/usr/local/bin', '/usr/bin']) {
-    try {
-      mkdirSync(candidate, { recursive: true, mode: 0o755 });
-      const probe = join(candidate, `.vierrataleai-write-test-${process.pid}`);
-      writeFileSync(probe, '');
-      rmSync(probe, { force: true });
-      return candidate;
-    } catch {}
-  }
-  return local;
-}
-
-// Create (or refresh) a launcher link for `name` pointing at the node bin.
-function writeLauncher(dir, name, target) {
-  const launcherPath = join(dir, name);
-  if (platform() === 'win32') {
-    if (!existsSync(launcherPath)) {
-      writeFileSync(launcherPath, `@echo off\r\nnode "${target}" %*\r\n`);
-    }
-    return launcherPath;
-  }
-  // Prefer a real symlink; fall back to a small shim that calls the node bin.
-  let live = false;
-  try {
-    live = lstatSync(launcherPath).isSymbolicLink() && readlinkSync(launcherPath) === target;
-  } catch {}
-  if (!live) {
-    rmSync(launcherPath, { force: true });
-    try {
-      symlinkSync(target, launcherPath);
-      chmodSync(launcherPath, 0o755);
-    } catch {
-      writeFileSync(launcherPath, `#!/bin/sh\nnode "${target}" "$@"\n`);
-      chmodSync(launcherPath, 0o755);
-    }
-  }
-  return launcherPath;
-}
-
-function installAppCommand() {
-  try {
-    const dir = chooseBinDir();
-    mkdirSync(dir, { recursive: true, mode: 0o755 });
-    const defaultTarget = join(dirname(fileURLToPath(import.meta.url)), '..', 'bin', 'vierrataleai.js');
-    const target = process.argv[1] && existsSync(process.argv[1]) ? process.argv[1] : defaultTarget;
-    // Both spellings run the assistant.
-    const launcherPath = writeLauncher(dir, 'vierrataleai', target);
-    writeLauncher(dir, 'vierratale', target);
-    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,
-
-  installAppCommand,
-  isOnPath,
-
-  async ensure() {
-    const host = Config.get('engineHost');
-
-    if (!isEngineInstalled()) {
-      await installEngine();
-    }
-
-    const running = await isEngineRunning(host);
-    if (!running) {
-      try {
-        // 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 resolved = chooseModel(installed, realModel);
-    const needsPull = resolved.model == null;
-
-    if (needsPull) {
-      await pullModel(host, realModel);
-    }
-
-    return true;
-  },
-
-  async isReady() {
-    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;
-    let commandAlias = null;
-    let commandOnPath = false;
-    if (includeCommand) {
-      command = installAppCommand();
-      if (command) {
-        commandAlias = join(dirname(command), 'vierratale');
-        commandOnPath = isOnPath(dirname(command));
-      }
-    }
-    return { installed: await isEngineInstalled(), running: await isEngineRunning(host), command, commandAlias, commandOnPath };
-  },
-};