markov-cli 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markov-cli",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "LivingCloud's CLI AI Agent",
   "type": "module",
   "bin": {

package/src/editor.js

@@ -141,16 +141,9 @@ export function renderDiff(filepath, newContent, cwd = process.cwd()) {
 
 export function parseEdits(responseText, loadedFiles = []) {
   const edits = [];
-  // 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 });
-  }
-
+  // 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];

package/src/interactive.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import gradient from 'gradient-string';
 import { homedir } from 'os';
-import { resolve } from 'path';
+import { resolve, relative, isAbsolute } from 'path';
 import { mkdirSync, rmSync, writeFileSync, unlinkSync, existsSync } from 'fs';
 import { join } from 'path';
 import { printLogo } from './ui/logo.js';
@@ -14,6 +14,15 @@ 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 = [];
@@ -64,109 +73,163 @@ function parseDeleteCommands(text) {
   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.
+ * options.autoConfirm: if true, skip y/n prompts and apply all ops.
  */
-async function handleFileOps(reply, loadedFiles) {
+async function handleFileOps(reply, loadedFiles, options = {}) {
+  const autoConfirm = options.autoConfirm === true;
   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;
+  // 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 = autoConfirm ? true : 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`));
       }
-      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] `));
+  // Create empty files
+  for (const filePath of parseTouchCommands(reply)) {
+    const path = toRelativePath(filePath);
+    const confirmed = autoConfirm ? true : await confirm(chalk.bold(`Create file ${chalk.cyan(path)}? [y/N] `));
     if (confirmed) {
       try {
-        applyEdit(filepath, content);
+        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(`✓ wrote ${filepath}\n`));
+        console.log(chalk.green(`✓ created ${path}\n`));
       } catch (err) {
-        console.log(chalk.red(`✗ could not write ${filepath}: ${err.message}\n`));
+        console.log(chalk.red(`✗ could not create ${path}: ${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] `));
+  // Write files via !!write: path + fenced block
+  for (const { filepath, content } of parseWriteCommands(reply)) {
+    const path = toRelativePath(filepath);
+    renderDiff(path, content);
+    const confirmed = autoConfirm ? true : await confirm(chalk.bold(`Write ${chalk.cyan(path)}? [y/N] `));
     if (confirmed) {
       try {
-        mkdirSync(resolve(process.cwd(), folderPath), { recursive: true });
+        applyEdit(path, content);
         allFiles = getFilesAndDirs();
-        console.log(chalk.green(`✓ created ${folderPath}\n`));
+        console.log(chalk.green(`✓ wrote ${path}\n`));
       } catch (err) {
-        console.log(chalk.red(`✗ could not create ${folderPath}: ${err.message}\n`));
+        console.log(chalk.red(`✗ could not write ${path}: ${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] `));
+  // 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 = autoConfirm ? true : await confirm(chalk.bold(`Write ${chalk.cyan(path)}? [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' });
+        applyEdit(path, content);
         allFiles = getFilesAndDirs();
-        console.log(chalk.green(`✓ created ${filePath}\n`));
+        console.log(chalk.green(`✓ wrote ${path}\n`));
       } catch (err) {
-        console.log(chalk.red(`✗ could not create ${filePath}: ${err.message}\n`));
+        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 = autoConfirm ? true : 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 confirmed = await confirm(chalk.bold(`Remove directory ${chalk.cyan(dirPath)}? [y/N] `));
+    const path = toRelativePath(dirPath);
+    const confirmed = autoConfirm ? true : await confirm(chalk.bold(`Remove directory ${chalk.cyan(path)}? [y/N] `));
     if (confirmed) {
-      const abs = resolve(process.cwd(), dirPath);
+      const abs = resolve(process.cwd(), path);
       if (existsSync(abs)) {
         try {
           rmSync(abs, { recursive: true, force: true });
           allFiles = getFilesAndDirs();
-          console.log(chalk.green(`✓ removed ${dirPath}\n`));
+          console.log(chalk.green(`✓ removed ${path}\n`));
         } catch (err) {
-          console.log(chalk.red(`✗ could not remove ${dirPath}: ${err.message}\n`));
+          console.log(chalk.red(`✗ could not remove ${path}: ${err.message}\n`));
         }
       } else {
-        console.log(chalk.yellow(`⚠  not found: ${dirPath}\n`));
+        console.log(chalk.yellow(`⚠  not found: ${path}\n`));
       }
     } else {
       console.log(chalk.dim('skipped\n'));
@@ -175,19 +238,20 @@ async function handleFileOps(reply, loadedFiles) {
 
   // Delete files
   for (const filePath of parseDeleteCommands(reply)) {
-    const confirmed = await confirm(chalk.bold(`Delete ${chalk.cyan(filePath)}? [y/N] `));
+    const path = toRelativePath(filePath);
+    const confirmed = autoConfirm ? true : await confirm(chalk.bold(`Delete ${chalk.cyan(path)}? [y/N] `));
     if (confirmed) {
-      const abs = resolve(process.cwd(), filePath);
+      const abs = resolve(process.cwd(), path);
       if (existsSync(abs)) {
         try {
           unlinkSync(abs);
           allFiles = getFilesAndDirs();
-          console.log(chalk.green(`✓ deleted ${filePath}\n`));
+          console.log(chalk.green(`✓ deleted ${path}\n`));
         } catch (err) {
-          console.log(chalk.red(`✗ could not delete ${filePath}: ${err.message}\n`));
+          console.log(chalk.red(`✗ could not delete ${path}: ${err.message}\n`));
         }
       } else {
-        console.log(chalk.yellow(`⚠  not found: ${filePath}\n`));
+        console.log(chalk.yellow(`⚠  not found: ${path}\n`));
       }
     } else {
       console.log(chalk.dim('skipped\n'));
@@ -354,14 +418,24 @@ function buildSystemMessage() {
   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 "FILE: path/to/file" followed by a fenced code block with the full file content.\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 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}` };
 }
 
@@ -454,7 +528,7 @@ const HELP_TEXT =
   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');
+  chalk.dim('\nNormal chat: plan then build (no y/n). Tips: ') + chalk.cyan('@filename') + chalk.dim(' to attach a file · ctrl+q to cancel\n');
 
 export async function startInteractive() {
   printLogo();
@@ -511,7 +585,7 @@ export async function startInteractive() {
       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` +
+        `- 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` +
@@ -542,7 +616,7 @@ export async function startInteractive() {
       }
 
       const buildPrompt =
-        `Execute the following plan. Use FILE: syntax for file writes, !!mkdir: for folders, !!delete: for deletions.\n\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 });
@@ -563,7 +637,7 @@ export async function startInteractive() {
       continue;
     }
 
-    // Normal chat — file ops always available
+    // Normal chat — plan then build (two phases), apply file ops without y/n
     const { loaded, failed } = resolveFileRefs(trimmed);
 
     if (loaded.length > 0) {
@@ -573,19 +647,38 @@ export async function startInteractive() {
       console.log(chalk.yellow(`\n⚠  not found: ${failed.map(f => `@${f}`).join(', ')}`));
     }
 
-    // Store raw message — @refs are re-resolved fresh on every API call
-    chatMessages.push({ role: 'user', content: trimmed });
-
+    const planPrompt =
+      `Create a detailed, numbered plan for the following task:\n\n${trimmed}\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 {
-      const reply = await streamWithViewport(chatMessages, abortController.signal);
-
-      if (reply === null) {
+      const planReply = await streamWithViewport(chatMessages, abortController.signal);
+      if (planReply === null) {
         chatMessages.pop();
-      } else {
-        chatMessages.push({ role: 'assistant', content: reply });
-        allFiles = await handleFileOps(reply, loaded);
+        continue;
+      }
+      chatMessages.push({ role: 'assistant', content: planReply });
+
+      const buildPrompt =
+        `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${planReply}`;
+
+      chatMessages.push({ role: 'user', content: buildPrompt });
+      const buildReply = await streamWithViewport(chatMessages, abortController.signal);
+      if (buildReply === null) {
+        chatMessages.pop(); // remove build prompt
+        continue;
       }
+      chatMessages.push({ role: 'assistant', content: buildReply });
+      allFiles = await handleFileOps(buildReply, loaded, { autoConfirm: true });
     } catch (err) {
       if (!abortController.signal.aborted) {
         console.log(chalk.red(`\n${err.message}\n`));