markov-cli 1.0.1 → 1.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "markov-cli",
-  "version": "1.0.1",
-  "description": "A friendly CLI tool",
+  "version": "1.0.3",
+  "description": "LivingCloud's CLI AI Agent",
   "type": "module",
   "bin": {
     "markov": "./bin/markov.js"
@@ -11,6 +11,8 @@
   },
   "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,16 @@ export function renderDiff(filepath, newContent, cwd = process.cwd()) {
 
 export function parseEdits(responseText, loadedFiles = []) {
   const edits = [];
-  const regex = /```([\w./\-]*)\n([\s\S]*?)```/g;
+  // Match "FILE: path" followed by a fenced code block (so model can use FILE: path + ```lang)
+  const filePrefixRegex = /FILE:\s*([^\n]+)\s*\n\s*```(?:[\w./\-]*)\n([\s\S]*?)```/g;
   let match;
+  while ((match = filePrefixRegex.exec(responseText)) !== null) {
+    const filepath = match[1].trim();
+    const content = match[2];
+    if (filepath) edits.push({ filepath, content });
+  }
 
+  const regex = /```([\w./\-]*)\n([\s\S]*?)```/g;
   while ((match = regex.exec(responseText)) !== null) {
     const tag     = match[1].trim();
     const content = match[2];
@@ -169,5 +176,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/input.js

@@ -7,7 +7,7 @@ const visibleLen = (s) => s.replace(/\x1b\[[0-9;]*m/g, '').length;
 
 const PREFIX      = '❯  ';
 const HINT        = chalk.dim(' Ask Markov anything...');
-const STATUS_LEFT = chalk.dim('ctrl+q cancel  ·  @ attach files  ·  /cd change dir  ·  /models switch model  ·  /login auth');
+const STATUS_LEFT = chalk.dim('/help');
 const PICKER_MAX  = 6;
 
 function border() {
@@ -83,13 +83,22 @@ export function chatPrompt(_promptStr, allFiles) {
       stdout.write(rows.join('\n'));
 
       // rows = [border, inputLine, border, ...pickerRows(N), statusBar]
-      // inputLine is always at index 1. After writing all rows cursor is on
-      // statusBar. Move up (pickerRows.length + 2) to land back on inputLine.
+      // upAmount is always pickerRows.length + 2 regardless of input line wrapping
+      // because the extra visual lines from wrapping and the shifted target cancel out.
       const upAmount = pickerRows.length + 2;
       stdout.write(`\x1b[${upAmount}A\r`);
-      cursorLineOffset = 1; // inputLine is always 1 line from the top
 
-      const col = visibleLen(chalk.cyan(PREFIX)) + visibleLen(buffer) + 1;
+      // Account for input line wrapping: if the input is wider than the terminal,
+      // it takes multiple visual lines and we must move up by that many to reach
+      // the top border on the next redraw.
+      const w = process.stdout.columns || 80;
+      const inputVisualLen = visibleLen(chalk.cyan(PREFIX)) + visibleLen(buffer || HINT);
+      const inputVisualLines = Math.max(1, Math.ceil(inputVisualLen / w));
+      cursorLineOffset = inputVisualLines;
+
+      // Position cursor at the correct column on the last visual line of the input.
+      const totalInputLen = visibleLen(chalk.cyan(PREFIX)) + visibleLen(buffer);
+      const col = (totalInputLen % w) + 1;
       stdout.write(`\x1b[${col}G`);
     };
 

package/src/interactive.js

@@ -1,13 +1,201 @@
 import chalk from 'chalk';
+import gradient from 'gradient-string';
 import { homedir } from 'os';
 import { resolve } 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']);
+
+/** 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;
+}
+
+/**
+ * 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();
+
+  // Run terminal commands
+  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'));
+    }
+  }
+
+  // Write / edit files
+  const edits = parseEdits(reply, loadedFiles);
+  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 = getFilesAndDirs();
+        console.log(chalk.green(`✓ wrote ${filepath}\n`));
+      } catch (err) {
+        console.log(chalk.red(`✗ could not write ${filepath}: ${err.message}\n`));
+      }
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  // Create folders
+  for (const folderPath of parseMkdirCommands(reply)) {
+    process.stdout.write(chalk.dim(`  mkdir: ${folderPath} — `));
+    const confirmed = await confirm(chalk.bold(`Create folder ${chalk.cyan(folderPath)}? [y/N] `));
+    if (confirmed) {
+      try {
+        mkdirSync(resolve(process.cwd(), folderPath), { recursive: true });
+        allFiles = getFilesAndDirs();
+        console.log(chalk.green(`✓ created ${folderPath}\n`));
+      } catch (err) {
+        console.log(chalk.red(`✗ could not create ${folderPath}: ${err.message}\n`));
+      }
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  // Create empty files
+  for (const filePath of parseTouchCommands(reply)) {
+    const confirmed = await confirm(chalk.bold(`Create file ${chalk.cyan(filePath)}? [y/N] `));
+    if (confirmed) {
+      try {
+        const abs = resolve(process.cwd(), filePath);
+        const parentDir = abs.split('/').slice(0, -1).join('/');
+        mkdirSync(parentDir, { recursive: true });
+        writeFileSync(abs, '', { flag: 'wx' });
+        allFiles = getFilesAndDirs();
+        console.log(chalk.green(`✓ created ${filePath}\n`));
+      } catch (err) {
+        console.log(chalk.red(`✗ could not create ${filePath}: ${err.message}\n`));
+      }
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  // Remove directories
+  for (const dirPath of parseRmdirCommands(reply)) {
+    const confirmed = await confirm(chalk.bold(`Remove directory ${chalk.cyan(dirPath)}? [y/N] `));
+    if (confirmed) {
+      const abs = resolve(process.cwd(), dirPath);
+      if (existsSync(abs)) {
+        try {
+          rmSync(abs, { recursive: true, force: true });
+          allFiles = getFilesAndDirs();
+          console.log(chalk.green(`✓ removed ${dirPath}\n`));
+        } catch (err) {
+          console.log(chalk.red(`✗ could not remove ${dirPath}: ${err.message}\n`));
+        }
+      } else {
+        console.log(chalk.yellow(`⚠  not found: ${dirPath}\n`));
+      }
+    } else {
+      console.log(chalk.dim('skipped\n'));
+    }
+  }
+
+  // Delete files
+  for (const filePath of parseDeleteCommands(reply)) {
+    const confirmed = await confirm(chalk.bold(`Delete ${chalk.cyan(filePath)}? [y/N] `));
+    if (confirmed) {
+      const abs = resolve(process.cwd(), filePath);
+      if (existsSync(abs)) {
+        try {
+          unlinkSync(abs);
+          allFiles = getFilesAndDirs();
+          console.log(chalk.green(`✓ deleted ${filePath}\n`));
+        } catch (err) {
+          console.log(chalk.red(`✗ could not delete ${filePath}: ${err.message}\n`));
+        }
+      } else {
+        console.log(chalk.yellow(`⚠  not found: ${filePath}\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) {
@@ -124,17 +312,159 @@ function promptSecret(label) {
   });
 }
 
+const VIEWPORT_LINES = 5;
+const TERM_WIDTH = 80;
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const visLen = (s) => s.replace(ANSI_RE, '').length;
+
+/** Word-wrap plain text to a given column width, preserving existing newlines. */
+function wrapText(text, width) {
+  return text.split('\n').map(line => {
+    if (visLen(line) <= width) return line;
+    const words = line.split(' ');
+    const wrapped = [];
+    let current = '';
+    for (const word of words) {
+      const test = current ? current + ' ' + word : word;
+      if (visLen(test) <= width) {
+        current = test;
+      } else {
+        if (current) wrapped.push(current);
+        current = word;
+      }
+    }
+    if (current) wrapped.push(current);
+    return wrapped.join('\n');
+  }).join('\n');
+}
+
+/** Count the number of terminal rows a list of lines occupies, accounting for wrapping. */
+function countRows(lines, w) {
+  return lines.reduce((sum, l) => sum + Math.max(1, Math.ceil(visLen(l) / w)), 0);
+}
+
+/**
+ * Stream a chat response with a live 5-line viewport.
+ * While streaming, only the last VIEWPORT_LINES lines are shown in-place.
+ * 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` +
+    `- Run a terminal command: output exactly on its own line: !!run: <command>\n` +
+    `- Write or edit a file: output "FILE: path/to/file" followed by 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`;
+  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;
+  let fullText = '';
+  let viewportRows = 0; // actual terminal rows currently rendered in the viewport
+
+  process.stdout.write(chalk.dim('\nMarkov › '));
+  const spinner = setInterval(() => {
+    process.stdout.write('\r' + chalk.dim('Markov › ') + markovGradient(DOTS[dotIdx % DOTS.length]) + '   ');
+    dotIdx++;
+  }, 400);
+
+  const onCancel = (data) => { if (data.toString() === '\x11') signal.abort(); };
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', onCancel);
+
+  try {
+    const reply = await streamChat([buildSystemMessage(), ...resolvedMessages], (token) => {
+      if (firstToken) {
+        clearInterval(spinner);
+        firstToken = false;
+        process.stdout.write('\r\x1b[0J' + chalk.dim('Markov ›\n\n'));
+      }
+
+      fullText += token;
+
+      // Build the viewport: last VIEWPORT_LINES lines of buffered text.
+      const w = process.stdout.columns || TERM_WIDTH;
+      const displayWidth = Math.min(w, TERM_WIDTH);
+      const lines = wrapText(fullText, displayWidth).split('\n');
+      const viewLines = lines;
+      const rendered = viewLines.join('\n');
+
+      // Count actual terminal rows rendered (accounts for line wrapping).
+      const newRows = countRows(viewLines, w) - 1;
+
+      // Move cursor up to top of current viewport, clear down, rewrite.
+      if (viewportRows > 0) {
+        process.stdout.write(`\x1b[${viewportRows}A\r\x1b[0J`);
+      }
+      process.stdout.write(rendered);
+      viewportRows = newRows;
+    }, undefined, signal);
+
+    process.stdin.removeListener('data', onCancel);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    clearInterval(spinner);
+
+    if (signal.aborted) {
+      if (viewportRows > 0) process.stdout.write(`\x1b[${viewportRows}A\r\x1b[0J`);
+      console.log(chalk.dim('(cancelled)\n'));
+      return null;
+    }
+
+    // Replace viewport with the full response.
+    if (viewportRows > 0) process.stdout.write(`\x1b[${viewportRows}A\r\x1b[0J`);
+    const finalWidth = Math.min(process.stdout.columns || TERM_WIDTH, TERM_WIDTH);
+    process.stdout.write(wrapText(fullText, finalWidth) + '\n\n');
+
+    return reply;
+  } catch (err) {
+    clearInterval(spinner);
+    process.stdin.removeListener('data', onCancel);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    if (!signal.aborted) throw err;
+    return null;
+  }
+}
+
+const HELP_TEXT =
+  '\n' +
+  chalk.bold('Commands:\n') +
+  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('  /models') + chalk.dim('                     switch the active AI model\n') +
+  chalk.cyan('  /cd [path]') + chalk.dim('                  change working directory\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}).\n`));
-
-  if (!getToken()) {
-    console.log(chalk.yellow('⚠  Not logged in. Use /login to authenticate.\n'));
-  }
+  console.log(chalk.dim(`Chat with Markov (${MODEL}).`));
+  console.log(HELP_TEXT);
 
   while (true) {
     const raw = await chatPrompt(chalk.magenta('you> '), allFiles);
@@ -143,16 +473,9 @@ 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`));
-      }
+    // /help — list all commands
+    if (trimmed === '/help') {
+      console.log(HELP_TEXT);
       continue;
     }
 
@@ -174,7 +497,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`));
@@ -182,10 +505,66 @@ export async function startInteractive() {
       continue;
     }
 
-    const isEditMode = trimmed.startsWith('/edit ');
-    const message = isEditMode ? trimmed.slice(6).trim() : trimmed;
+    // /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 =
+        `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 → FILE: path/to/file + 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 {
+        const reply = await streamWithViewport(chatMessages, abortController.signal);
+        if (reply === null) {
+          chatMessages.pop();
+        } else {
+          chatMessages.push({ role: 'assistant', content: reply });
+          currentPlan = { text: reply };
+          console.log(chalk.green('\n✓ Plan stored. Use /build to execute it.\n'));
+        }
+      } catch (err) {
+        if (!abortController.signal.aborted) console.log(chalk.red(`\n${err.message}\n`));
+      }
+      continue;
+    }
+
+    // /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'));
+        continue;
+      }
+
+      const buildPrompt =
+        `Execute the following plan. Use FILE: syntax 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();
+      try {
+        const reply = await streamWithViewport(chatMessages, abortController.signal);
+        if (reply === null) {
+          chatMessages.pop();
+        } else {
+          chatMessages.push({ role: 'assistant', content: reply });
+          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`));
+      }
+      continue;
+    }
 
-    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(', ')}`));
@@ -194,82 +573,20 @@ export async function startInteractive() {
       console.log(chalk.yellow(`\n⚠  not found: ${failed.map(f => `@${f}`).join(', ')}`));
     }
 
-    chatMessages.push({ role: 'user', content });
-
-    // Animated waiting dots — cleared on first token
-    const DOTS = ['.', '..', '...'];
-    let dotIdx = 0;
-    let firstToken = true;
-    process.stdout.write(chalk.dim('\nMarkov › '));
-    const spinner = setInterval(() => {
-      process.stdout.write('\r' + chalk.dim('Markov › ' + DOTS[dotIdx % DOTS.length] + '   '));
-      dotIdx++;
-    }, 400);
+    // Store raw message — @refs are re-resolved fresh on every API call
+    chatMessages.push({ role: 'user', content: trimmed });
 
     const abortController = new AbortController();
     try {
+      const reply = await streamWithViewport(chatMessages, abortController.signal);
 
-      // Listen for Ctrl+Q on raw stdin to cancel the stream
-      const onCancel = (data) => {
-        if (data.toString() === '\x11') abortController.abort();
-      };
-      process.stdin.setRawMode(true);
-      process.stdin.resume();
-      process.stdin.setEncoding('utf8');
-      process.stdin.on('data', onCancel);
-
-      const reply = await streamChat(chatMessages, (token) => {
-        if (firstToken) {
-          clearInterval(spinner);
-          firstToken = false;
-          process.stdout.write('\r\x1b[0J' + chalk.dim('Markov ›\n\n'));
-        }
-        process.stdout.write(token);
-      }, undefined, abortController.signal);
-
-      process.stdin.removeListener('data', onCancel);
-      process.stdin.setRawMode(false);
-      process.stdin.pause();
-      clearInterval(spinner);
-
-      if (abortController.signal.aborted) {
-        console.log(chalk.dim('\n(cancelled)\n'));
+      if (reply === null) {
+        chatMessages.pop();
       } else {
-        console.log('\n');
         chatMessages.push({ role: 'assistant', content: reply });
-
-        // Detect file edits in the response (only in /edit mode)
-        const edits = isEditMode ? parseEdits(reply, loaded) : [];
-        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'));
-          }
-        }
-
-        // Refresh chat context with updated file contents so the model
-        // doesn't reference stale content from earlier in the conversation.
-        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) {
-      clearInterval(spinner);
       if (!abortController.signal.aborted) {
         console.log(chalk.red(`\n${err.message}\n`));
       }

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

@@ -9,19 +9,8 @@ const ASCII_ART = `
   ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝   ╚═══╝        
 `;
 
-const SMALL_MARKOV = `
-  █   █  ██  █ ██ █  █  ██  █   █
-  ██ ██ █ ██ ██   ███  █  █  ███
-  █ █ █ █  █ █    █ ██  ██    █  █   
-`;
-
 const markovGradient = gradient(['#6366f1', '#a855f7', '#ec4899']);
 
 export function printLogo() {
-  console.log(markovGradient.multiline(ASCII_ART));
-  console.log('  A friendly CLI tool\n');
-}
-
-export function printSmallMarkov() {
-  console.log(markovGradient.multiline(SMALL_MARKOV));
+  console.log(markovGradient.multiline(ASCII_ART + '                                 LivingCloud\'s AI Agent'));
 }

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();