markov-cli 1.0.1 → 1.0.2

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "markov-cli",
-  "version": "1.0.1",
-  "description": "A friendly CLI tool",
+  "version": "1.0.2",
+  "description": "LivingCloud's AI Agent",
   "type": "module",
   "bin": {
-    "markov": "./bin/markov.js"
+    "markov": "./bin/markov.js",
+    "markov-local": "./bin/markov.js"
   },
   "scripts": {
     "start": "node bin/markov.js"

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,6 +1,8 @@
 import chalk from 'chalk';
+import gradient from 'gradient-string';
 import { homedir } from 'os';
-import { resolve } from 'path';
+import { resolve, dirname, join } from 'path';
+import { readdirSync } from 'fs';
 import { printLogo } from './ui/logo.js';
 import { streamChat, MODEL, MODELS, setModel } from './ollama.js';
 import { resolveFileRefs } from './files.js';
@@ -9,6 +11,8 @@ import { chatPrompt } from './input.js';
 import { getFiles } from './ui/picker.js';
 import { getToken, login } from './auth.js';
 
+const markovGradient = gradient(['#6366f1', '#a855f7', '#ec4899']);
+
 /** Arrow-key selector. Returns the chosen string or null if cancelled. */
 function selectFrom(options, label) {
   return new Promise((resolve) => {
@@ -124,13 +128,140 @@ 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.
+ */
+async function streamWithViewport(chatMessages, signal) {
+  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(chatMessages, (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.slice(-VIEWPORT_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('  /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();
   const chatMessages = [];
+  let currentPlan = null; // { text: string } | null
 
-  console.log(chalk.dim(`Chat with Markov (${MODEL}).\n`));
+  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'));
@@ -156,6 +287,12 @@ export async function startInteractive() {
       continue;
     }
 
+    // /help — list all commands
+    if (trimmed === '/help') {
+      console.log(HELP_TEXT);
+      continue;
+    }
+
     // /models — pick active model
     if (trimmed === '/models') {
       const chosen = await selectFrom(MODELS, 'Select model:');
@@ -166,6 +303,58 @@ 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();
@@ -182,6 +371,140 @@ export async function startInteractive() {
       continue;
     }
 
+    // /plan <message> — ask LLM to produce a plan, store it (no files written)
+    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.`;
+
+      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
+    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 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\`\`\``;
+
+      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 });
+          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.' });
+          }
+        }
+      } catch (err) {
+        if (!abortController.signal.aborted) console.log(chalk.red(`\n${err.message}\n`));
+      }
+      continue;
+    }
+
+    // Determine mode
     const isEditMode = trimmed.startsWith('/edit ');
     const message = isEditMode ? trimmed.slice(6).trim() : trimmed;
 
@@ -194,52 +517,40 @@ export async function startInteractive() {
       console.log(chalk.yellow(`\n⚠  not found: ${failed.map(f => `@${f}`).join(', ')}`));
     }
 
-    chatMessages.push({ role: 'user', content });
+    // 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;
 
-    // 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);
+    chatMessages.push({ role: 'user', content: fullContent });
 
     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 edits = isEditMode ? parseEdits(reply, [...loaded, ...editDirFiles]) : [];
         const appliedEdits = [];
         for (const { filepath, content } of edits) {
           renderDiff(filepath, content);
@@ -257,8 +568,6 @@ export async function startInteractive() {
           }
         }
 
-        // 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({
@@ -269,7 +578,6 @@ export async function startInteractive() {
         }
       }
     } catch (err) {
-      clearInterval(spinner);
       if (!abortController.signal.aborted) {
         console.log(chalk.red(`\n${err.message}\n`));
       }

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'));
 }