@vierratale/ai 0.1.0-beta.8 → 0.1.0-beta.9

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,131 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { resolve, sep } from 'path';
+import { toolResult, SafeCommandExecutor } from './executor.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 });
+  }
+}
+
+// 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),
+};
+
+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,24 +1,33 @@
 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',
+  model: 'VRTL-2.fast',
   engineHost: 'http://127.0.0.1:11434',
   numCtx: 2048,
   temperature: 0.7,
   maxTokens: 4096,
   keepAlive: '5m',
+  numThreads: 6,
+  commandTimeoutMs: 60000,
+  planTimeoutMs: 45000,
 };
 
 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 {}
@@ -44,11 +53,14 @@ export const Config = {
       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 || {},
+      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;
   },
@@ -76,20 +88,22 @@ export const Config = {
   },
 
   getEffectiveModel(provider) {
-    return this.getProviderModel(provider) || this.get('model');
+    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

@@ -4,3 +4,4 @@ export { Installer } from './installer.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';

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';
 
@@ -54,6 +56,88 @@ 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);
@@ -63,6 +147,17 @@ export const Installer = {
     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');
 
@@ -89,7 +184,8 @@ export const Installer = {
 
     const realModel = Catalog.getRealModel(Config.get('model'));
     const installed = await getInstalledModels(host);
-    const needsPull = !installed.includes(realModel);
+    const resolved = chooseModel(installed, realModel);
+    const needsPull = resolved.model == null;
 
     if (needsPull) {
       await pullModel(host, realModel);
@@ -102,4 +198,36 @@ export const Installer = {
     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.