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

package/src/cmd/executor.js

@@ -0,0 +1,257 @@
+import { spawn } from 'child_process';
+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',
+]);
+
+const SHELL_META = /[;&|<>`$]|\$\{|\(\)|\|\||&&/;
+
+// Bins whose *path arguments* must stay inside the workspace. Reads like `ls`
+// are unrestricted on purpose; writes/deletes are contained.
+const PATH_CONTAINED_BINS = new Set(['mkdir', 'touch', 'cat', 'cp', 'mv', 'rm']);
+
+const MAX_CAPTURE = 200 * 1024;
+
+export function toolResult(overrides = {}) {
+  return {
+    success: false,
+    command: '',
+    stdout: '',
+    stderr: '',
+    exitCode: 0,
+    cwd: '',
+    timedOut: false,
+    ...overrides,
+  };
+}
+
+// Tokenizer for a single command line. Supports single/double quotes and
+// backslash escaping so arguments with spaces are handled without a shell.
+export function parseCommandLine(line) {
+  const argv = [];
+  let buf = null;
+  let quote = null;
+  const flush = () => {
+    if (buf !== null) {
+      argv.push(buf);
+      buf = null;
+    }
+  };
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (quote) {
+      if (c === quote) {
+        quote = null;
+      } else if (c === '\\' && quote === '"') {
+        if (i + 1 < line.length) buf += line[++i];
+        else buf += c;
+      } else {
+        buf += c;
+      }
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      if (buf === null) buf = '';
+      quote = c;
+      continue;
+    }
+    if (c === ' ' || c === '\t' || c === '\n') {
+      flush();
+      continue;
+    }
+    if (c === '\\') {
+      if (buf === null) buf = '';
+      if (i + 1 < line.length) buf += line[++i];
+      else buf += c;
+      continue;
+    }
+    if (buf === null) buf = '';
+    buf += c;
+  }
+  flush();
+  return argv;
+}
+
+export function isAllowedBin(bin) {
+  if (!/^[A-Za-z0-9._-]+$/.test(bin || '')) return false;
+  return ALLOWED_BINS.has(bin);
+}
+
+export class SafeCommandExecutor {
+  constructor({ cwd, timeoutMs } = {}) {
+    this.cwd = resolve(cwd || process.cwd());
+    this.timeoutMs = timeoutMs || 60000;
+  }
+
+  // Validate a command line and normalize it to an argv array, or throw with a
+  // human-readable reason.
+  validate(argv) {
+    if (!argv.length) {
+      throw new Error('Empty command — nothing to run.');
+    }
+    const bin = argv[0];
+    if (!isAllowedBin(bin)) {
+      throw new Error(`Command "${bin}" is not on the allowed list. Use one of: ${[...ALLOWED_BINS].join(', ')}.`);
+    }
+    const args = argv.slice(1);
+
+    for (const a of args) {
+      if (SHELL_META.test(a)) {
+        throw new Error(`Shell operators and variable syntax are not allowed in arguments: ${JSON.stringify(a)}`);
+      }
+    }
+
+    if ((bin === 'node' || bin === 'python' || bin === 'python3') && args.includes('-e') || args.includes('-c')) {
+      throw new Error(`Inline code (-e/-c) is disabled for ${bin}. Run a file inside the workspace instead (e.g. ${bin} script.js).`);
+    }
+    if (bin === 'git' && args.includes('clean')) {
+      throw new Error('`git clean` is disabled by the safety policy.');
+    }
+    if (bin === 'rm') {
+      this._checkRm(args);
+    }
+    if (PATH_CONTAINED_BINS.has(bin)) {
+      this._checkPaths(bin, args);
+    }
+    return argv;
+  }
+
+  _resolve(argvIdxArg) {
+    const base = resolve(this.cwd);
+    const target = resolve(base, argvIdxArg);
+    const outside = target !== base && !target.startsWith(base + sep);
+    return { base, target, outside };
+  }
+
+  _isHomeish(p) {
+    return p === '~' || p.startsWith('~/');
+  }
+
+  _checkRm(args) {
+    const targets = args.filter((a) => !a.startsWith('-'));
+    if (!targets.length) {
+      throw new Error('`rm` needs a target path.');
+    }
+    for (const t of targets) {
+      if (this._isHomeish(t)) {
+        throw new Error(`Refusing to remove ${t} — that path is outside the workspace.`);
+      }
+      if (t === '*' || t.includes('*')) {
+        throw new Error('Wildcards are not expanded (commands run without a shell). Give an explicit path for `rm`.');
+      }
+      const { base, target, outside } = this._resolve(t);
+      if (outside || target === base) {
+        throw new Error(`Refusing to remove ${t} — it resolves outside the workspace (${base}).`);
+      }
+    }
+  }
+
+  _checkPaths(bin, args) {
+    for (const a of args) {
+      if (a.startsWith('-') || a === '--') continue;
+      if (this._isHomeish(a)) {
+        throw new Error(`Refusing to use ${a} — home-directory paths are outside the workspace.`);
+      }
+      if (!this._looksLikePath(a)) continue;
+      const { base, target, outside } = this._resolve(a);
+      if (outside) {
+        throw new Error(`${bin}: refusing to touch ${a} — it resolves outside the workspace (${base}).`);
+      }
+    }
+  }
+
+  // Avoid treating plain words (e.g. a file NAME in `npm install foo`) as
+  // paths. Only flags, or tokens that contain a path separator or a known
+  // relative prefix, are checked.
+  _looksLikePath(a) {
+    if (a.includes('/') || a.includes('\\') || a.startsWith('.') || a === '..') return true;
+    if (/\.[A-Za-z0-9]{1,8}$/.test(a)) return true;
+    return false;
+  }
+
+  runCommand(commandLine) {
+    if (typeof commandLine !== 'string' || !commandLine.trim()) {
+      return Promise.resolve(toolResult({
+        success: false,
+        command: String(commandLine || ''),
+        stderr: 'Empty or invalid command.',
+        cwd: this.cwd,
+      }));
+    }
+    let argv;
+    try {
+      argv = this.validate(parseCommandLine(commandLine));
+    } catch (err) {
+      return Promise.resolve(toolResult({
+        success: false,
+        command: commandLine,
+        stderr: err.message,
+        cwd: this.cwd,
+      }));
+    }
+    return this.run(argv, commandLine);
+  }
+
+  run(argv, display = argv.join(' ')) {
+    return new Promise((resolvePromise) => {
+      let stdout = '';
+      let stderr = '';
+      let settled = false;
+      let timedOut = false;
+      let childExitCode = 1;
+
+      let child;
+      try {
+        child = spawn(argv[0], argv.slice(1), { cwd: this.cwd, shell: false });
+      } catch (err) {
+        return resolvePromise(toolResult({
+          success: false,
+          command: display,
+          stderr: err.message,
+          cwd: this.cwd,
+        }));
+      }
+
+      const finish = (code, dueToTimeout) => {
+        if (settled) return;
+        settled = true;
+        let out = stdout;
+        let errOut = stderr;
+        if (out.length > MAX_CAPTURE) out = out.slice(-MAX_CAPTURE) + '\n…[truncated]';
+        if (errOut.length > MAX_CAPTURE) errOut = errOut.slice(-MAX_CAPTURE) + '\n…[truncated]';
+        resolvePromise(toolResult({
+          success: code === 0 && !dueToTimeout,
+          command: display,
+          stdout: out,
+          stderr: errOut,
+          exitCode: dueToTimeout ? 124 : code,
+          cwd: this.cwd,
+          timedOut: !!dueToTimeout,
+        }));
+      };
+
+      const timer = setTimeout(() => {
+        timedOut = true;
+        try { child.kill('SIGKILL'); } catch {}
+      }, this.timeoutMs);
+
+      child.stdout.on('data', (d) => {
+        if (stdout.length < MAX_CAPTURE * 2) stdout += d.toString();
+      });
+      child.stderr.on('data', (d) => {
+        if (stderr.length < MAX_CAPTURE * 2) stderr += d.toString();
+      });
+      child.on('error', (err) => {
+        clearTimeout(timer);
+        stderr = err.message;
+        finish(127, false);
+      });
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        finish(timedOut ? 124 : (code == null ? 1 : code), timedOut);
+      });
+    });
+  }
+}

package/src/cmd/tools.js

@@ -0,0 +1,153 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { resolve, sep } from 'path';
+import { toolResult, SafeCommandExecutor } from './executor.js';
+import { Downloader } from '../utils/downloader.js';
+import { Config } from '../config.js';
+
+// Resolve a path relative to the workspace and require it to stay inside.
+// Throws if the path escapes the workspace (or hits the workspace root for
+// destructive operations).
+export function resolveWithin(cwd, p, { allowRoot = false } = {}) {
+  const base = resolve(cwd);
+  const target = resolve(base, String(p || ''));
+  const rootOrEscape = target === base || !target.startsWith(base + sep);
+  if (target !== base && !target.startsWith(base + sep)) {
+    throw new Error(`Refusing to access a path outside the workspace: ${p}`);
+  }
+  if (!allowRoot && target === base && String(p || '') !== '.' && String(p || '') !== '') {
+    throw new Error('Refusing to use the workspace root as a file path.');
+  }
+  return target;
+}
+
+function ok({ command, stdout = '', cwd }) {
+  return toolResult({ success: true, command, stdout, stderr: '', exitCode: 0, cwd });
+}
+
+function fail({ command, stderr, exitCode = 1, cwd }) {
+  return toolResult({ success: false, command, stdout: '', stderr, exitCode, cwd });
+}
+
+export function createFile(cwd, path, content = '') {
+  if (!path || typeof path !== 'string' || path.trim() === '') {
+    return fail({ command: 'create_file', stderr: 'Missing file path.', cwd });
+  }
+  try {
+    const target = resolveWithin(cwd, path);
+    const dir = resolve(target, '..');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(target, String(content ?? ''));
+    return ok({ command: `create_file("${path}")`, stdout: `created ${path} (${String(content ?? '').length} bytes)`, cwd });
+  } catch (err) {
+    return fail({ command: `create_file("${path}")`, stderr: err.message, cwd });
+  }
+}
+
+export function createDirectory(cwd, path) {
+  if (!path || typeof path !== 'string' || path.trim() === '') {
+    return fail({ command: 'create_directory', stderr: 'Missing directory path.', cwd });
+  }
+  try {
+    const target = resolveWithin(cwd, path, { allowRoot: true });
+    if (target === resolve(cwd)) {
+      return ok({ command: `create_directory("${path}")`, stdout: `already at workspace root`, cwd });
+    }
+    mkdirSync(target, { recursive: true });
+    return ok({ command: `create_directory("${path}")`, stdout: `created directory ${path}`, cwd });
+  } catch (err) {
+    return fail({ command: `create_directory("${path}")`, stderr: err.message, cwd });
+  }
+}
+
+export function readFile(cwd, path) {
+  if (!path || typeof path !== 'string' || path.trim() === '') {
+    return fail({ command: 'read_file', stderr: 'Missing file path.', cwd });
+  }
+  try {
+    const target = resolveWithin(cwd, path);
+    const content = readFileSync(target, 'utf-8');
+    return ok({ command: `read_file("${path}")`, stdout: content, cwd });
+  } catch (err) {
+    return fail({ command: `read_file("${path}")`, stderr: err.message, cwd });
+  }
+}
+
+export function listDirectory(cwd, path = '.') {
+  try {
+    const target = resolveWithin(cwd, path, { allowRoot: true });
+    const entries = readdirSync(target, { withFileTypes: true });
+    const list = entries
+      .map((e) => (e.isDirectory() ? `${e.name}/` : e.name))
+      .sort()
+      .join('\n');
+    return ok({ command: `list_directory("${path}")`, stdout: list || '(empty)', cwd });
+  } catch (err) {
+    return fail({ command: `list_directory("${path}")`, stderr: err.message, cwd });
+  }
+}
+
+export function deleteFile(cwd, path) {
+  if (!path || typeof path !== 'string' || path.trim() === '') {
+    return fail({ command: 'delete_file', stderr: 'Missing path.', cwd });
+  }
+  try {
+    const target = resolveWithin(cwd, path);
+    if (resolve(cwd) === target) {
+      return fail({ command: `delete_file("${path}")`, stderr: 'Refusing to delete the workspace root.', cwd });
+    }
+    if (!existsSync(target)) {
+      return fail({ command: `delete_file("${path}")`, stderr: `No such file or directory: ${path}`, exitCode: 1, cwd });
+    }
+    rmSync(target, { recursive: true, force: true });
+    return ok({ command: `delete_file("${path}")`, stdout: `removed ${path}`, cwd });
+  } catch (err) {
+    return fail({ command: `delete_file("${path}")`, stderr: err.message, cwd });
+  }
+}
+
+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 });
+  }
+  const targetDir = dir ? resolveWithin(cwd, dir, { allowRoot: true }) : Config.get('downloadDir');
+  try {
+    const res = await Downloader.download(url.trim(), { dir: targetDir });
+    const kind = res.kind || 'file';
+    const note = res.extracted ? '\n(contents extracted into that folder)' : '';
+    return ok({
+      command: `download_url("${url}")`,
+      stdout: `downloaded ${kind} → ${res.path}${note}`,
+      cwd,
+    });
+  } catch (err) {
+    return fail({ command: 'download_url', stderr: err.message, cwd });
+  }
+}
+
+// Structured tool registry shared with the agent loop.
+export const TOOL_EXECUTORS = {
+  run_command: (executor, params) => executor.runCommand(params.command),
+  create_file: (executor, params) => createFile(executor.cwd, params.path, params.content),
+  create_directory: (executor, params) => createDirectory(executor.cwd, params.path),
+  read_file: (executor, params) => readFile(executor.cwd, params.path),
+  list_directory: (executor, params) => listDirectory(executor.cwd, params.path || '.'),
+  delete_file: (executor, params) => deleteFile(executor.cwd, params.path),
+  download_url: (executor, params) => downloadUrl(executor.cwd, params.url, params.dir),
+};
+
+export function makeExecutor({ cwd, timeoutMs } = {}) {
+  return new SafeCommandExecutor({ cwd, timeoutMs });
+}
+
+export function dispatchTool(executor, call) {
+  const fn = TOOL_EXECUTORS[call && call.name];
+  if (!fn) {
+    return toolResult({
+      success: false,
+      command: `${call && call.name ? call.name : '(unknown tool)'}`,
+      stderr: `Unknown tool ${call && call.name}.`,
+      cwd: executor.cwd,
+    });
+  }
+  return fn(executor, call.params || {});
+}

package/src/config.js

@@ -1,23 +1,34 @@
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { Catalog } from './catalog.js';
 
-const CONFIG_DIR = join(homedir(), '.config', 'vierrataleai');
-const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+function configPaths() {
+  const dir = process.env.VIERRATALE_CONFIG_DIR
+    ? join(process.env.VIERRATALE_CONFIG_DIR)
+    : join(homedir(), '.config', 'vierrataleai');
+  return { dir, file: join(dir, 'config.json') };
+}
 
 const DEFAULTS = {
   provider: 'auto',
-  model: 'vierratale-fast',
-  ollamaHost: 'http://127.0.0.1:11434',
-  numCtx: 8192,
+  model: 'VRTL-2.fast',
+  engineHost: 'http://127.0.0.1:11434',
+  numCtx: 2048,
   temperature: 0.7,
   maxTokens: 4096,
+  keepAlive: '5m',
+  numThreads: 8,
+  commandTimeoutMs: 60000,
+  planTimeoutMs: 45000,
+  downloadDir: join(homedir(), 'Downloads'),
 };
 
 function loadConfigFile() {
   try {
-    if (existsSync(CONFIG_FILE)) {
-      const raw = readFileSync(CONFIG_FILE, 'utf-8');
+    const { file } = configPaths();
+    if (existsSync(file)) {
+      const raw = readFileSync(file, 'utf-8');
       return JSON.parse(raw);
     }
   } catch {}
@@ -33,15 +44,25 @@ export const Config = {
 
   load() {
     const file = loadConfigFile();
+    // Migrate legacy 'cortexHost' key to 'engineHost' if present.
+    const engineHost = file.engineHost || file.cortexHost || DEFAULTS.engineHost;
     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))),
+      engineHost: getEnv('VIERRATALE_ENGINE_HOST', engineHost),
+      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))),
+      keepAlive: getEnv('VIERRATALE_KEEP_ALIVE', file.keepAlive ?? DEFAULTS.keepAlive),
+      numThreads: parseInt(getEnv('VIERRATALE_NUM_THREADS', String(file.numThreads ?? DEFAULTS.numThreads))),
       openaiApiKey: getEnv('OPENAI_API_KEY', file.openaiApiKey || ''),
       anthropicApiKey: getEnv('ANTHROPIC_API_KEY', file.anthropicApiKey || ''),
+      geminiApiKey: getEnv('GEMINI_API_KEY', file.geminiApiKey || ''),
+      systemPrompt: file.systemPrompt || '',
+      providerModels: file.providerModels || {},
+      downloadDir: getEnv('VIERRATALE_DOWNLOAD_DIR', file.downloadDir ?? DEFAULTS.downloadDir),
+      commandTimeoutMs: parseInt(getEnv('VIERRATALE_COMMAND_TIMEOUT_MS', String(file.commandTimeoutMs ?? DEFAULTS.commandTimeoutMs))),
+      planTimeoutMs: parseInt(getEnv('VIERRATALE_PLAN_TIMEOUT_MS', String(file.planTimeoutMs ?? DEFAULTS.planTimeoutMs))),
     };
     return this._config;
   },
@@ -56,17 +77,35 @@ export const Config = {
     return { ...this._config };
   },
 
+  getProviderModel(provider) {
+    if (!this._config) this.load();
+    return this._config.providerModels?.[provider] || null;
+  },
+
+  setProviderModel(provider, model) {
+    if (!this._config) this.load();
+    this._config.providerModels = this._config.providerModels || {};
+    this._config.providerModels[provider] = model;
+    this.save();
+  },
+
+  getEffectiveModel(provider) {
+    const raw = this.getProviderModel(provider) || this.get('model');
+    return Catalog.normalize(raw);
+  },
+
   save(overrides = {}) {
-    if (!existsSync(CONFIG_DIR)) {
-      mkdirSync(CONFIG_DIR, { recursive: true });
+    const { dir, file } = configPaths();
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
     }
     const current = this._config || DEFAULTS;
     const merged = { ...current, ...overrides };
-    writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+    writeFileSync(file, JSON.stringify(merged, null, 2));
     this._config = merged;
   },
 
   getConfigDir() {
-    return CONFIG_DIR;
+    return configPaths().dir;
   },
 };

package/src/index.js

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