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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vierratale/ai",
-  "version": "0.1.0-beta.11",
+  "version": "0.1.0-beta.12",
   "description": "VierrataleAI - Intelligent terminal assistant",
   "type": "module",
   "files": [

package/src/cli.js

@@ -18,6 +18,7 @@ import { Session } from './session.js';
 import { ChatUI, FrameThrottle } from './ui/chatbox.js';
 import { logger } from './utils/logger.js';
 import { runWithTools, TOOL_RESULTS_PROMPT, looksLikeOperationRequest } from './cmd/agent.js';
+import { loadTodos, addTodo, updateTodo, clearTodos, saveTodos, formatTodos, todosFile } from './cmd/todos.js';
 
 function parseArgs(args) {
   const parsed = { provider: null, model: null, clear: false, version: false, help: false, install: false };
@@ -54,6 +55,7 @@ Commands (in chat):
   /search <query>         Search the web and summarize with AI
   /fetch <url>            Open a link and summarize its content
   /download <url>         Download a file, folder listing or archive
+  /todos                  List the todo list (add <text> | done/undone <n> | clear)
   /log [n|path]           Show the last n log entries (default 30), or the log file path
   /clear                  Clear screen
   /new                    Start a new empty session (keeps old ones)
@@ -79,6 +81,7 @@ export const SLASH_COMMANDS = [
   { name: 'fetch', args: '<url>', desc: 'Open a link and summarize' },
   { name: 'download', args: '<url>', desc: 'Download a file / folder / archive' },
   { name: 'system', desc: 'Show or set the system prompt' },
+  { name: 'todos', args: '[add <text> | done <n> | undone <n> | clear]', desc: 'Manage the todo list' },
   { name: 'sessions', desc: 'List saved sessions' },
   { name: 'session', args: 'new | open | delete | backup | restore', desc: 'Manage sessions' },
   { name: 'log', args: '[n | path]', desc: 'Show recent log entries' },
@@ -656,7 +659,7 @@ async function chat(provider, systemPrompt) {
     if (cmd === '/help') {
       chatUI.clearNotices();
       chatUI.notify(
-        `Commands:\n  /search <query> · /fetch <url> · /model [name] · /provider [name]\n  /models · /log [n|path] · /new · /sessions · /session new|open|delete|backup|restore\n  /clear · /help · /quit`
+        `Commands:\n  /search <query> · /fetch <url> · /model [name] · /provider [name]\n  /models · /todos · /log [n|path] · /new · /sessions · /session new|open|delete|backup|restore\n  /clear · /help · /quit`
       );
       chatUI.render(messages);
       continue;
@@ -977,6 +980,11 @@ async function chat(provider, systemPrompt) {
       continue;
     }
 
+    if (cmd === '/todos' || cmd.startsWith('/todos ')) {
+      handleTodosCommand(trimmed, chatUI, messages, process.cwd());
+      continue;
+    }
+
     const intent = detectIntent(trimmed);
     if (intent.type === 'self') {
       const model = Config.getEffectiveModel(provider.name);
@@ -1125,6 +1133,49 @@ async function ensureRawLocalModel(realModel, notify) {
 export { looksLikeFileRequest, requestedFileName, extractFallbackFile, storyFileName, responseWantsFile, responseIsSoloCode, languageFileName, fallbackHasUsefulCode, validateWrittenCode, looksLikeJunkCode, warnIfJunkCode, writeFilesFromResponse }; 
 // Command/tool layer: asks the model to plan filesystem/shell operations,
 // executes them with the sandboxed executor, then streams the final answer.
+function handleTodosCommand(trimmed, chatUI, messages, cwd) {
+  chatUI.clearNotices();
+  const rest = trimmed.slice('/todos'.length).trim();
+  let out;
+  if (!rest) {
+    out = `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+  } else if (/^add\s+/i.test(rest)) {
+    const err = addTodo(cwd, rest.replace(/^add\s+/i, '').trim());
+    out = err && err.error ? err.error : `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+  } else if (/^done\s+\d+$/i.test(rest)) {
+    const err = updateTodo(cwd, parseInt(rest.replace(/^done\s+/i, ''), 10), { done: true });
+    out = err && err.error ? err.error : `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+  } else if (/^undone\s+\d+$/i.test(rest)) {
+    const err = updateTodo(cwd, parseInt(rest.replace(/^undone\s+/i, ''), 10), { done: false });
+    out = err && err.error ? err.error : `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+  } else if (/^remove\s+\d+$/i.test(rest)) {
+    const n = parseInt(rest.replace(/^remove\s+/i, ''), 10);
+    const todos = loadTodos(cwd);
+    if (!Number.isInteger(n - 1) || n - 1 < 0 || n - 1 >= todos.length) {
+      out = `No todo #${n}.`;
+    } else {
+      const next = todos.filter((_, i) => i !== n - 1);
+      saveTodos(cwd, next);
+      out = `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+    }
+  } else if (/^clear$/i.test(rest)) {
+    clearTodos(cwd);
+    out = `Todos cleared (${todosFile(cwd)}). (no todos yet)`;
+  } else if (/^\d+$/.test(rest)) {
+    const n = parseInt(rest, 10);
+    const todos = loadTodos(cwd);
+    const err = (Number.isInteger(n - 1) && n - 1 >= 0 && n - 1 < todos.length)
+      ? updateTodo(cwd, n, { done: !todos[n - 1].done })
+      : { error: `No todo #${n}.` };
+    out = err && err.error ? err.error : `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+  } else {
+    out = 'Usage: /todos [add <text> | done <n> | undone <n> | remove <n> | <n> (toggle) | clear]';
+  }
+  chatUI.notify(out);
+  logger.log('CMD', `todos: ${rest || '(list)'}`);
+  chatUI.render(messages);
+}
+
 async function answerWithTools(messages, provider, requestText, systemPrompt, confirm, chatUI, cwd, timeoutMs) {
   let results = [];
   try {

package/src/cmd/agent.js

@@ -19,6 +19,10 @@ Reply with EXACTLY ONE JSON array of the tool calls needed to do the job, in ord
 {"name":"list_directory","path":"."}
 {"name":"delete_file","path":"old.txt"}
 {"name":"download_url","url":"https://example.com/file.zip","dir":"downloads"}
+{"name":"todo_add","text":"install dependencies"}
+{"name":"todo_list"}
+{"name":"todo_update","index":1,"done":true}
+{"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.
@@ -27,6 +31,7 @@ Rules:
 - 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).
+- 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
 - Output the JSON array only — no prose, no markdown fences unless the array is inside them.`;
@@ -37,6 +42,20 @@ ${resultsJson}
 
 Give the user a short, natural reply (in the user's own language) telling them what happened. Keep the whole reply under 40 words. Do NOT tell them to run the commands yourself. If they asked for a file containing code and files were created with content, you may also emit FILE: blocks if more files are still required.`;
 
+// Auto error fixing: shown to the model when a tool call fails so it can emit
+// a corrected plan instead of giving up. Bounded by MAX_AUTO_FIXES per run.
+const MAX_AUTO_FIXES = 3;
+
+const TOOL_FIX_PROMPT = (call, result) => `A tool call made while working in the workspace FAILED. Fix the problem so the original request can complete.
+
+Failed tool call:
+${JSON.stringify(call, null, 2)}
+
+Failure:
+${JSON.stringify({ success: false, exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr }, null, 2)}
+
+Emit a NEW tool plan (a JSON array of tool calls) that corrects the failure — for example re-create the file with the error fixed, run a command to repair it, or download/read what is missing. If your previous plan skipped a required step (like creating a parent folder), include it. Use todo tools to track remaining subtasks if useful. Reply with exactly one JSON array, or the single word NONE if no tool call can fix this.`;
+
 // ---------------------------------------------------------------------------
 // Request detection
 // ---------------------------------------------------------------------------
@@ -84,6 +103,18 @@ export function normalizeToolCall(raw) {
   } else if (name === 'download_url') {
     if (typeof raw.url !== 'string' || raw.url.trim() === '') return null;
     params = { url: raw.url, dir: typeof raw.dir === 'string' && raw.dir.trim() ? raw.dir.trim() : undefined };
+  } else if (name === 'todo_add') {
+    if (typeof raw.text !== 'string' || raw.text.trim() === '') return null;
+    params = { text: raw.text };
+  } else if (name === 'todo_update') {
+    if (!Number.isInteger(raw.index) && !/^\d+$/.test(String(raw.index ?? ''))) return null;
+    params = {
+      index: Number(raw.index),
+      done: typeof raw.done === 'boolean' ? raw.done : undefined,
+      text: typeof raw.text === 'string' && raw.text.trim() ? raw.text : undefined,
+    };
+  } else if (name === 'todo_list' || name === 'todo_clear') {
+    params = {};
   } else {
     return null;
   }
@@ -1631,6 +1662,75 @@ export async function planOnce(provider, messages, requestText, options = {}) {
   return heuristic;
 }
 
+async function executeToolCall({ executor, call, chatUI, messages, cwd }) {
+  const label = call.name === 'run_command' ? call.params.command
+    : call.name === 'download_url' ? `download_url(${call.params.url})`
+    : (call.name === 'todo_add' || call.name === 'todo_update')
+      ? `${call.name}(${JSON.stringify(call.params ?? {})})`
+      : `${call.name}(${call.params.path})`;
+  if (chatUI) {
+    chatUI.setStatus(`Running: ${label}`);
+    chatUI.setThinking(true);
+    chatUI.render(messages);
+  }
+  const result = await dispatchTool(executor, call);
+  logger.log('EXEC', `${label} -> ${result.exitCode}${result.timedOut ? ' [timeout]' : ''}`);
+  if (result.success) {
+    if (chatUI) chatUI.notify(`\u2713 ${label}`);
+    if (result.stdout.trim()) logger.log('EXEC', `${label} stdout: ${result.stdout.trim().slice(0, 500)}`);
+    if (result.stderr.trim()) logger.log('WARN', `${label} stderr: ${result.stderr.trim().slice(0, 500)}`);
+    if (call.name === 'create_file' && /\.py$/i.test(call.params.path)) {
+      const check = spawnSync('python3', [
+        '-c', 'import ast,sys; ast.parse(open(sys.argv[1], encoding="utf-8").read())',
+        join(cwd || '.', call.params.path),
+      ], { encoding: 'utf-8', timeout: 30000 });
+      if (check.status === 1) {
+        const detail = (check.stderr || '').trim().split('\n').slice(-2).join(' ');
+        if (chatUI) chatUI.notify(`\u2717 python check failed: ${call.params.path} (${detail})`);
+        logger.log('WARN', `${label} failed python syntax check: ${detail}`);
+      }
+    }
+  } else {
+    if (chatUI) chatUI.notify(`\u2717 ${label}: ${(result.stderr || 'failed').trim().slice(0, 300)}`);
+    logger.log('ERROR', `${label} failed: ${(result.stderr || result.stdout || 'exit ' + result.exitCode).trim().slice(0, 500)}`);
+  }
+  return { label, result };
+}
+
+// Ask the model for a corrected tool plan after a failed call. Returns []
+// when the model emits nothing usable. Does NOT mutate the session messages.
+async function planAutoFix(provider, messages, requestText, call, result) {
+  const history = (messages && messages.length ? messages.slice(-6) : [{ role: 'user', content: String(requestText || '') }]);
+  const deadline = Config.get('planTimeoutMs');
+  const controller = new AbortController();
+  let text = '';
+  let timer;
+  try {
+    text = await Promise.race([
+      provider.complete([...history, { role: 'user', content: TOOL_FIX_PROMPT(call, result) }], {
+        model: Config.getEffectiveModel(provider.name),
+        system_prompt: TOOL_PLAN_PROMPT,
+        maxTokens: 400,
+        signal: controller.signal,
+      }),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+          if (!controller.signal.aborted) controller.abort();
+          reject(Object.assign(new Error(`auto-fix exceeded ${deadline}ms`), { name: 'DeadlineError' }));
+        }, deadline);
+      }),
+    ]);
+  } catch (err) {
+    logger.log('FIX', `auto-fix plan failed: ${err.message}`);
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+  const plan = parseToolPlan(text);
+  if (plan.length) logger.log('FIX', `auto-fix plan: ${plan.map((p) => p.name).join(', ')}`);
+  return plan;
+}
+
 export async function runWithTools({
   provider,
   messages,
@@ -1648,6 +1748,7 @@ export async function runWithTools({
   const executor = makeExecutor({ cwd, timeoutMs });
   const results = [];
   const plannedByModel = [];
+  let autoFixes = 0;
 
   for (let round = 0; round < MAX_PLANNING_ROUNDS; round++) {
     let plan;
@@ -1662,38 +1763,25 @@ export async function runWithTools({
     const steps = Math.min(plan.length, MAX_STEPS - results.length);
     let allOk = true;
     for (const call of plan.slice(0, steps)) {
-      const label = call.name === 'run_command' ? call.params.command
-        : call.name === 'download_url' ? `download_url(${call.params.url})`
-        : `${call.name}(${call.params.path})`;
-      if (chatUI) {
-        chatUI.setStatus(`Running: ${label}`);
-        chatUI.setThinking(true);
-        chatUI.render(messages);
-      }
-      const result = await dispatchTool(executor, call);
+      const { result } = await executeToolCall({ executor, call, chatUI, messages, cwd });
       results.push({ name: call.name, params: call.params, result });
-      logger.log('EXEC', `${label} -> ${result.exitCode}${result.timedOut ? ' [timeout]' : ''}`);
-      if (result.success) {
-        if (chatUI) chatUI.notify(`\u2713 ${label}`);
-        if (result.stdout.trim()) logger.log('EXEC', `${label} stdout: ${result.stdout.trim().slice(0, 500)}`);
-        if (result.stderr.trim()) logger.log('WARN', `${label} stderr: ${result.stderr.trim().slice(0, 500)}`);
-        if (call.name === 'create_file' && /\.py$/i.test(call.params.path)) {
-          const check = spawnSync('python3', [
-            '-c', 'import ast,sys; ast.parse(open(sys.argv[1], encoding="utf-8").read())',
-            join(cwd || '.', call.params.path),
-          ], { encoding: 'utf-8', timeout: 30000 });
-          if (check.status === 1) {
-            const detail = (check.stderr || '').trim().split('\n').slice(-2).join(' ');
-            if (chatUI) chatUI.notify(`\u2717 python check failed: ${call.params.path} (${detail})`);
-            logger.log('WARN', `${label} failed python syntax check: ${detail}`);
-          }
+      if (!result.success) allOk = false;
+      if (result.timedOut && !result.success) break;
+
+      if (!result.success && autoFixes < MAX_AUTO_FIXES && results.length < MAX_STEPS) {
+        autoFixes++;
+        if (chatUI) chatUI.setStatus('Auto-fixing failed step…');
+        const fixPlan = await planAutoFix(provider, messages, requestText, call, result);
+        const fixSteps = Math.min(fixPlan.length, MAX_STEPS - results.length);
+        let fixedOk = fixPlan.length > 0;
+        for (const fcall of fixPlan.slice(0, fixSteps)) {
+          const f = await executeToolCall({ executor, call: fcall, chatUI, messages, cwd });
+          results.push({ name: fcall.name, params: fcall.params, result: f.result });
+          if (!f.result.success) { fixedOk = false; break; }
         }
-      } else {
-        allOk = false;
-        if (chatUI) chatUI.notify(`\u2717 ${label}: ${(result.stderr || 'failed').trim().slice(0, 300)}`);
-        logger.log('ERROR', `${label} failed: ${(result.stderr || result.stdout || 'exit ' + result.exitCode).trim().slice(0, 500)}`);
+        if (fixedOk && chatUI) chatUI.notify('Auto-fixed after failure.');
+        if (fixedOk) allOk = true;
       }
-      if (result.timedOut && !result.success) break;
     }
     if (allOk || !results.length || round >= MAX_PLANNING_ROUNDS - 1) break;
   }

package/src/cmd/todos.js

@@ -0,0 +1,64 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const FILE_NAME = '.todos.json';
+
+export function todosFile(cwd) {
+  return join(cwd || '.', FILE_NAME);
+}
+
+export function loadTodos(cwd) {
+  try {
+    const data = JSON.parse(readFileSync(todosFile(cwd), 'utf-8'));
+    if (!Array.isArray(data)) return [];
+    return data.map((t, i) => {
+      if (t && typeof t === 'object') {
+        return {
+          text: String(t.text ?? '').trim(),
+          done: Boolean(t.done),
+          createdAt: t.createdAt ?? null,
+          updatedAt: t.updatedAt ?? null,
+        };
+      }
+      return { text: String(t ?? '').trim(), done: false, createdAt: null, updatedAt: null };
+    }).filter((t) => t.text.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+export function saveTodos(cwd, todos) {
+  writeFileSync(todosFile(cwd), JSON.stringify(todos, null, 2) + '\n', 'utf-8');
+}
+
+export function formatTodos(todos) {
+  if (!todos || !todos.length) return '(no todos yet)';
+  return todos.map((t, i) => `${i + 1}. ${t.done ? '[x]' : '[ ]'} ${t.text}`).join('\n');
+}
+
+export function addTodo(cwd, text) {
+  const clean = String(text ?? '').trim();
+  if (!clean) return { error: 'Missing todo text.' };
+  const todos = loadTodos(cwd);
+  todos.push({ text: clean, done: false, createdAt: new Date().toISOString(), updatedAt: null });
+  saveTodos(cwd, todos);
+  return { okay: true };
+}
+
+export function updateTodo(cwd, index, { done, text } = {}) {
+  const todos = loadTodos(cwd);
+  const i = Number(index) - 1;
+  if (!Number.isInteger(i) || i < 0 || i >= todos.length) {
+    return { error: `No todo #${index}.` };
+  }
+  if (typeof done === 'boolean') todos[i].done = done;
+  if (typeof text === 'string' && text.trim()) todos[i].text = text.trim();
+  todos[i].updatedAt = new Date().toISOString();
+  saveTodos(cwd, todos);
+  return { okay: true };
+}
+
+export function clearTodos(cwd) {
+  saveTodos(cwd, []);
+  return { okay: true };
+}

package/src/cmd/tools.js

@@ -3,6 +3,7 @@ import { resolve, sep } from 'path';
 import { toolResult, SafeCommandExecutor } from './executor.js';
 import { Downloader } from '../utils/downloader.js';
 import { Config } from '../config.js';
+import { loadTodos, addTodo, updateTodo, clearTodos, formatTodos } from './todos.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
@@ -124,6 +125,35 @@ export async function downloadUrl(cwd, url, dir) {
   }
 }
 
+export function todoAdd(cwd, text) {
+  const err = addTodo(cwd, text);
+  if (err && err.error) return fail({ command: `todo_add("${text}")`, stderr: err.error, cwd });
+  return ok({ command: `todo_add("${text}")`, stdout: formatTodos(loadTodos(cwd)), cwd });
+}
+
+export function todoList(cwd) {
+  try {
+    return ok({ command: 'todo_list', stdout: formatTodos(loadTodos(cwd)), cwd });
+  } catch (err) {
+    return fail({ command: 'todo_list', stderr: err.message, cwd });
+  }
+}
+
+export function todoUpdate(cwd, index, done, text) {
+  const err = updateTodo(cwd, index, { done, text });
+  if (err && err.error) return fail({ command: `todo_update(${index})`, stderr: err.error, cwd });
+  return ok({ command: `todo_update(${index})`, stdout: formatTodos(loadTodos(cwd)), cwd });
+}
+
+export function todoClear(cwd) {
+  try {
+    clearTodos(cwd);
+    return ok({ command: 'todo_clear', stdout: '(no todos yet)', cwd });
+  } catch (err) {
+    return fail({ command: 'todo_clear', stderr: err.message, cwd });
+  }
+}
+
 // Structured tool registry shared with the agent loop.
 export const TOOL_EXECUTORS = {
   run_command: (executor, params) => executor.runCommand(params.command),
@@ -133,6 +163,10 @@ export const TOOL_EXECUTORS = {
   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),
+  todo_add: (executor, params) => todoAdd(executor.cwd, params ? params.text : undefined),
+  todo_list: (executor, params) => todoList(executor.cwd),
+  todo_update: (executor, params) => todoUpdate(executor.cwd, params ? params.index : undefined, params ? params.done : undefined, params ? params.text : undefined),
+  todo_clear: (executor, params) => todoClear(executor.cwd),
 };
 
 export function makeExecutor({ cwd, timeoutMs } = {}) {

package/src/ui/branding.js

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