markov-cli 1.0.10 → 1.0.12

package/src/tools.js

@@ -2,6 +2,7 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import { mkdirSync, readFileSync, writeFileSync, existsSync, unlinkSync, readdirSync, statSync } from 'fs';
 import { resolve, dirname } from 'path';
+import { chatWithTools } from './ollama.js';
 
 const execAsync = promisify(exec);
 
@@ -29,23 +30,23 @@ export const RUN_TERMINAL_COMMAND_TOOL = {
 };
 
 /** 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").',
-        },
-      },
-    },
-  },
-};
+// 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").',
+//         },
+//       },
+//     },
+//   },
+// };
 
 /** Ollama-format tool definition for reading a file */
 export const READ_FILE_TOOL = {
@@ -66,7 +67,7 @@ export const READ_FILE_TOOL = {
   },
 };
 
-/** Ollama-format tool definition for writing or overwriting a file */
+/* WRITE_FILE_TOOL disabled: model uses run_terminal_command for file creation/overwrite
 export const WRITE_FILE_TOOL = {
   type: 'function',
   function: {
@@ -88,6 +89,7 @@ export const WRITE_FILE_TOOL = {
     },
   },
 };
+*/
 
 /** Ollama-format tool definition for search-and-replace in a file */
 export const SEARCH_REPLACE_TOOL = {
@@ -117,37 +119,83 @@ export const SEARCH_REPLACE_TOOL = {
 };
 
 /** Ollama-format tool definition for deleting a file */
-export const DELETE_FILE_TOOL = {
+// export const DELETE_FILE_TOOL = {
+//   type: 'function',
+//   function: {
+//     name: 'delete_file',
+//     description: 'Delete a file. Does not remove directories.',
+//     parameters: {
+//       type: 'object',
+//       required: ['path'],
+//       properties: {
+//         path: {
+//           type: 'string',
+//           description: 'Relative path to the file to delete.',
+//         },
+//       },
+//     },
+//   },
+// };
+
+/** Ollama-format tool definition for listing directory contents */
+// export const LIST_DIR_TOOL = {
+//   type: 'function',
+//   function: {
+//     name: 'list_dir',
+//     description: 'List files and folders in a directory. Use to discover paths before reading or editing.',
+//     parameters: {
+//       type: 'object',
+//       required: [],
+//       properties: {
+//         path: {
+//           type: 'string',
+//           description: 'Relative path to the directory (default "." for current directory).',
+//         },
+//       },
+//     },
+//   },
+// };
+
+/** Ollama-format tool definition for web search */
+export const WEB_SEARCH_TOOL = {
   type: 'function',
   function: {
-    name: 'delete_file',
-    description: 'Delete a file. Does not remove directories.',
+    name: 'web_search',
+    description: 'Search the web for current information. Use when the user asks about recent events, documentation, or facts that may require up-to-date or external sources.',
     parameters: {
       type: 'object',
-      required: ['path'],
+      required: ['query'],
       properties: {
-        path: {
+        query: {
           type: 'string',
-          description: 'Relative path to the file to delete.',
+          description: 'Search query (e.g. "Node.js 20 release date", "React useEffect docs").',
+        },
+        num_results: {
+          type: 'number',
+          description: 'Maximum number of results to return (default 5).',
         },
       },
     },
   },
 };
 
-/** Ollama-format tool definition for listing directory contents */
-export const LIST_DIR_TOOL = {
+/** Ollama-format tool definition for delegating a task to a fast 0.8b subagent */
+export const CREATE_SUBAGENT_TOOL = {
   type: 'function',
   function: {
-    name: 'list_dir',
-    description: 'List files and folders in a directory. Use to discover paths before reading or editing.',
+    name: 'create_subagent',
+    description: 'Delegate a focused, self-contained task to a fast 0.8b model. Use for isolated sub-tasks like summarizing text, generating a regex, writing a small helper function, or answering a specific question. The subagent has no tools and no prior conversation context — pass everything it needs in task/context. Its response is returned directly to you.',
     parameters: {
       type: 'object',
-      required: [],
+      required: ['task'],
       properties: {
-        path: {
+        task: {
+          type: 'string',
+          description: 'The specific task or question for the subagent to complete (be precise and self-contained).',
+        },
+        context: {
           type: 'string',
-          description: 'Relative path to the directory (default "." for current directory).',
+          description: 'Optional extra context the subagent needs (e.g. a file snippet, a schema, relevant background). Keep it concise.',
         },
       },
     },
@@ -157,12 +205,14 @@ export const LIST_DIR_TOOL = {
 /** Tools array for agent loop (chatWithTools). */
 export const AGENT_TOOLS = [
   RUN_TERMINAL_COMMAND_TOOL,
-  CREATE_FOLDER_TOOL,
+  // CREATE_FOLDER_TOOL,
   READ_FILE_TOOL,
-  WRITE_FILE_TOOL,
+  // WRITE_FILE_TOOL, // disabled: model uses run_terminal_command for file creation/overwrite
   SEARCH_REPLACE_TOOL,
-  DELETE_FILE_TOOL,
-  LIST_DIR_TOOL,
+  // DELETE_FILE_TOOL,
+  // LIST_DIR_TOOL,
+  WEB_SEARCH_TOOL,
+  CREATE_SUBAGENT_TOOL,
 ];
 
 function getPath(args, opts) {
@@ -199,6 +249,7 @@ const TOOLS_MAP = {
       return { error: err.message };
     }
   },
+  /* write_file disabled: model uses run_terminal_command for file creation/overwrite
   write_file: async (args, opts = {}) => {
     const { path: relPath, absPath } = getPath(args, opts);
     const content = typeof args.content === 'string' ? args.content : String(args?.content ?? '');
@@ -211,6 +262,7 @@ const TOOLS_MAP = {
       return { success: false, error: err.message };
     }
   },
+  */
   search_replace: async (args, opts = {}) => {
     const { path: relPath, absPath } = getPath(args, opts);
     const oldStr = typeof args.old_string === 'string' ? args.old_string : String(args?.old_string ?? '');
@@ -287,6 +339,70 @@ const TOOLS_MAP = {
       return { stdout, stderr, exitCode };
     }
   },
+  web_search: async (args) => {
+    const apiKey = '763399c40c6e5025305aff6f12bbff36152c0830';
+    if (!apiKey || !apiKey.trim()) {
+      return { error: 'Web search not configured. Set MARKOV_SEARCH_API_KEY.' };
+    }
+    const query = typeof args.query === 'string' ? args.query.trim() : String(args?.query ?? '').trim();
+    if (!query) {
+      return { error: 'Query is required for web_search.' };
+    }
+    const numResults = Math.min(10, Math.max(1, parseInt(args?.num_results, 10) || 5));
+    try {
+      const res = await fetch('https://google.serper.dev/search', {
+        method: 'POST',
+        headers: {
+          'X-API-KEY': apiKey,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ q: query, num: numResults }),
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        return { error: `Search API error ${res.status}: ${text.slice(0, 200)}` };
+      }
+      const data = await res.json();
+      const organic = data?.organic ?? [];
+      const results = organic.slice(0, numResults).map((item) => ({
+        title: item.title ?? '',
+        link: item.link ?? item.url ?? '',
+        snippet: item.snippet ?? '',
+      }));
+      return { results, query };
+    } catch (err) {
+      return { error: err?.message ?? 'Web search request failed.' };
+    }
+  },
+  create_subagent: async (args) => {
+    const task = typeof args.task === 'string' ? args.task.trim() : '';
+    const context = typeof args.context === 'string' ? args.context.trim() : '';
+    if (!task) return { error: 'task is required for create_subagent' };
+
+    const messages = [
+      {
+        role: 'system',
+        content: 'You are a focused AI subagent. Complete the assigned task concisely and return only the result. No preamble.',
+      },
+      {
+        role: 'user',
+        content: context ? `Context:\n${context}\n\nTask: ${task}` : task,
+      },
+    ];
+
+    try {
+      const data = await chatWithTools(messages, [RUN_TERMINAL_COMMAND_TOOL], 'qwen3.5:0.8b', null, 'ollama');
+      // Backend returns raw JSON; Claude path returns { message: { content } }
+      const content =
+        data?.message?.content ??
+        data?.choices?.[0]?.message?.content ??
+        data?.content ??
+        '';
+      return { result: content, model: 'qwen3.5:0.8b' };
+    } catch (err) {
+      return { error: err.message ?? 'Subagent call failed' };
+    }
+  },
 };
 
 /**

package/src/ui/formatting.js

@@ -0,0 +1,125 @@
+import chalk from 'chalk';
+
+const TERM_WIDTH = 80;
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const visLen = (s) => s.replace(ANSI_RE, '').length;
+
+/** Print token usage when the provider returns it (OpenAI or Anthropic shape). */
+export function printTokenUsage(usage) {
+  if (!usage) return;
+  // OpenAI: prompt_tokens, completion_tokens, total_tokens
+  if (typeof usage.prompt_tokens === 'number' && typeof usage.completion_tokens === 'number') {
+    const total = usage.total_tokens ?? usage.prompt_tokens + usage.completion_tokens;
+    console.log(chalk.dim(`Tokens: prompt ${usage.prompt_tokens}, completion ${usage.completion_tokens}, total ${total}`));
+    return;
+  }
+  // Anthropic: input_tokens, output_tokens
+  if (typeof usage.input_tokens === 'number' && typeof usage.output_tokens === 'number') {
+    const total = usage.input_tokens + usage.output_tokens;
+    console.log(chalk.dim(`Tokens: input ${usage.input_tokens}, output ${usage.output_tokens}, total ${total}`));
+  }
+}
+
+/** Word-wrap plain text to a given column width, preserving existing newlines. */
+export 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');
+}
+
+/** Parse fenced code blocks (```lang\n...\n```) and render them with plain styling. Non-code segments are wrapped. */
+export function formatResponseWithCodeBlocks(text, width) {
+  if (!text || typeof text !== 'string') return '';
+  const re = /```(\w*)\n([\s\S]*?)```/g;
+  const parts = [];
+  let lastIndex = 0;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    if (m.index > lastIndex) {
+      const textSegment = text.slice(lastIndex, m.index);
+      if (textSegment) parts.push({ type: 'text', content: textSegment });
+    }
+    parts.push({ type: 'code', lang: m[1], content: m[2].trim() });
+    lastIndex = re.lastIndex;
+  }
+  if (lastIndex < text.length) {
+    const textSegment = text.slice(lastIndex);
+    if (textSegment) parts.push({ type: 'text', content: textSegment });
+  }
+  if (parts.length === 0) return wrapText(text, width);
+  return parts.map((p) => {
+    if (p.type === 'text') return wrapText(p.content, width);
+    const label = p.lang ? p.lang : 'code';
+    const header = chalk.dim('─── ') + chalk.cyan(label) + chalk.dim(' ' + '─'.repeat(Math.max(0, width - label.length - 5)));
+    const code = p.content.split('\n').map(l => chalk.dim('  ') + l).join('\n');
+    return header + '\n' + code + '\n' + chalk.dim('─'.repeat(width));
+  }).join('\n\n');
+}
+
+/** Preview of a file edit for confirmation (search_replace) */
+export function formatFileEditPreview(name, args) {
+  const path = args?.path ?? '(no path)';
+  if (name === 'search_replace') {
+    const oldStr = String(args?.old_string ?? '');
+    const newStr = String(args?.new_string ?? '');
+    const max = 120;
+    const oldPreview = oldStr.length > max ? oldStr.slice(0, max) + '…' : oldStr;
+    const newPreview = newStr.length > max ? newStr.slice(0, max) + '…' : newStr;
+    return (
+      chalk.cyan(path) + '\n' +
+      chalk.red('  - ' + (oldPreview || '(empty)').replace(/\n/g, '\n    ')) + '\n' +
+      chalk.green('  + ' + (newPreview || '(empty)').replace(/\n/g, '\n    '))
+    );
+  }
+  return path;
+}
+
+/** One-line summary of tool args for display */
+export function formatToolCallSummary(name, args) {
+  const a = args ?? {};
+  if (name === 'run_terminal_command') return (a.command ?? '').trim() || '(empty)';
+  if (name === 'search_replace') return (a.path ?? '') + (a.old_string ? ` "${String(a.old_string).slice(0, 30)}…"` : '');
+  if (name === 'read_file' || name === 'delete_file') return a.path ?? '(no path)';
+  if (name === 'create_folder') return a.path ?? '(no path)';
+  if (name === 'list_dir') return (a.path ?? '.') || '.';
+  if (name === 'web_search') return (a.query ?? '').trim() || '(empty query)';
+  return JSON.stringify(a).slice(0, 50);
+}
+
+/** One-line summary of tool result for display */
+export function formatToolResultSummary(name, resultJson) {
+  let obj;
+  try {
+    obj = typeof resultJson === 'string' ? JSON.parse(resultJson) : resultJson;
+  } catch {
+    return resultJson?.slice(0, 60) ?? '—';
+  }
+  if (obj.error) return chalk.red('✗ ' + obj.error);
+  if (obj.declined) return chalk.yellow('✗ declined');
+  if (name === 'run_terminal_command') {
+    const code = obj.exitCode ?? obj.exit_code;
+    if (code === 0) return chalk.green('✓ exit 0') + (obj.stdout ? chalk.dim('  ' + String(obj.stdout).trim().slice(0, 80).replace(/\n/g, ' ')) : '');
+    return chalk.red(`✗ exit ${code}`) + (obj.stderr ? chalk.dim('  ' + String(obj.stderr).trim().slice(0, 80)) : '');
+  }
+  if (name === 'search_replace' || name === 'delete_file' || name === 'create_folder') {
+    return obj.success !== false ? chalk.green('✓ ' + (obj.path ? obj.path : 'ok')) : chalk.red('✗ ' + (obj.error || 'failed'));
+  }
+  if (name === 'read_file') return obj.content != null ? chalk.green('✓ ' + (obj.path ?? '') + chalk.dim(` (${String(obj.content).length} chars)`)) : chalk.red('✗ ' + (obj.error || ''));
+  if (name === 'list_dir') return obj.entries ? chalk.green('✓ ' + (obj.entries.length ?? 0) + ' entries') : chalk.red('✗ ' + (obj.error || ''));
+  if (name === 'web_search') return obj.error ? chalk.red('✗ ' + obj.error) : (obj.results ? chalk.green('✓ ' + (obj.results.length ?? 0) + ' results') : chalk.dim('—'));
+  return chalk.dim(JSON.stringify(obj).slice(0, 60));
+}

package/src/ui/prompts.js

@@ -0,0 +1,116 @@
+import chalk from 'chalk';
+
+/** Arrow-key selector. Returns the chosen string or null if cancelled. */
+export function selectFrom(options, label) {
+  return new Promise((resolve) => {
+    let idx = 0;
+
+    const draw = () => {
+      process.stdout.write('\r\x1b[0J');
+      process.stdout.write(chalk.dim(label) + '\n');
+      options.forEach((o, i) => {
+        process.stdout.write(
+          i === idx
+            ? '  ' + chalk.bgCyan.black(` ${o} `) + '\n'
+            : '  ' + chalk.dim(o) + '\n'
+        );
+      });
+      // Move cursor back up to keep it stable
+      process.stdout.write(`\x1b[${options.length + 1}A`);
+    };
+
+    const cleanup = () => {
+      process.stdin.removeListener('data', onKey);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      // Clear the drawn lines
+      process.stdout.write('\r\x1b[0J');
+    };
+
+    const onKey = (data) => {
+      const key = data.toString();
+      if (key === '\x1b[A') { idx = (idx - 1 + options.length) % options.length; draw(); return; }
+      if (key === '\x1b[B') { idx = (idx + 1) % options.length; draw(); return; }
+      if (key === '\r' || key === '\n') { cleanup(); resolve(options[idx]); return; }
+      if (key === '\x03' || key === '\x11') { cleanup(); resolve(null); return; }
+    };
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', onKey);
+    draw();
+  });
+}
+
+/** Prompt y/n in raw mode, returns true for y/Y. */
+export function confirm(question) {
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    const onKey = (key) => {
+      process.stdin.removeListener('data', onKey);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      const answer = key.toLowerCase() === 'y';
+      process.stdout.write(answer ? chalk.green('y\n') : chalk.dim('n\n'));
+      resolve(answer);
+    };
+    process.stdin.on('data', onKey);
+  });
+}
+
+/** Read a visible line of input. */
+export function promptLine(label) {
+  return new Promise((resolve) => {
+    process.stdout.write(label);
+    let buf = '';
+    const onData = (data) => {
+      const key = data.toString();
+      if (key === '\r' || key === '\n') {
+        process.stdin.removeListener('data', onData);
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdout.write('\n');
+        resolve(buf);
+      } else if (key === '\x7f' || key === '\b') {
+        if (buf.length > 0) { buf = buf.slice(0, -1); process.stdout.write('\b \b'); }
+      } else if (key >= ' ') {
+        buf += key;
+        process.stdout.write(key);
+      }
+    };
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', onData);
+  });
+}
+
+/** Read a line of input without echo (for passwords). */
+export function promptSecret(label) {
+  return new Promise((resolve) => {
+    process.stdout.write(label);
+    let buf = '';
+    const onData = (data) => {
+      const key = data.toString();
+      if (key === '\r' || key === '\n') {
+        process.stdin.removeListener('data', onData);
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdout.write('\n');
+        resolve(buf);
+      } else if (key === '\x7f' || key === '\b') {
+        if (buf.length > 0) buf = buf.slice(0, -1);
+      } else if (key >= ' ') {
+        buf += key;
+      }
+    };
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', onData);
+  });
+}

package/src/ui/spinner.js

@@ -0,0 +1,40 @@
+import chalk from 'chalk';
+import gradient from 'gradient-string';
+
+const agentGradient = gradient(['#22c55e', '#16a34a', '#4ade80']);
+
+/**
+ * Create a spinner with a given label.
+ * Returns an object with a stop() method.
+ * @param {string} label - The label to display before the spinner
+ * @returns {{ stop: () => void }} A spinner handle with a stop() method
+ */
+export function createSpinner(label) {
+  const DOTS = ['.', '..', '...'];
+  let dotIdx = 0;
+  let interval = null;
+  const startTime = Date.now();
+
+  const start = () => {
+    if (interval) clearInterval(interval);
+    dotIdx = 0;
+    process.stdout.write(chalk.dim(`\n${label}`));
+    interval = setInterval(() => {
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      process.stdout.write('\r' + chalk.dim(label) + chalk.dim(elapsed + 's ') + agentGradient(DOTS[dotIdx % DOTS.length]) + '   ');
+      dotIdx++;
+    }, 400);
+  };
+
+  const stop = () => {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    process.stdout.write('\r\x1b[0J');
+  };
+
+  start();
+
+  return { stop };
+}