markov-cli 1.0.2 → 1.0.4

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "markov-cli",
-  "version": "1.0.2",
-  "description": "LivingCloud's AI Agent",
+  "version": "1.0.4",
+  "description": "LivingCloud's CLI AI Agent",
   "type": "module",
   "bin": {
-    "markov": "./bin/markov.js",
-    "markov-local": "./bin/markov.js"
+    "markov": "./bin/markov.js"
   },
   "scripts": {
     "start": "node bin/markov.js"
   },
   "keywords": [
     "cli",
+    "livingcloud",
+    "livingcloud-cli",
     "markov",
     "markov-cli",
     "agent",

package/src/editor.js

@@ -1,5 +1,5 @@
-import { writeFileSync, readFileSync, existsSync } from 'fs';
-import { join, extname } from 'path';
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
+import { join, extname, dirname } from 'path';
 import chalk from 'chalk';
 
 // Maps common language identifiers (including short aliases) to file extensions.
@@ -141,9 +141,9 @@ export function renderDiff(filepath, newContent, cwd = process.cwd()) {
 
 export function parseEdits(responseText, loadedFiles = []) {
   const edits = [];
+  // File writes use !!write: in interactive.js; here we only handle fenced blocks with path/language or single attached file
   const regex = /```([\w./\-]*)\n([\s\S]*?)```/g;
   let match;
-
   while ((match = regex.exec(responseText)) !== null) {
     const tag     = match[1].trim();
     const content = match[2];
@@ -169,5 +169,7 @@ export function parseEdits(responseText, loadedFiles = []) {
 }
 
 export function applyEdit(filepath, content, cwd = process.cwd()) {
-  writeFileSync(join(cwd, filepath), content, 'utf-8');
+  const abs = join(cwd, filepath);
+  mkdirSync(dirname(abs), { recursive: true });
+  writeFileSync(abs, content, 'utf-8');
 }

package/src/files.js

@@ -1,8 +1,20 @@
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { readFileSync, existsSync, statSync } from 'fs';
+import { join, relative } from 'path';
+import { getFiles } from './ui/picker.js';
 
 const FILE_REF_REGEX = /@([\w./\-]+)/g;
 
+/** Infer language for fenced block from file extension */
+function langForPath(path) {
+  const ext = path.split('.').pop()?.toLowerCase();
+  const map = {
+    js: 'javascript', ts: 'typescript', tsx: 'tsx', jsx: 'jsx',
+    html: 'html', css: 'css', scss: 'scss', json: 'json',
+    md: 'markdown', py: 'python', sh: 'shell', yaml: 'yaml', yml: 'yaml',
+  };
+  return map[ext] ?? 'text';
+}
+
 /**
  * Finds all @ref patterns in a string and returns the unique file paths.
  */
@@ -29,15 +41,34 @@ export function resolveFileRefs(input, cwd = process.cwd()) {
   const blocks = [];
 
   for (const ref of refs) {
-    const fullPath = join(cwd, ref);
+    const cleanRef = ref.endsWith('/') ? ref.slice(0, -1) : ref;
+    const fullPath = join(cwd, cleanRef);
     if (!existsSync(fullPath)) {
       failed.push(ref);
       continue;
     }
+
+    // If it's a directory, expand to all files inside
+    if (statSync(fullPath).isDirectory()) {
+      const dirFiles = getFiles(fullPath, cwd);
+      for (const filePath of dirFiles) {
+        try {
+          const text = readFileSync(join(cwd, filePath), 'utf-8');
+          const lang = langForPath(filePath);
+          blocks.push(`FILE: ${filePath}\n\`\`\`${lang}\n${text}\n\`\`\``);
+          loaded.push(filePath);
+        } catch {
+          failed.push(filePath);
+        }
+      }
+      continue;
+    }
+
     try {
       const text = readFileSync(fullPath, 'utf-8');
-      blocks.push(`--- @${ref} ---\n${text}\n---`);
-      loaded.push(ref);
+      const lang = langForPath(cleanRef);
+      blocks.push(`FILE: ${cleanRef}\n\`\`\`${lang}\n${text}\n\`\`\``);
+      loaded.push(cleanRef);
     } catch {
       failed.push(ref);
     }

package/src/interactive.js

@@ -1,18 +1,264 @@
 import chalk from 'chalk';
 import gradient from 'gradient-string';
 import { homedir } from 'os';
-import { resolve, dirname, join } from 'path';
-import { readdirSync } from 'fs';
+import { resolve, relative, isAbsolute } from 'path';
+import { mkdirSync, rmSync, writeFileSync, unlinkSync, existsSync } from 'fs';
+import { join } from 'path';
 import { printLogo } from './ui/logo.js';
 import { streamChat, MODEL, MODELS, setModel } from './ollama.js';
 import { resolveFileRefs } from './files.js';
+import { execCommand } from './tools.js';
 import { parseEdits, applyEdit, renderDiff } from './editor.js';
 import { chatPrompt } from './input.js';
-import { getFiles } from './ui/picker.js';
-import { getToken, login } from './auth.js';
+import { getFiles, getFilesAndDirs } from './ui/picker.js';
 
 const markovGradient = gradient(['#6366f1', '#a855f7', '#ec4899']);
 
+/** If path is absolute and under cwd, return relative path; otherwise return as-is. */
+function toRelativePath(p) {
+  const cwd = process.cwd();
+  if (!isAbsolute(p)) return p;
+  const rel = relative(cwd, p);
+  if (!rel.startsWith('..') && !isAbsolute(rel)) return rel;
+  return p;
+}
+
+/** Extract every !!run: command from a model response. */
+function parseRunCommands(text) {
+  const commands = [];
+  for (const line of text.split('\n')) {
+    const match = line.match(/^!!run:\s*(.+)$/);
+    if (match) commands.push(match[1].trim());
+  }
+  return commands;
+}
+
+/** Extract every !!mkdir: path from a model response. */
+function parseMkdirCommands(text) {
+  const paths = [];
+  for (const line of text.split('\n')) {
+    const match = line.match(/^!!mkdir:\s*(.+)$/);
+    if (match) paths.push(match[1].trim());
+  }
+  return paths;
+}
+
+/** Extract every !!rmdir: path from a model response. */
+function parseRmdirCommands(text) {
+  const paths = [];
+  for (const line of text.split('\n')) {
+    const match = line.match(/^!!rmdir:\s*(.+)$/);
+    if (match) paths.push(match[1].trim());
+  }
+  return paths;
+}
+
+/** Extract every !!touch: path from a model response. */
+function parseTouchCommands(text) {
+  const paths = [];
+  for (const line of text.split('\n')) {
+    const match = line.match(/^!!touch:\s*(.+)$/);
+    if (match) paths.push(match[1].trim());
+  }
+  return paths;
+}
+
+/** Extract every !!delete: path from a model response. */
+function parseDeleteCommands(text) {
+  const paths = [];
+  for (const line of text.split('\n')) {
+    const match = line.match(/^!!delete:\s*(.+)$/);
+    if (match) paths.push(match[1].trim());
+  }
+  return paths;
+}
+
+/** Extract every !!write: path and its following fenced code block from a model response. */
+function parseWriteCommands(text) {
+  const edits = [];
+  const lines = text.split('\n');
+  let i = 0;
+  const blockRegex = /```(?:[\w./\-]*)\n([\s\S]*?)```/;
+  while (i < lines.length) {
+    const line = lines[i];
+    const writeMatch = line.match(/^!!write:\s*(.+)$/);
+    if (writeMatch) {
+      const filepath = writeMatch[1].trim();
+      if (filepath) {
+        const rest = lines.slice(i + 1).join('\n');
+        const blockMatch = rest.match(blockRegex);
+        if (blockMatch) {
+          edits.push({ filepath, content: blockMatch[1] });
+          const blockText = blockMatch[0];
+          const beforeBlock = rest.substring(0, rest.indexOf(blockText));
+          const linesBeforeBlock = beforeBlock.split('\n').length;
+          const linesInBlock = blockText.split('\n').length;
+          i += 1 + linesBeforeBlock + linesInBlock;
+          continue;
+        }
+      }
+    }
+    i++;
+  }
+  return edits;
+}
+
+/**
+ * Parse and apply all file operations from a model reply.
+ * Shows diffs/confirmations for each op. Returns updated allFiles list.
+ */
+async function handleFileOps(reply, loadedFiles) {
+  let allFiles = getFilesAndDirs();
+
+  // Create folders first (so !!run: cd <folder> can succeed later)
+  for (const folderPath of parseMkdirCommands(reply)) {
+    const path = toRelativePath(folderPath);
+    process.stdout.write(chalk.dim(`  mkdir: ${path} — `));
+    const confirmed = await confirm(chalk.bold(`Create folder ${chalk.cyan(path)}? [y/N] `));
+    if (confirmed) {
+      try {
+        mkdirSync(resolve(process.cwd(), path), { recursive: true });
+        allFiles = getFilesAndDirs();
+        console.log(chalk.green(`✓ created ${path}\n`));
+      } catch (err) {
+        console.log(chalk.red(`✗ could not create ${path}: ${err.message}\n`));
+      }
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  // Create empty files
+  for (const filePath of parseTouchCommands(reply)) {
+    const path = toRelativePath(filePath);
+    const confirmed = await confirm(chalk.bold(`Create file ${chalk.cyan(path)}? [y/N] `));
+    if (confirmed) {
+      try {
+        const abs = resolve(process.cwd(), path);
+        const parentDir = abs.split('/').slice(0, -1).join('/');
+        mkdirSync(parentDir, { recursive: true });
+        writeFileSync(abs, '', { flag: 'wx' });
+        allFiles = getFilesAndDirs();
+        console.log(chalk.green(`✓ created ${path}\n`));
+      } catch (err) {
+        console.log(chalk.red(`✗ could not create ${path}: ${err.message}\n`));
+      }
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  // Write files via !!write: path + fenced block
+  for (const { filepath, content } of parseWriteCommands(reply)) {
+    const path = toRelativePath(filepath);
+    renderDiff(path, content);
+    const confirmed = await confirm(chalk.bold(`Write ${chalk.cyan(path)}? [y/N] `));
+    if (confirmed) {
+      try {
+        applyEdit(path, content);
+        allFiles = getFilesAndDirs();
+        console.log(chalk.green(`✓ wrote ${path}\n`));
+      } catch (err) {
+        console.log(chalk.red(`✗ could not write ${path}: ${err.message}\n`));
+      }
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  // Write / edit files (fenced blocks with path/language or single attached file)
+  const edits = parseEdits(reply, loadedFiles);
+  for (const { filepath, content } of edits) {
+    const path = toRelativePath(filepath);
+    renderDiff(path, content);
+    const confirmed = await confirm(chalk.bold(`Write ${chalk.cyan(path)}? [y/N] `));
+    if (confirmed) {
+      try {
+        applyEdit(path, content);
+        allFiles = getFilesAndDirs();
+        console.log(chalk.green(`✓ wrote ${path}\n`));
+      } catch (err) {
+        console.log(chalk.red(`✗ could not write ${path}: ${err.message}\n`));
+      }
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  // Run terminal commands (after folders/files exist, so cd works)
+  for (const cmd of parseRunCommands(reply)) {
+    const ok = await confirm(chalk.bold(`Run: ${chalk.cyan(cmd)}? [y/N] `));
+    if (ok) {
+      // cd must be handled in-process — child processes can't change the parent's cwd
+      const cdMatch = cmd.match(/^cd\s+(.+)$/);
+      if (cdMatch) {
+        const target = resolve(process.cwd(), cdMatch[1].trim().replace(/^~/, homedir()));
+        try {
+          process.chdir(target);
+          allFiles = getFilesAndDirs();
+          console.log(chalk.dim(`  📁 ${process.cwd()}\n`));
+        } catch (err) {
+          console.log(chalk.red(`  no such directory: ${target}\n`));
+        }
+        continue;
+      }
+      process.stdout.write(chalk.dim(`  running: ${cmd}\n`));
+      const { stdout, stderr, exitCode } = await execCommand(cmd);
+      const output = [stdout, stderr].filter(Boolean).join('\n').trim();
+      console.log(output ? chalk.dim(output) + '\n' : chalk.dim(`  (exit ${exitCode})\n`));
+      allFiles = getFilesAndDirs();
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  // Remove directories
+  for (const dirPath of parseRmdirCommands(reply)) {
+    const path = toRelativePath(dirPath);
+    const confirmed = await confirm(chalk.bold(`Remove directory ${chalk.cyan(path)}? [y/N] `));
+    if (confirmed) {
+      const abs = resolve(process.cwd(), path);
+      if (existsSync(abs)) {
+        try {
+          rmSync(abs, { recursive: true, force: true });
+          allFiles = getFilesAndDirs();
+          console.log(chalk.green(`✓ removed ${path}\n`));
+        } catch (err) {
+          console.log(chalk.red(`✗ could not remove ${path}: ${err.message}\n`));
+        }
+      } else {
+        console.log(chalk.yellow(`⚠  not found: ${path}\n`));
+      }
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  // Delete files
+  for (const filePath of parseDeleteCommands(reply)) {
+    const path = toRelativePath(filePath);
+    const confirmed = await confirm(chalk.bold(`Delete ${chalk.cyan(path)}? [y/N] `));
+    if (confirmed) {
+      const abs = resolve(process.cwd(), path);
+      if (existsSync(abs)) {
+        try {
+          unlinkSync(abs);
+          allFiles = getFilesAndDirs();
+          console.log(chalk.green(`✓ deleted ${path}\n`));
+        } catch (err) {
+          console.log(chalk.red(`✗ could not delete ${path}: ${err.message}\n`));
+        }
+      } else {
+        console.log(chalk.yellow(`⚠  not found: ${path}\n`));
+      }
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  return allFiles;
+}
+
 /** Arrow-key selector. Returns the chosen string or null if cancelled. */
 function selectFrom(options, label) {
   return new Promise((resolve) => {
@@ -165,7 +411,40 @@ function countRows(lines, w) {
  * After streaming finishes, the viewport is replaced with the full response.
  * Returns the full reply string.
  */
+function buildSystemMessage() {
+  const files = getFiles();
+  const fileList = files.length > 0 ? `\nFiles in working directory:\n${files.map(f => `  ${f}`).join('\n')}\n` : '';
+  const fileOpsInstructions =
+    `\nFILE OPERATIONS — use these exact syntaxes when needed:\n` +
+    `- Always use RELATIVE paths (e.g. path/to/file or markov/next-app/README.md), never absolute paths like /Users/...\n` +
+    `- Run a terminal command: output exactly on its own line: !!run: <command>\n` +
+    `- Write or edit a file: output exactly on its own line !!write: path/to/file, then a fenced code block with the full file content.\n` +
+    `- Create an empty file: output exactly on its own line: !!touch: path/to/file\n` +
+    `- Create a folder: output exactly on its own line: !!mkdir: path/to/folder\n` +
+    `- Remove a folder: output exactly on its own line: !!rmdir: path/to/folder\n` +
+    `- Delete a file: output exactly on its own line: !!delete: path/to/file\n` +
+    `- You may combine multiple operations in one response.\n` +
+    `- NEVER put commands in fenced code blocks — always use !!run: syntax for commands.\n` +
+    `- NEVER use && inside !!run: — use one !!run: per command. For "cd then do X", output !!run: cd <path> on one line, then !!run: <command> on the next (cd changes the working directory for all following commands).\n` +
+    `\nSETUP NEXT.JS APP (or any new project in a subfolder):\n` +
+    `1. Create the folder first: !!mkdir: next-app (or the requested name).\n` +
+    `2. Change into it on its own line: !!run: cd next-app (nothing after the path).\n` +
+    `3. Run each following command on its own !!run: line: e.g. !!run: npx create-next-app@latest . --yes, then !!run: git init, !!run: git add ., !!run: git commit -m "Initial commit".\n` +
+    `\nSETUP LARAVEL API (output exactly this):\n` +
+    `!!mkdir: laravel-api then !!run: cd laravel-api then !!run: composer create-project --prefer-dist laravel/laravel . then !!run: php artisan serve. One per line; nothing after the dot in composer; no composer run dev or dev-server. No custom routes.\n` +
+    `\nSETUP ROUTES (API only — use when user asks to add routes, /health, /users, or API endpoints):\n` +
+    `Only after the Laravel app exists. Add in routes/api.php only (not web.php): GET /api/health returning response()->json(['status' => 'ok']), and /api/users as a resource (index, show, store, update, destroy) using User model and a controller. Register api in bootstrap/app.php if needed. Use !!write: for routes/api.php and the controller; prefix with laravel-api/ if cwd is parent. Do not use routes/web.php.\n`;
+  return { role: 'system', content: `You are Markov, an AI coding assistant.\nWorking directory: ${process.cwd()}\n${fileList}${fileOpsInstructions}` };
+}
+
 async function streamWithViewport(chatMessages, signal) {
+  // Re-resolve @file refs fresh on every request so the model always sees the latest file contents.
+  const resolvedMessages = chatMessages.map(msg => {
+    if (msg.role !== 'user') return msg;
+    const { content } = resolveFileRefs(msg.content);
+    return { ...msg, content };
+  });
+
   const DOTS = ['.', '..', '...'];
   let dotIdx = 0;
   let firstToken = true;
@@ -185,7 +464,7 @@ async function streamWithViewport(chatMessages, signal) {
   process.stdin.on('data', onCancel);
 
   try {
-    const reply = await streamChat(chatMessages, (token) => {
+    const reply = await streamChat([buildSystemMessage(), ...resolvedMessages], (token) => {
       if (firstToken) {
         clearInterval(spinner);
         firstToken = false;
@@ -198,7 +477,7 @@ async function streamWithViewport(chatMessages, signal) {
       const w = process.stdout.columns || TERM_WIDTH;
       const displayWidth = Math.min(w, TERM_WIDTH);
       const lines = wrapText(fullText, displayWidth).split('\n');
-      const viewLines = lines.slice(-VIEWPORT_LINES);
+      const viewLines = lines;
       const rendered = viewLines.join('\n');
 
       // Count actual terminal rows rendered (accounts for line wrapping).
@@ -245,28 +524,20 @@ const HELP_TEXT =
   chalk.cyan('  /help') + chalk.dim('                       show this help\n') +
   chalk.cyan('  /plan <message>') + chalk.dim('             ask AI to create a plan (no files written)\n') +
   chalk.cyan('  /build') + chalk.dim('                      execute the stored plan\n') +
-  chalk.cyan('  /yolo <message>') + chalk.dim('             AI can create/edit any file in cwd\n') +
-  chalk.cyan('  /edit <message>') + chalk.dim('             AI can edit files in @-referenced directories\n') +
-  chalk.cyan('  /new <file> [desc]') + chalk.dim('          create a new file with AI\n') +
   chalk.cyan('  /models') + chalk.dim('                     switch the active AI model\n') +
   chalk.cyan('  /cd [path]') + chalk.dim('                  change working directory\n') +
-  chalk.cyan('  /login') + chalk.dim('                      authenticate with email & password\n') +
   chalk.dim('\nTips: use ') + chalk.cyan('@filename') + chalk.dim(' to attach a file · ctrl+q to cancel a response\n');
 
 export async function startInteractive() {
   printLogo();
 
-  let allFiles = getFiles();
+  let allFiles = getFilesAndDirs();
   const chatMessages = [];
   let currentPlan = null; // { text: string } | null
 
   console.log(chalk.dim(`Chat with Markov (${MODEL}).`));
   console.log(HELP_TEXT);
 
-  if (!getToken()) {
-    console.log(chalk.yellow('⚠  Not logged in. Use /login to authenticate.\n'));
-  }
-
   while (true) {
     const raw = await chatPrompt(chalk.magenta('you> '), allFiles);
     if (raw === null) continue;
@@ -274,19 +545,6 @@ export async function startInteractive() {
 
     if (!trimmed) continue;
 
-    // /login — authenticate and save token
-    if (trimmed === '/login') {
-      const email    = await promptLine('Email: ');
-      const password = await promptSecret('Password: ');
-      try {
-        await login(email, password);
-        console.log(chalk.green('✓ logged in\n'));
-      } catch (err) {
-        console.log(chalk.red(`✗ ${err.message}\n`));
-      }
-      continue;
-    }
-
     // /help — list all commands
     if (trimmed === '/help') {
       console.log(HELP_TEXT);
@@ -303,58 +561,6 @@ export async function startInteractive() {
       continue;
     }
 
-    // /new <filename> [description] — create a new file with AI
-    if (trimmed.startsWith('/new ')) {
-      const args = trimmed.slice(5).trim();
-      const spaceIdx = args.indexOf(' ');
-      const filename = spaceIdx === -1 ? args : args.slice(0, spaceIdx);
-      const description = spaceIdx === -1 ? '' : args.slice(spaceIdx + 1).trim();
-
-      if (!filename) {
-        console.log(chalk.yellow('\nUsage: /new <filename> [description]\n'));
-        continue;
-      }
-
-      const newFilePrompt = description
-        ? `Create a new file called \`${filename}\` with the following requirements:\n${description}\n\nOutput the complete file content in a fenced code block tagged with the exact filename like this:\n\`\`\`${filename}\n// content here\n\`\`\``
-        : `Create a new file called \`${filename}\`. Output the complete file content in a fenced code block tagged with the exact filename like this:\n\`\`\`${filename}\n// content here\n\`\`\``;
-
-      chatMessages.push({ role: 'user', content: newFilePrompt });
-
-      const abortController = new AbortController();
-      try {
-        const reply = await streamWithViewport(chatMessages, abortController.signal);
-
-        if (reply === null) {
-          chatMessages.pop();
-        } else {
-          chatMessages.push({ role: 'assistant', content: reply });
-
-          const edits = parseEdits(reply, [filename]);
-          for (const { filepath, content } of edits) {
-            renderDiff(filepath, content);
-            const confirmed = await confirm(chalk.bold(`Create ${chalk.cyan(filepath)}? [y/N] `));
-            if (confirmed) {
-              try {
-                applyEdit(filepath, content);
-                allFiles = getFiles();
-                console.log(chalk.green(`✓ created ${filepath}\n`));
-              } catch (err) {
-                console.log(chalk.red(`✗ could not write ${filepath}: ${err.message}\n`));
-              }
-            } else {
-              console.log(chalk.dim('skipped\n'));
-            }
-          }
-        }
-      } catch (err) {
-        if (!abortController.signal.aborted) {
-          console.log(chalk.red(`\n${err.message}\n`));
-        }
-      }
-      continue;
-    }
-
     // /cd [path] — change working directory within this session
     if (trimmed.startsWith('/cd')) {
       const arg = trimmed.slice(3).trim();
@@ -363,7 +569,7 @@ export async function startInteractive() {
         : homedir();
       try {
         process.chdir(target);
-        allFiles = getFiles();
+        allFiles = getFilesAndDirs();
         console.log(chalk.dim(`\n📁 ${process.cwd()}\n`));
       } catch {
         console.log(chalk.red(`\nno such directory: ${target}\n`));
@@ -371,14 +577,18 @@ export async function startInteractive() {
       continue;
     }
 
-    // /plan <message> — ask LLM to produce a plan, store it (no files written)
+    // /plan <message> — ask LLM to produce a plan as a normal chat message, store it
     if (trimmed.startsWith('/plan ')) {
       const planRequest = trimmed.slice(6).trim();
       const planPrompt =
-        `You are a planning assistant. Create a detailed, numbered plan for the following task:\n\n${planRequest}\n\n` +
-        `For each step specify what to do and which files to create or modify (with exact relative paths).\n` +
-        `Do NOT write any code yet — only the plan.`;
-
+        `Create a detailed, numbered plan for the following task:\n\n${planRequest}\n\n` +
+        `For each step, specify exactly what will happen and which syntax will be used:\n` +
+        `- Writing or editing a file → !!write: path/to/file then fenced code block\n` +
+        `- Creating an empty file   → !!touch: path/to/file\n` +
+        `- Creating a folder        → !!mkdir: path/to/folder\n` +
+        `- Removing a folder        → !!rmdir: path/to/folder\n` +
+        `- Deleting a file          → !!delete: path/to/file\n\n` +
+        `Do NOT output any actual file contents or commands yet — only the plan.`;
       chatMessages.push({ role: 'user', content: planPrompt });
       const abortController = new AbortController();
       try {
@@ -396,7 +606,7 @@ export async function startInteractive() {
       continue;
     }
 
-    // /build — execute the stored plan
+    // /build — execute the stored plan with full file ops
     if (trimmed === '/build') {
       if (!currentPlan) {
         console.log(chalk.yellow('\n⚠  No plan stored. Use /plan <message> first.\n'));
@@ -404,9 +614,8 @@ export async function startInteractive() {
       }
 
       const buildPrompt =
-        `Execute the following plan by outputting ALL files to create or modify as fenced code blocks tagged with their exact relative filenames.\n\n` +
-        `Plan:\n${currentPlan.text}\n\n` +
-        `Output each file completely in a fenced code block like:\n\`\`\`path/to/file.ext\n// full content\n\`\`\``;
+        `Execute the following plan. Use !!write: path then a fenced code block for file writes, !!mkdir: for folders, !!delete: for deletions.\n\n` +
+        `Plan:\n${currentPlan.text}`;
 
       chatMessages.push({ role: 'user', content: buildPrompt });
       const abortController = new AbortController();
@@ -416,87 +625,9 @@ export async function startInteractive() {
           chatMessages.pop();
         } else {
           chatMessages.push({ role: 'assistant', content: reply });
-          const edits = parseEdits(reply, []);
-          const appliedEdits = [];
-          for (const { filepath, content } of edits) {
-            renderDiff(filepath, content);
-            const confirmed = await confirm(chalk.bold(`Write ${chalk.cyan(filepath)}? [y/N] `));
-            if (confirmed) {
-              try {
-                applyEdit(filepath, content);
-                allFiles = getFiles();
-                console.log(chalk.green(`✓ wrote ${filepath}\n`));
-                appliedEdits.push({ filepath, content });
-              } catch (err) {
-                console.log(chalk.red(`✗ could not write ${filepath}: ${err.message}\n`));
-              }
-            } else {
-              console.log(chalk.dim('skipped\n'));
-            }
-          }
-          if (appliedEdits.length > 0) {
-            currentPlan = null;
-            console.log(chalk.green('✓ Plan executed.\n'));
-          }
-        }
-      } catch (err) {
-        if (!abortController.signal.aborted) console.log(chalk.red(`\n${err.message}\n`));
-      }
-      continue;
-    }
-
-    // /yolo <message> — AI can create/edit any file in cwd; @refs loaded for context
-    if (trimmed.startsWith('/yolo ')) {
-      const yoloMessage = trimmed.slice(6).trim();
-      const { content: yoloContent, loaded: yoloLoaded, failed: yoloFailed } = resolveFileRefs(yoloMessage);
-
-      if (yoloLoaded.length > 0) {
-        console.log(chalk.dim(`\n📎 attached: ${yoloLoaded.map(f => chalk.cyan(`@${f}`)).join(', ')}`));
-      }
-      if (yoloFailed.length > 0) {
-        console.log(chalk.yellow(`\n⚠  not found: ${yoloFailed.map(f => `@${f}`).join(', ')}`));
-      }
-
-      const yoloInstruction =
-        `You have permission to create or modify ANY file in the current working directory.\n` +
-        `Output every file you create or modify as a fenced code block tagged with its exact relative path:\n` +
-        `\`\`\`path/to/file.ext\n// full content\n\`\`\`\n\n`;
-
-      const yoloFull = yoloContent.startsWith('The user referenced')
-        ? yoloContent.replace('The user referenced', yoloInstruction + 'The user referenced')
-        : yoloInstruction + yoloContent;
-
-      chatMessages.push({ role: 'user', content: yoloFull });
-      const abortController = new AbortController();
-      try {
-        const reply = await streamWithViewport(chatMessages, abortController.signal);
-        if (reply === null) {
-          chatMessages.pop();
-        } else {
-          chatMessages.push({ role: 'assistant', content: reply });
-          const edits = parseEdits(reply, yoloLoaded);
-          const appliedEdits = [];
-          for (const { filepath, content } of edits) {
-            renderDiff(filepath, content);
-            const confirmed = await confirm(chalk.bold(`Write ${chalk.cyan(filepath)}? [y/N] `));
-            if (confirmed) {
-              try {
-                applyEdit(filepath, content);
-                allFiles = getFiles();
-                console.log(chalk.green(`✓ wrote ${filepath}\n`));
-                appliedEdits.push({ filepath, content });
-              } catch (err) {
-                console.log(chalk.red(`✗ could not write ${filepath}: ${err.message}\n`));
-              }
-            } else {
-              console.log(chalk.dim('skipped\n'));
-            }
-          }
-          if (appliedEdits.length > 0) {
-            const blocks = appliedEdits.map(({ filepath, content }) => `--- @${filepath} ---\n${content}\n---`);
-            chatMessages.push({ role: 'user', content: `Files saved:\n\n${blocks.join('\n\n')}` });
-            chatMessages.push({ role: 'assistant', content: 'Got it, I have the updated file contents.' });
-          }
+          allFiles = await handleFileOps(reply, []);
+          currentPlan = null;
+          console.log(chalk.green('✓ Plan executed.\n'));
         }
       } catch (err) {
         if (!abortController.signal.aborted) console.log(chalk.red(`\n${err.message}\n`));
@@ -504,11 +635,8 @@ export async function startInteractive() {
       continue;
     }
 
-    // Determine mode
-    const isEditMode = trimmed.startsWith('/edit ');
-    const message = isEditMode ? trimmed.slice(6).trim() : trimmed;
-
-    const { content, loaded, failed } = resolveFileRefs(message);
+    // Normal chat — file ops always available
+    const { loaded, failed } = resolveFileRefs(trimmed);
 
     if (loaded.length > 0) {
       console.log(chalk.dim(`\n📎 attached: ${loaded.map(f => chalk.cyan(`@${f}`)).join(', ')}`));
@@ -517,29 +645,8 @@ export async function startInteractive() {
       console.log(chalk.yellow(`\n⚠  not found: ${failed.map(f => `@${f}`).join(', ')}`));
     }
 
-    // For /edit, expand scope to all files in the directories of @-referenced files.
-    let editDirFiles = [];
-    let editDirInstruction = '';
-    if (isEditMode && loaded.length > 0) {
-      const dirs = [...new Set(loaded.map(f => dirname(f) || '.'))];
-      for (const dir of dirs) {
-        try {
-          const entries = readdirSync(join(process.cwd(), dir), { withFileTypes: true });
-          for (const e of entries) {
-            if (e.isFile()) editDirFiles.push(dir === '.' ? e.name : `${dir}/${e.name}`);
-          }
-        } catch { /* ignore unreadable dirs */ }
-      }
-      editDirInstruction =
-        `\nYou may edit any file in the following director${dirs.length > 1 ? 'ies' : 'y'}: ${dirs.join(', ')}.\n` +
-        `Output modified files as fenced code blocks tagged with their exact relative path.\n`;
-    }
-
-    const fullContent = isEditMode && editDirInstruction
-      ? content + editDirInstruction
-      : content;
-
-    chatMessages.push({ role: 'user', content: fullContent });
+    // Store raw message — @refs are re-resolved fresh on every API call
+    chatMessages.push({ role: 'user', content: trimmed });
 
     const abortController = new AbortController();
     try {
@@ -549,33 +656,7 @@ export async function startInteractive() {
         chatMessages.pop();
       } else {
         chatMessages.push({ role: 'assistant', content: reply });
-
-        const edits = isEditMode ? parseEdits(reply, [...loaded, ...editDirFiles]) : [];
-        const appliedEdits = [];
-        for (const { filepath, content } of edits) {
-          renderDiff(filepath, content);
-          const confirmed = await confirm(chalk.bold(`Apply changes to ${chalk.cyan(filepath)}? [y/N] `));
-          if (confirmed) {
-            try {
-              applyEdit(filepath, content);
-              console.log(chalk.green(`✓ saved ${filepath}\n`));
-              appliedEdits.push({ filepath, content });
-            } catch (err) {
-              console.log(chalk.red(`✗ could not write ${filepath}: ${err.message}\n`));
-            }
-          } else {
-            console.log(chalk.dim('skipped\n'));
-          }
-        }
-
-        if (appliedEdits.length > 0) {
-          const blocks = appliedEdits.map(({ filepath, content }) => `--- @${filepath} ---\n${content}\n---`);
-          chatMessages.push({
-            role: 'user',
-            content: `The following file(s) were just saved with the applied changes:\n\n${blocks.join('\n\n')}`,
-          });
-          chatMessages.push({ role: 'assistant', content: 'Got it, I have the updated file contents.' });
-        }
+        allFiles = await handleFileOps(reply, loaded);
       }
     } catch (err) {
       if (!abortController.signal.aborted) {

package/src/ollama.js

@@ -4,7 +4,7 @@ const getHeaders = () => {
   const token = getToken();
   return { 'Content-Type': 'application/json', ...(token && { Authorization: `Bearer ${token}` }) };
 };
-export const MODELS = ['gemma3:4b', 'qwen2.5-coder:0.5b', 'qwen2.5-coder:7b', 'qwen3:14b'];
+export const MODELS = ['gemma3:4b', 'qwen2.5-coder:0.5b', 'qwen2.5-coder:7b', 'qwen2.5:14b-instruct', 'qwen3:14b'];
 export let MODEL    = 'qwen3:14b';
 export function setModel(m) { MODEL = m; }
 
@@ -69,3 +69,23 @@ export async function streamChat(messages, onToken, _model = MODEL, signal = nul
 
   return fullText;
 }
+
+/**
+ * Chat with tools (function calling). Non-streaming; returns full response with optional tool_calls.
+ * Use for agent loop: if message.tool_calls present, run tools locally and call again with updated messages.
+ */
+export async function chatWithTools(messages, tools, model = MODEL, signal = null) {
+  const controller = signal ? { signal } : {};
+  const res = await fetch(`${API_URL}/ai/chat/tools`, {
+    method: 'POST',
+    headers: getHeaders(),
+    body: JSON.stringify({ messages, tools, model, temperature: 0.2 }),
+    ...controller,
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`API error ${res.status} ${res.statusText}${body ? ': ' + body : ''}`);
+  }
+  const data = await res.json();
+  return data;
+}

package/src/tools.js

@@ -0,0 +1,129 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { mkdirSync } from 'fs';
+import { resolve } from 'path';
+
+const execAsync = promisify(exec);
+
+/** Ollama-format tool definition for running a shell command on the user's machine */
+export const RUN_TERMINAL_COMMAND_TOOL = {
+  type: 'function',
+  function: {
+    name: 'run_terminal_command',
+    description: 'Run a single shell command in the user\'s terminal. You MUST call this tool (do not only list commands in your reply) when the user asks to set up a project, install dependencies (npm install, pip install, etc.), run init/build commands (npm init, npx create-react-app, etc.), or execute any shell command. Use for listing files (ls), checking status (git status), and running scripts. Commands run in the current working directory. Do not run interactive or long-running daemons. Run one command per tool call; for multiple commands, make multiple tool calls.',
+    parameters: {
+      type: 'object',
+      required: ['command'],
+      properties: {
+        command: {
+          type: 'string',
+          description: 'The shell command to run (e.g. "ls -la", "git status"). Single command only, no pipes or multiple commands unless the shell supports it.',
+        },
+        cwd: {
+          type: 'string',
+          description: 'Working directory for the command. Defaults to current directory if omitted.',
+        },
+      },
+    },
+  },
+};
+
+/** Ollama-format tool definition for creating a directory */
+export const CREATE_FOLDER_TOOL = {
+  type: 'function',
+  function: {
+    name: 'create_folder',
+    description: 'Create a folder (and any necessary parent folders) in the current working directory.',
+    parameters: {
+      type: 'object',
+      required: ['path'],
+      properties: {
+        path: {
+          type: 'string',
+          description: 'Relative path of the folder to create (e.g. "src/components").',
+        },
+      },
+    },
+  },
+};
+
+const TOOLS_MAP = {
+  create_folder: async (args, opts = {}) => {
+    const folderPath = typeof args.path === 'string' ? args.path : String(args?.path ?? '');
+    if (!folderPath.trim()) {
+      return { success: false, error: 'Error: empty path' };
+    }
+    const cwd = opts.cwd ?? process.cwd();
+    const absPath = resolve(cwd, folderPath);
+    try {
+      mkdirSync(absPath, { recursive: true });
+      return { success: true, path: folderPath };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  },
+  run_terminal_command: async (args, opts = {}) => {
+    const command = typeof args.command === 'string' ? args.command : String(args?.command ?? '');
+    const cwd = typeof args.cwd === 'string' ? args.cwd : opts.cwd ?? process.cwd();
+    if (!command.trim()) {
+      return { stdout: '', stderr: 'Error: empty command', exitCode: 1 };
+    }
+    if (opts.confirmFn) {
+      const ok = await opts.confirmFn(command);
+      if (!ok) {
+        return { stdout: '', stderr: 'Command cancelled by user', exitCode: -1 };
+      }
+    }
+    const timeout = opts.timeout ?? 30_000;
+
+    const maxBuffer = opts.maxBuffer ?? 1024 * 1024;
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd,
+        timeout,
+        maxBuffer,
+        shell: true,
+      });
+      return { stdout: stdout || '', stderr: stderr || '', exitCode: 0 };
+    } catch (err) {
+      const stderr = err.stderr ?? err.message ?? String(err);
+      const stdout = err.stdout ?? '';
+      const exitCode = err.code ?? 1;
+      return { stdout, stderr, exitCode };
+    }
+  },
+};
+
+/**
+ * Execute a shell command directly and return its output.
+ * @param {string} command
+ * @param {string} [cwd]
+ * @returns {Promise<{ stdout: string, stderr: string, exitCode: number }>}
+ */
+export async function execCommand(command, cwd = process.cwd()) {
+  if (!command.trim()) return { stdout: '', stderr: 'Error: empty command', exitCode: 1 };
+  const timeout = 30_000;
+  const maxBuffer = 1024 * 1024;
+  try {
+    const { stdout, stderr } = await execAsync(command, { cwd, timeout, maxBuffer, shell: true });
+    return { stdout: stdout || '', stderr: stderr || '', exitCode: 0 };
+  } catch (err) {
+    return { stdout: err.stdout ?? '', stderr: err.stderr ?? err.message ?? String(err), exitCode: err.code ?? 1 };
+  }
+}
+
+/**
+ * Run a tool by name with the given arguments.
+ * @param {string} name - Tool name (e.g. 'run_terminal_command')
+ * @param {Record<string, unknown>} args - Arguments object (e.g. { command: 'ls -la' })
+ * @param {{ cwd?: string, confirmFn?: (command: string) => Promise<boolean>, timeout?: number }} opts - Optional cwd, confirmation callback for terminal commands, timeout
+ * @returns {Promise<string>} - Result string to send back to the model (e.g. JSON or plain text)
+ */
+export async function runTool(name, args, opts = {}) {
+  const fn = TOOLS_MAP[name];
+  if (!fn) {
+    return JSON.stringify({ error: `Unknown tool: ${name}` });
+  }
+  const result = await fn(args ?? {}, opts);
+  return typeof result === 'string' ? result : JSON.stringify(result);
+}

package/src/ui/picker.js

@@ -24,6 +24,26 @@ export function getFiles(dir = process.cwd(), base = dir, depth = 0, acc = []) {
   return acc;
 }
 
+/** Returns files AND directories (dirs have a trailing /). */
+export function getFilesAndDirs(dir = process.cwd(), base = dir, depth = 0, acc = []) {
+  if (depth > 5 || acc.length >= MAX_FILES) return acc;
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return acc; }
+  for (const entry of entries) {
+    if (IGNORE.has(entry.name) || entry.name.startsWith('.')) continue;
+    const full = join(dir, entry.name);
+    const rel  = relative(base, full);
+    if (entry.isDirectory()) {
+      acc.push(rel + '/');
+      getFilesAndDirs(full, base, depth + 1, acc);
+    } else {
+      acc.push(rel);
+    }
+    if (acc.length >= MAX_FILES) break;
+  }
+  return acc;
+}
+
 export function filterFiles(files, query) {
   if (!query) return files;
   const q = query.toLowerCase();