@vierratale/ai 0.1.0-beta.12 → 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/README.md

@@ -4,11 +4,20 @@ Intelligent terminal assistant that runs AI models locally and in the cloud.
 
 ## Install
 
+Install requirements and run from source:
+
 ```bash
-# From npm
-npm install -g @vierratale/ai
+git clone <your-repo-url>/vierratale-ai.git
+cd vierratale-ai
+
+./install.sh --node   # installs requirements + links the commands
+vierratale             # start chatting
+```
 
-# Or run directly
+Or run directly from npm:
+
+```bash
+npm install -g @vierratale/ai
 npx @vierratale/ai
 ```
 

package/bin/vierrataleai.js

@@ -1,17 +1,17 @@
 #!/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.
+// Running without flags starts the assistant and auto-detects dependencies:
+// if the AI engine (ollama) or the model is missing, they are installed first.
+// Running with --install (or --setup / install) additionally creates a global
+// "vierrataleai" / "vierratale" 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';
-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';
 
 const C = Branding.colors;
 
@@ -23,6 +23,8 @@ const INSTALL_STEPS = [
   'Optimizing for this device',
 ];
 
+const READY_STEPS = ['Checking engine', 'Installing dependencies', 'Downloading model', 'Optimizing'];
+
 function delay(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
@@ -53,17 +55,17 @@ async function fakeProgress(steps, work) {
 async function main() {
   const args = process.argv.slice(2);
   const doInstall = args.includes('--install') || args.includes('--setup') || args.includes('install');
+  const quick = args.includes('--version') || args.includes('-v') || args.includes('--help') || args.includes('-h');
 
   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}`);
-    }
+    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, Engine.ensure());
     console.log();
   }
 

package/package.json

@@ -1,31 +1,31 @@
 {
   "name": "@vierratale/ai",
-  "version": "0.1.0-beta.12",
+  "version": "0.1.0-beta.14",
   "description": "VierrataleAI - Intelligent terminal assistant",
   "type": "module",
-  "files": [
-    "bin/",
-    "scripts/",
-    "src/",
-    "README.md"
-  ],
-  "bin": {
-    "vierrataleai": "./bin/vierrataleai.js"
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
   },
-  "main": "./src/index.js",
-  "exports": {
-    ".": "./src/index.js"
+  "bin": {
+    "vierrataleai": "./bin/vierrataleai.js",
+    "vierratale": "./bin/vierrataleai.js"
   },
   "scripts": {
-    "start": "node bin/vierrataleai.js",
-    "test": "node --test \"test/*.test.js\"",
     "postinstall": "node scripts/postinstall.js"
   },
-  "keywords": ["ai", "chatbot", "terminal", "assistant", "llm"],
-  "author": "Vierratale",
-  "license": "MIT",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {}
-}
+  "files": [
+    "bin",
+    "src",
+    "scripts",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "ai",
+    "chatbot",
+    "terminal",
+    "assistant",
+    "llm"
+  ]
+}

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';
@@ -47,6 +47,8 @@ Options:
   --version, -v           Show version
   --help, -h              Show this help
 
+Missing dependencies (engine + model) are installed automatically on start.
+
 Commands (in chat):
   /help                   Show commands
   /model [name]           Switch model
@@ -809,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);
         }
       }
@@ -1112,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}` };
   }
@@ -1262,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/cmd/agent.js

@@ -3,7 +3,8 @@ import { readFileSync } from 'node:fs';
 import { join } from 'path';
 import { Config } from '../config.js';
 import { logger } from '../utils/logger.js';
-import { makeExecutor, dispatchTool, TOOL_EXECUTORS } from './tools.js';
+import { renderFileTree } from '../utils/filetree.js';
+import { makeExecutor, dispatchTool, TOOL_EXECUTORS, pickPackageManager } from './tools.js';
 
 const MAX_PLANNING_ROUNDS = 3;
 const MAX_STEPS = 8;
@@ -25,12 +26,13 @@ Reply with EXACTLY ONE JSON array of the tool calls needed to do the job, in ord
 {"name":"todo_clear"}
 
 Rules:
-- run_command runs WITHOUT a shell. Allowed commands: mkdir touch ls pwd cat cp mv rm npm npx node python python3 git echo printf.
+- run_command runs WITHOUT a shell. Allowed commands: mkdir touch ls pwd cat cp mv rm npm npx node python python3 git echo printf apt apt-get pkg.
 - run_command supports arguments with spaces (quote them). No shell operators (&& | > ; etc.), no wildcards for rm, no inline -e/-c code for node/python, no paths outside the workspace.
 - To create a file containing code or text, ALWAYS use create_file (never echo/cat > …). Pass the full content in "content".
 - Prefer create_file over redirecting output.
 - If you need to create a folder first, plan create_directory before create_file inside it.
 - To download a file, web asset, archive or folder listing from the web, use download_url with the full URL. dir is optional (defaults to ~/Downloads).
+- To install a system package the user asked for, use run_command with pkg (Termux/Android) or apt/apt-get (Linux), e.g. {"name":"run_command","command":"pkg install -y curl wget"}. The -y/--yes confirm flag is added automatically — never use && or sudo.
 - For multi-step work, track your progress with todo_add/todo_list/todo_update (e.g. todo_add for each remaining subtask, todo_update to mark steps done).
 - Code you create must be runnable. For Python servers bind to 127.0.0.1, read PORT from the environment (default 8000), and fall back to a free port (port 0) when the default is taken. HTML/CSS/JS must be self-contained and reference each other by relative filename.
 - If NO tools are needed, reply exactly: NONE
@@ -207,6 +209,24 @@ export function heuristicPlan(requestText) {
     return [{ name: 'run_command', params: { command: tail } }];
   }
 
+  // System package installs: explicit "pkg/apt install …" and generic
+  // "install <pkg>" requests ("pasang curl", "install wget").
+  const pkgInstall = /\b(pkg|apt-get|apt)\s+(install|i|add)\s+(.+)$/i.exec(text);
+  if (pkgInstall) {
+    const pkgs = pkgInstall[3].trim().split(/\s+/).slice(0, 8).filter((p) => /^[a-z0-9][a-z0-9.+_~-]*$/i.test(p));
+    if (pkgs.length) return [{ name: 'run_command', params: { command: `${pkgInstall[1]} install ${pkgs.join(' ')}` } }];
+  }
+  const INSTALL_BLOCKED = new Set(['project', 'proyek', 'folder', 'direktori', 'file', 'berkas', 'code', 'kode', 'dependencies', 'dependensi', 'app', 'aplikasi', 'gui', 'the', 'a', 'an', 'for', 'to', 'in', 'on', 'from', 'with', 'and', 'dan', 'lalu', 'semua', 'ini', 'itu', 'now', 'please', 'tolong']);
+  const genericInstall = /\b(install|pasang|installkan|menginstall|menginstal|set\s*up|setup)\b/i.exec(text);
+  const devInstallSpeak = /node modules|modules|dependenc\w*|package\.json|requirements(\.txt)?|virtualenv|pip\b|cargo\b|go get\b/gi;
+  if (genericInstall && !/\b(npm|yarn|pnpm|npx|bun|pip|pip3|uv|conda|apt|pkg)\b/i.test(text) && !devInstallSpeak.test(text)) {
+    const target = text.match(/\b(install|pasang|installkan|menginstall|menginstal|set\s*up|setup)\b\s+(?:(the|a|an|package|paket|tool|alat|program|utility|latest)\s+)?([a-z0-9][a-z0-9.+_~-]{1,63})\b/i);
+    if (target && !INSTALL_BLOCKED.has(target[3].toLowerCase())) {
+      const manager = pickPackageManager();
+      return [{ name: 'run_command', params: { command: `${manager} install ${target[3]}` } }];
+    }
+  }
+
   m = /\b(jalankan|run|execute|exec|kerjakan)\b\s+(node|python3?)\b\s*([A-Za-z0-9_.\/-]+(?:\.[A-Za-z0-9]+)?)?/i.exec(text);
   if (m) {
     const cmd = `${m[2]} ${m[3] || ''}`.trim();
@@ -1787,6 +1807,12 @@ export async function runWithTools({
   }
 
   if (results.length) {
+    const madeFiles = results.some((r) => (r.name === 'create_file' || r.name === 'create_directory') && r.result.success);
+    if (madeFiles) {
+      const treeText = renderFileTree(cwd || process.cwd()).join('\n');
+      logger.log('TREE', treeText.slice(0, 2500));
+      if (chatUI) chatUI.notify(treeText);
+    }
     if (chatUI) {
       chatUI.setStatus('');
       chatUI.setThinking(true);

package/src/cmd/executor.js

@@ -4,8 +4,16 @@ import { dirname, resolve, sep } from 'path';
 const ALLOWED_BINS = new Set([
   'mkdir', 'touch', 'ls', 'pwd', 'cat', 'cp', 'mv', 'rm',
   'npm', 'npx', 'node', 'python', 'python3', 'git', 'echo', 'printf',
+  'apt', 'apt-get', 'pkg',
 ]);
 
+// Package-manager commands never run interactively (no TTY), so auto-append a
+// confirm flag to mutating subcommands instead of letting apt/pkg block on a
+// prompt. pkg is the Termux/Android wrapper, apt/apt-get the Linux ones.
+const INSTALL_MANAGERS = new Set(['apt', 'apt-get', 'pkg']);
+const INSTALL_SUBCOMMANDS = new Set(['install', 'upgrade', 'remove', 'autoremove', 'purge']);
+const INSTALL_CONFIRM_FLAGS = /^-y$|^--yes$|^-dy$|^--assume-yes$/i;
+
 const SHELL_META = /[;&|<>`$]|\$\{|\(\)|\|\||&&/;
 
 // Bins whose *path arguments* must stay inside the workspace. Reads like `ls`
@@ -115,6 +123,12 @@ export class SafeCommandExecutor {
     if (PATH_CONTAINED_BINS.has(bin)) {
       this._checkPaths(bin, args);
     }
+    if (INSTALL_MANAGERS.has(bin)) {
+      const subIdx = argv.findIndex((a) => INSTALL_SUBCOMMANDS.has(a));
+      if (subIdx !== -1 && !argv.some((a) => INSTALL_CONFIRM_FLAGS.test(a))) {
+        argv.splice(subIdx + 1, 0, '-y');
+      }
+    }
     return argv;
   }
 

package/src/cmd/tools.js

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
-import { resolve, sep } from 'path';
+import { accessSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, X_OK } from 'fs';
+import { delimiter, join, resolve, sep } from 'path';
 import { toolResult, SafeCommandExecutor } from './executor.js';
 import { Downloader } from '../utils/downloader.js';
 import { Config } from '../config.js';
@@ -106,6 +106,23 @@ export function deleteFile(cwd, path) {
   }
 }
 
+// Pick the package manager to use for installing system packages: pkg is the
+// Termux/Android wrapper, everywhere else apt/apt-get.
+export function pickPackageManager() {
+  const dirs = (process.env.PATH || '').split(delimiter).filter(Boolean);
+  const available = (bin) => dirs.some((dir) => {
+    try {
+      accessSync(join(dir, bin), X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  if (available('pkg')) return 'pkg';
+  if (available('apt-get')) return 'apt-get';
+  return 'apt';
+}
+
 export async function downloadUrl(cwd, url, dir) {
   if (!url || typeof url !== 'string' || !/^https?:\/\//i.test(url.trim())) {
     return fail({ command: 'download_url', stderr: 'Invalid URL. Provide a valid http(s) address.', cwd });

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/utils/filetree.js

@@ -0,0 +1,44 @@
+import { readdirSync } from 'fs';
+import { join } from 'path';
+
+// Directories that are never worth expanding in a workspace tree.
+const SKIP_DIRS = new Set(['.git', 'node_modules', '__pycache__', '.cache']);
+
+// Render a compact box-drawing tree of a directory. Returns an array of lines
+// starting with "." for the workspace root. Bounded so huge folders (node_modules,
+// caches, download dirs) can never flood a chat with thousands of lines.
+export function renderFileTree(rootDir, { maxDepth = 4, maxEntries = 150 } = {}) {
+  const root = rootDir || process.cwd();
+  const lines = ['.'];
+  let entries = 0;
+
+  const walk = (dir, depth, prefix) => {
+    if (entries >= maxEntries) return;
+    let names;
+    try {
+      names = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    names = names
+      .filter((e) => !SKIP_DIRS.has(e.name))
+      .sort((a, b) => {
+        if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
+    for (let i = 0; i < names.length; i++) {
+      if (entries >= maxEntries) return;
+      const e = names[i];
+      const last = i === names.length - 1;
+      lines.push(`${prefix}${last ? '└── ' : '├── '}${e.name}`);
+      entries++;
+      if (e.isDirectory() && depth < maxDepth) {
+        walk(join(dir, e.name), depth + 1, `${prefix}${last ? '    ' : '│   '}`);
+      }
+    }
+  };
+
+  walk(root, 0, '');
+  if (entries >= maxEntries) lines.push(`… showing first ${entries} entries`);
+  return lines;
+}

package/src/installer.js

@@ -1,233 +0,0 @@
-import { execSync, exec } from 'child_process';
-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';
-
-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 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('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;
-    if (includeCommand) command = installAppCommand();
-    return { installed: await isEngineInstalled(), running: await isEngineRunning(host), command };
-  },
-};