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

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,9 +1,10 @@
 #!/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.
@@ -12,6 +13,7 @@ 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';
+import { dirname } from 'path';
 
 const C = Branding.colors;
 
@@ -23,6 +25,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,6 +57,7 @@ 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();
 
@@ -60,11 +65,18 @@ async function main() {
     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.');
+      Terminal.printInfo('Could not create a global command; run it via the bin script.');
     } else {
-      Terminal.printSuccess(`Engine + model installed; "vierrataleai" command available at ${result.command}`);
+      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.`);
+      }
     }
     console.log();
+  } else if (!quick) {
+    // Auto-detect: install anything that's missing (engine, model) before starting.
+    await fakeProgress(READY_STEPS, Installer.ensure());
+    console.log();
   }
 
   return run();

package/package.json

@@ -1,31 +1,30 @@
 {
   "name": "@vierratale/ai",
-  "version": "0.1.0-beta.12",
+  "version": "0.1.0-beta.13",
   "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",
+    "README.md"
+  ],
+  "keywords": [
+    "ai",
+    "chatbot",
+    "terminal",
+    "assistant",
+    "llm"
+  ]
+}

package/src/cli.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

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/installer.js

@@ -1,6 +1,7 @@
 import { execSync, exec } from 'child_process';
-import { existsSync, mkdirSync, symlinkSync, chmodSync, writeFileSync } from 'fs';
-import { join } from 'path';
+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';
@@ -112,19 +113,61 @@ function localBinDir() {
   return '/usr/local/bin';
 }
 
-function installAppCommand() {
+function isOnPath(dir) {
+  const sep = platform() === 'win32' ? ';' : ':';
+  let dirResolved;
   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;
+    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`);
     }
-    // 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');
+    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);
@@ -132,6 +175,19 @@ function installAppCommand() {
       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;
@@ -158,6 +214,9 @@ export const Installer = {
 
   chooseModel,
 
+  installAppCommand,
+  isOnPath,
+
   async ensure() {
     const host = Config.get('engineHost');
 
@@ -227,7 +286,15 @@ export const Installer = {
     }
 
     let command = null;
-    if (includeCommand) command = installAppCommand();
-    return { installed: await isEngineInstalled(), running: await isEngineRunning(host), command };
+    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 };
   },
 };

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;
+}