@cosmicstack/mercury-agent 0.5.1 → 0.5.2

package/README.md

@@ -235,4 +235,4 @@ MIT © [Cosmic Stack](https://github.com/cosmicstack-labs)
 
 ## Suggestions and Contributions
 
-For suggestions, contributions, or any inquiries, please reach out to us at [support@cosmicstack.org](mailto:support@cosmicstack.org).
+For suggestions, contributions, or any inquiries, please reach out to us at [mercury@cosmicstack.org](mailto:mercury@cosmicstack.org).

package/dist/index.js

@@ -916,9 +916,34 @@ var BaseChannel = class {
 import { Marked } from "marked";
 import chalk from "chalk";
 var lexer = new Marked();
+var HTML_ENTITIES = {
+  "&": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'",
+  "&apos;": "'",
+  "&nbsp;": " "
+};
+function decodeHtmlEntities(text) {
+  return text.replace(/&(?:#[xX]?[0-9a-fA-F]+|[a-zA-Z]+);/g, (match) => {
+    if (HTML_ENTITIES[match]) return HTML_ENTITIES[match];
+    if (match.startsWith("&#x") || match.startsWith("&#X")) {
+      const code = parseInt(match.slice(3, -1), 16);
+      return isNaN(code) ? match : String.fromCodePoint(code);
+    }
+    if (match.startsWith("&#")) {
+      const code = parseInt(match.slice(2, -1), 10);
+      return isNaN(code) ? match : String.fromCodePoint(code);
+    }
+    return match;
+  });
+}
 function renderMarkdown(text) {
   try {
-    const tokens = lexer.lexer(text);
+    const decoded = decodeHtmlEntities(text);
+    const tokens = lexer.lexer(decoded);
     const result = renderTokens(tokens);
     return result.replace(/\n{3,}/g, "\n\n").trimEnd();
   } catch {
@@ -1106,6 +1131,67 @@ function mdToTelegram(text) {
   return out;
 }
 
+// src/utils/tool-label.ts
+var TOOL_LABELS = {
+  fetch_url: { icon: "\u2197", label: "Fetching", argKey: "url", argTransform: extractDomain },
+  read_file: { icon: "\u{1F4C4}", label: "Reading", argKey: "path", argTransform: basename },
+  write_file: { icon: "\u270F\uFE0F", label: "Writing", argKey: "path", argTransform: basename },
+  create_file: { icon: "\u2728", label: "Creating", argKey: "path", argTransform: basename },
+  edit_file: { icon: "\u2702\uFE0F", label: "Editing", argKey: "path", argTransform: basename },
+  delete_file: { icon: "\u{1F5D1}", label: "Deleting", argKey: "path", argTransform: basename },
+  list_dir: { icon: "\u{1F4C2}", label: "Listing", argKey: "path", argTransform: basename },
+  approve_scope: { icon: "\u{1F513}", label: "Approving scope" },
+  run_command: { icon: "\u2328", label: "Running command", argKey: "command", argTransform: truncate(40) },
+  cd: { icon: "\u{1F4C2}", label: "Changing dir to", argKey: "path" },
+  approve_command: { icon: "\u2705", label: "Approving command" },
+  send_message: { icon: "\u{1F4AC}", label: "Sending message" },
+  send_file: { icon: "\u{1F4CE}", label: "Sending file", argKey: "path", argTransform: basename },
+  git_status: { icon: "\u{1F4CA}", label: "Git status" },
+  git_diff: { icon: "\u{1F4DD}", label: "Git diff" },
+  git_log: { icon: "\u{1F4CB}", label: "Git log" },
+  git_add: { icon: "\u2795", label: "Staging files" },
+  git_commit: { icon: "\u{1F4BE}", label: "Committing" },
+  git_push: { icon: "\u2B06", label: "Pushing" },
+  create_pr: { icon: "\u{1F500}", label: "Creating PR" },
+  review_pr: { icon: "\u{1F440}", label: "Reviewing PR" },
+  list_issues: { icon: "\u{1F4CB}", label: "Listing issues" },
+  create_issue: { icon: "\u{1F41B}", label: "Creating issue" },
+  github_api: { icon: "\u{1F500}", label: "GitHub API", argKey: "path", argTransform: truncate(30) },
+  schedule_task: { icon: "\u23F0", label: "Scheduling task" },
+  cancel_task: { icon: "\u274C", label: "Cancelling task" },
+  list_tasks: { icon: "\u{1F4CB}", label: "Listing tasks" },
+  use_skill: { icon: "\u{1F9E0}", label: "Using skill", argKey: "name" },
+  list_skills: { icon: "\u{1F4CB}", label: "Listing skills" },
+  install_skill: { icon: "\u{1F4E5}", label: "Installing skill" },
+  budget_status: { icon: "\u{1F4B0}", label: "Budget status" }
+};
+function extractDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+}
+function basename(p) {
+  const parts = p.replace(/\\/g, "/").split("/");
+  return parts[parts.length - 1] || p;
+}
+function truncate(maxLen) {
+  return (v) => v.length > maxLen ? v.slice(0, maxLen) + "\u2026" : v;
+}
+function formatToolStep(toolName, args) {
+  const config = TOOL_LABELS[toolName];
+  if (!config) {
+    return toolName;
+  }
+  let detail = "";
+  if (config.argKey && args[config.argKey] !== void 0) {
+    const raw = String(args[config.argKey]);
+    detail = config.argTransform ? config.argTransform(raw) : raw;
+  }
+  return detail ? `${config.icon} ${config.label} ${detail}` : `${config.icon} ${config.label}`;
+}
+
 // src/utils/arrow-select.ts
 import readline from "readline";
 import chalk2 from "chalk";
@@ -1226,6 +1312,12 @@ async function selectWithArrowKeys(title, options, config = {}) {
 }
 
 // src/channels/cli.ts
+var USER_PROMPT = "  You: ";
+var USER_PROMPT_VISIBLE_LEN = USER_PROMPT.length;
+function agentPrefix(name, suffix) {
+  const time = suffix ?? "";
+  return chalk3.cyan(`  ${name}:`) + time;
+}
 var CLIChannel = class extends BaseChannel {
   type = "cli";
   rl = null;
@@ -1233,6 +1325,9 @@ var CLIChannel = class extends BaseChannel {
   menuDepth = 0;
   menuAbortController = null;
   outputInProgress = 0;
+  streamActive = false;
+  streamToolLines = 0;
+  lastUserInput = "";
   constructor(agentName = "Mercury") {
     super();
     this.agentName = agentName;
@@ -1243,16 +1338,17 @@ var CLIChannel = class extends BaseChannel {
   async start() {
     this.createInterface();
     this.ready = true;
-    this.showPrompt();
     logger.info("CLI channel started");
   }
   createInterface() {
     this.rl = readline2.createInterface({
       input: process.stdin,
-      output: process.stdout,
-      prompt: "  You: "
+      output: process.stdout
     });
+    this.rl.setPrompt(chalk3.yellow(USER_PROMPT));
+    this.rl._promptLength = USER_PROMPT_VISIBLE_LEN;
     this.rl.on("line", (line) => {
+      this.lastUserInput = line.trim();
       const trimmed = line.trim();
       if (!trimmed) {
         this.showPrompt();
@@ -1279,9 +1375,9 @@ var CLIChannel = class extends BaseChannel {
     this.beginOutput();
     const timeStr = elapsedMs != null ? chalk3.dim(` (${(elapsedMs / 1e3).toFixed(1)}s)`) : "";
     const rendered = renderMarkdown(content);
+    const indented = this.indent(rendered);
     console.log("");
-    console.log(chalk3.cyan(`  ${this.agentName}:`) + timeStr);
-    const indented = rendered.split("\n").map((line) => `  ${line}`).join("\n");
+    console.log(agentPrefix(this.agentName, timeStr));
     console.log(indented);
     console.log("");
     this.endOutput();
@@ -1298,23 +1394,69 @@ var CLIChannel = class extends BaseChannel {
     const stat = fs.statSync(resolved);
     const sizeStr = stat.size > 1024 * 1024 ? `${(stat.size / (1024 * 1024)).toFixed(1)}MB` : stat.size > 1024 ? `${(stat.size / 1024).toFixed(1)}KB` : `${stat.size}B`;
     console.log("");
-    console.log(chalk3.cyan(`  ${this.agentName}:`) + chalk3.dim(" (file)"));
+    console.log(agentPrefix(this.agentName, chalk3.dim(" (file)")));
     console.log(chalk3.dim(`  path: ${resolved}`));
     console.log(chalk3.dim(`  size: ${sizeStr}`));
     console.log("");
     this.endOutput();
   }
+  async sendToolFeedback(toolName, args) {
+    const label = formatToolStep(toolName, args);
+    if (this.streamActive) {
+      this.streamToolLines++;
+      process.stdout.write(chalk3.dim(`
+  ${label}
+`));
+    } else {
+      console.log(chalk3.dim(`  ${label}`));
+    }
+  }
   async stream(content, _targetId) {
     this.closeActiveMenu();
     this.beginOutput();
-    console.log("");
-    process.stdout.write(chalk3.cyan(`  ${this.agentName}: `));
+    this.streamActive = true;
+    this.streamToolLines = 0;
+    if (!process.stdout.isTTY) {
+      process.stdout.write(chalk3.cyan(`  ${this.agentName}: `));
+      let full2 = "";
+      for await (const chunk of content) {
+        process.stdout.write(chunk);
+        full2 += chunk;
+      }
+      this.streamActive = false;
+      console.log("\n");
+      this.endOutput();
+      return full2;
+    }
+    console.log(chalk3.cyan(`  ${this.agentName}:`));
     let full = "";
     for await (const chunk of content) {
       process.stdout.write(chunk);
       full += chunk;
     }
-    console.log("\n");
+    this.streamActive = false;
+    if (!full.trim()) {
+      console.log("");
+      this.endOutput();
+      return full;
+    }
+    const termWidth = process.stdout.columns || 80;
+    let textLineCount = 0;
+    for (const line of full.split("\n")) {
+      const visualLen = line.replace(/\x1b\[[0-9;]*m/g, "").length;
+      textLineCount += Math.max(1, Math.ceil((visualLen + 2) / termWidth));
+    }
+    const totalLines = 1 + textLineCount + this.streamToolLines;
+    process.stdout.write(`\x1B[${totalLines}A`);
+    for (let i = 0; i < totalLines; i++) {
+      process.stdout.write("\x1B[2K\x1B[1B");
+    }
+    process.stdout.write(`\x1B[${totalLines}A`);
+    const rendered = renderMarkdown(full);
+    const indented = this.indent(rendered);
+    console.log(agentPrefix(this.agentName));
+    console.log(indented);
+    console.log("");
     this.endOutput();
     return full;
   }
@@ -1323,8 +1465,8 @@ var CLIChannel = class extends BaseChannel {
   }
   showPrompt() {
     if (this.rl) {
-      this.rl.setPrompt("  You: ");
-      this.rl.prompt();
+      process.stdout.write("\x1B[2K\r");
+      process.stdout.write(chalk3.yellow(USER_PROMPT));
     }
   }
   async withMenu(runner) {
@@ -1377,6 +1519,9 @@ var CLIChannel = class extends BaseChannel {
     if (!this.ready || this.rl) return;
     this.createInterface();
   }
+  indent(text) {
+    return text.split("\n").map((line) => `  ${line}`).join("\n");
+  }
   async prompt(question) {
     return new Promise((resolve13) => {
       this.rl?.question(question, (answer) => resolve13(answer.trim()));
@@ -1391,13 +1536,37 @@ var CLIChannel = class extends BaseChannel {
       });
     });
   }
+  async askToContinue(question, _targetId) {
+    return new Promise((resolve13) => {
+      console.log("");
+      console.log(chalk3.yellow(`  \u26A0 ${question}`));
+      this.rl?.question(chalk3.yellow("  Continue? [y/N] "), (answer) => {
+        const val = answer.trim().toLowerCase();
+        resolve13(val === "y" || val === "yes");
+      });
+    });
+  }
 };
 
 // src/core/agent.ts
-var ToolCallLoopDetector = class {
+var ToolCallLoopDetector = class _ToolCallLoopDetector {
   recentCalls = [];
-  maxEntries = 16;
-  aborted = false;
+  maxEntries = 20;
+  hardAborted = false;
+  static HIGH_TOLERANCE_TOOLS = /* @__PURE__ */ new Set([
+    "fetch_url",
+    "read_file",
+    "list_dir",
+    "web_search",
+    "github_api",
+    "run_command"
+  ]);
+  static getIdenticalThreshold() {
+    return 3;
+  }
+  static getSameToolThreshold(toolName) {
+    return _ToolCallLoopDetector.HIGH_TOLERANCE_TOOLS.has(toolName) ? 6 : 4;
+  }
   record(toolName, params) {
     const paramsKey = JSON.stringify(params).slice(0, 100);
     this.recentCalls.push({ tool: toolName, params: paramsKey });
@@ -1405,7 +1574,7 @@ var ToolCallLoopDetector = class {
       this.recentCalls.shift();
     }
   }
-  detect() {
+  detectIdentical() {
     if (this.recentCalls.length < 3) return null;
     const last = this.recentCalls[this.recentCalls.length - 1];
     let identicalCount = 0;
@@ -1416,39 +1585,42 @@ var ToolCallLoopDetector = class {
         break;
       }
     }
-    if (identicalCount >= 3) {
-      this.aborted = true;
+    if (identicalCount >= _ToolCallLoopDetector.getIdenticalThreshold()) {
+      this.hardAborted = true;
       return {
         tool: last.tool,
         count: identicalCount,
-        message: `You called "${last.tool}" ${identicalCount} times with identical parameters and got the same result. Stop repeating this call entirely.`
+        message: `[SYSTEM] You called "${last.tool}" ${identicalCount} times with identical parameters and got the same result. This is a hard loop \u2014 stop immediately.`
       };
     }
-    const lastTool = last.tool;
+    return null;
+  }
+  detectSameTool() {
+    if (this.recentCalls.length < 4) return null;
+    const last = this.recentCalls[this.recentCalls.length - 1];
     let sameToolCount = 0;
     for (let i = this.recentCalls.length - 1; i >= 0; i--) {
-      if (this.recentCalls[i].tool === lastTool) {
+      if (this.recentCalls[i].tool === last.tool) {
         sameToolCount++;
       } else {
         break;
       }
     }
-    if (sameToolCount >= 3) {
-      this.aborted = true;
+    const threshold = _ToolCallLoopDetector.getSameToolThreshold(last.tool);
+    if (sameToolCount >= threshold) {
       return {
-        tool: lastTool,
-        count: sameToolCount,
-        message: `You called "${lastTool}" ${sameToolCount} times in a row with slightly different parameters and it isn't working. Stop \u2014 the approach is wrong. Step back, tell the user what you tried and what failed, and suggest alternatives instead of retrying.`
+        tool: last.tool,
+        count: sameToolCount
       };
     }
     return null;
   }
-  isAborted() {
-    return this.aborted;
+  isHardAborted() {
+    return this.hardAborted;
   }
   reset() {
     this.recentCalls = [];
-    this.aborted = false;
+    this.hardAborted = false;
   }
 };
 var MAX_STEPS = 10;
@@ -1612,30 +1784,6 @@ You can override this:
       const recentMemory = this.shortTerm.getRecent(msg.channelId, 10);
       const relevantFacts = this.longTerm.search(msg.content, 3);
       const messages = [];
-      const recentSteps = this.shortTerm.getRecent(msg.channelId, 4);
-      let loopWarning = null;
-      if (recentSteps.length >= 3) {
-        const toolCallPattern = /\[Using: (.+?)\]/g;
-        const toolCalls = [];
-        for (const m of recentSteps) {
-          if (m.role === "assistant") {
-            let match;
-            while ((match = toolCallPattern.exec(m.content)) !== null) {
-              toolCalls.push(match[1]);
-            }
-          }
-        }
-        if (toolCalls.length >= 3) {
-          const last3 = toolCalls.slice(-3);
-          if (last3[0] === last3[1] && last3[1] === last3[2]) {
-            loopWarning = `[SYSTEM WARNING] In previous turns you called ${last3[0]} repeatedly. Do NOT call it again. If something failed, explain the failure to the user and suggest alternatives.`;
-          }
-        }
-      }
-      if (loopWarning) {
-        messages.push({ role: "user", content: loopWarning });
-        messages.push({ role: "assistant", content: "Understood. I will try a different approach." });
-      }
       if (relevantFacts.length > 0) {
         messages.push({
           role: "user",
@@ -1687,18 +1835,44 @@ You can override this:
                   for (const tc of toolCalls) {
                     loopDetector.record(tc.toolName, tc.args);
                   }
-                  const loop = loopDetector.detect();
-                  if (loop) {
-                    logger.warn({ tool: loop.tool, count: loop.count }, "Tool call loop detected \u2014 aborting generation");
+                  if (toolCalls.some((tc) => tc.toolName === "use_skill")) {
+                    loopDetector.reset();
+                  }
+                  const hardLoop = loopDetector.detectIdentical();
+                  if (hardLoop) {
+                    logger.warn({ tool: hardLoop.tool, count: hardLoop.count }, "Hard loop detected \u2014 aborting");
                     if (!loopWarningSent && channel && msg.channelType !== "internal") {
                       loopWarningSent = true;
-                      await channel.send(`\u26A0 Loop detected \u2014 ${loop.tool} called ${loop.count}x in a row. Stopping to save tokens.`, msg.channelId).catch(() => {
+                      await channel.send(`\u26A0 Repeated call detected \u2014 ${hardLoop.tool} called ${hardLoop.count}x with same params. Stopping.`, msg.channelId).catch(() => {
                       });
                     }
                     loopAbortController.abort();
                   }
-                  await channel.send(`  [Using: ${names}]`, msg.channelId).catch(() => {
-                  });
+                  const softLoop = loopDetector.detectSameTool();
+                  if (softLoop && !loopWarningSent && channel && msg.channelType !== "internal") {
+                    loopWarningSent = true;
+                    const shouldContinue = await channel.askToContinue(
+                      `${softLoop.tool} has been called ${softLoop.count}x in a row. This might be a loop.`,
+                      msg.channelId
+                    ).catch(() => false);
+                    if (shouldContinue) {
+                      loopDetector.reset();
+                      loopWarningSent = false;
+                    } else {
+                      loopAbortController.abort();
+                    }
+                  }
+                  if (channel && msg.channelType !== "internal") {
+                    if (channel instanceof CLIChannel) {
+                      for (const tc of toolCalls) {
+                        await channel.sendToolFeedback(tc.toolName, tc.args).catch(() => {
+                        });
+                      }
+                    } else {
+                      await channel.send(`  [Using: ${names}]`, msg.channelId).catch(() => {
+                      });
+                    }
+                  }
                 }
               }
             });
@@ -1738,19 +1912,43 @@ You can override this:
                   for (const tc of toolCalls) {
                     loopDetector.record(tc.toolName, tc.args);
                   }
-                  const loop = loopDetector.detect();
-                  if (loop) {
-                    logger.warn({ tool: loop.tool, count: loop.count }, "Tool call loop detected \u2014 aborting generation");
+                  if (toolCalls.some((tc) => tc.toolName === "use_skill")) {
+                    loopDetector.reset();
+                  }
+                  const hardLoop = loopDetector.detectIdentical();
+                  if (hardLoop) {
+                    logger.warn({ tool: hardLoop.tool, count: hardLoop.count }, "Hard loop detected \u2014 aborting");
                     if (!loopWarningSent && channel && msg.channelType !== "internal") {
                       loopWarningSent = true;
-                      await channel.send(`\u26A0 Loop detected \u2014 ${loop.tool} called ${loop.count}x in a row. Stopping to save tokens.`, msg.channelId).catch(() => {
+                      await channel.send(`\u26A0 Repeated call detected \u2014 ${hardLoop.tool} called ${hardLoop.count}x with same params. Stopping.`, msg.channelId).catch(() => {
                       });
                     }
                     loopAbortController.abort();
                   }
+                  const softLoop = loopDetector.detectSameTool();
+                  if (softLoop && !loopWarningSent && channel && msg.channelType !== "internal") {
+                    loopWarningSent = true;
+                    const shouldContinue = await channel.askToContinue(
+                      `${softLoop.tool} has been called ${softLoop.count}x in a row. This might be a loop.`,
+                      msg.channelId
+                    ).catch(() => false);
+                    if (shouldContinue) {
+                      loopDetector.reset();
+                      loopWarningSent = false;
+                    } else {
+                      loopAbortController.abort();
+                    }
+                  }
                   if (channel && msg.channelType !== "internal") {
-                    await channel.send(`  [Using: ${names}]`, msg.channelId).catch(() => {
-                    });
+                    if (channel instanceof CLIChannel) {
+                      for (const tc of toolCalls) {
+                        await channel.sendToolFeedback(tc.toolName, tc.args).catch(() => {
+                        });
+                      }
+                    } else {
+                      await channel.send(`  [Using: ${names}]`, msg.channelId).catch(() => {
+                      });
+                    }
                   }
                 }
               }
@@ -1760,11 +1958,14 @@ You can override this:
           this.providers.markSuccess(provider.name);
           break;
         } catch (err) {
-          if (loopDetector.isAborted()) {
+          if (loopDetector.isHardAborted() || loopAbortController.signal.aborted) {
             logger.info("Generation aborted due to loop detection \u2014 using partial response");
             if (!result && streamedText) {
               result = { text: streamedText, usage: void 0 };
             }
+            if (!result) {
+              result = { text: "I stopped because I was repeating the same tool calls. What would you like me to do differently?", usage: void 0 };
+            }
             if (usedProvider) {
               this.providers.markSuccess(usedProvider.name);
             }
@@ -2989,6 +3190,32 @@ var TelegramChannel = class extends BaseChannel {
       }, 12e4);
     });
   }
+  async askToContinue(question, targetId) {
+    const chatIds = this.resolveTargetChatIds(targetId);
+    const chatId = chatIds[0];
+    if (!chatId || !this.bot) return false;
+    const id = `loop_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const keyboard = new InlineKeyboard().text("Continue", `${id}:yes`).text("Stop", `${id}:no`);
+    try {
+      await this.bot.api.sendMessage(chatId, mdToTelegram(question), {
+        parse_mode: "HTML",
+        reply_markup: keyboard
+      });
+    } catch {
+      await this.bot.api.sendMessage(chatId, question, {
+        reply_markup: keyboard
+      });
+    }
+    return new Promise((resolve13) => {
+      this.pendingApprovals.set(`${id}:yes`, () => resolve13(true));
+      this.pendingApprovals.set(`${id}:no`, () => resolve13(false));
+      setTimeout(() => {
+        this.pendingApprovals.delete(`${id}:yes`);
+        this.pendingApprovals.delete(`${id}:no`);
+        resolve13(false);
+      }, 12e4);
+    });
+  }
   async handleAccessRequest(userId, chatId, username, firstName) {
     const approvedUser = findTelegramApprovedUser(this.config, userId);
     if (approvedUser) {
@@ -4003,7 +4230,7 @@ function createEditFileTool(permissions, getCwd) {
 import { tool as tool7 } from "ai";
 import { z as z7 } from "zod";
 import { existsSync as existsSync12, statSync as statSync2 } from "fs";
-import { resolve as resolve9, basename, isAbsolute as isAbsolute7 } from "path";
+import { resolve as resolve9, basename as basename2, isAbsolute as isAbsolute7 } from "path";
 function createSendFileTool(permissions, getCwd, sendFile) {
   return tool7({
     description: "Send a file to the user. On Telegram the file is uploaded as an attachment to the relevant approved recipients. On CLI the file path and size are displayed. The path must be within an allowed read scope.",
@@ -4029,7 +4256,7 @@ function createSendFileTool(permissions, getCwd, sendFile) {
       }
       try {
         await sendFile(resolved);
-        const filename = basename(resolved);
+        const filename = basename2(resolved);
         const sizeStr = stat.size > 1024 * 1024 ? `${(stat.size / (1024 * 1024)).toFixed(1)}MB` : `${Math.round(stat.size / 1024)}KB`;
         return `File sent: ${filename} (${sizeStr})`;
       } catch (err) {
@@ -6851,6 +7078,7 @@ async function runAgent(isDaemon = false) {
     console.log(chalk7.green(`  ${name} is live. Type a message and press Enter.`));
     console.log(chalk7.dim("  Ctrl+C to exit \xB7 /help for commands"));
     console.log("");
+    cliChannel?.showPrompt();
   } else {
     logger.info({ channels: activeCh, tools: toolNames }, "Mercury is live (daemon mode)");
   }