yiyan-browser-agent 1.4.5 → 1.4.7

package/src/parser.js

@@ -0,0 +1,272 @@
+// src/parser.js — Parse Yiyan's text responses to extract tool calls
+'use strict';
+
+/**
+ * Parse a raw Yiyan response string.
+ *
+ * Returns one of:
+ *   { type: 'tool_call', name: string, args: object, raw: string }
+ *   { type: 'final',     content: string,            raw: string }
+ *   { type: 'error',     message: string,            raw: string }
+ */
+function parseResponse(rawText) {
+  const text = stripThinkingBlocks(rawText).trim();
+
+  // ── Strategy 0 (DOM FALLBACK): bare "tool_call\n{ ... }" ─────────────────
+  //
+  //  When the browser markdown renderer converts:
+  //    ```tool_call
+  //    { "name": "write_file", "args": {...} }
+  //    ```
+  //  …into a <pre><code class="language-tool_call"> element, our getFullText()
+  //  now reconstructs the fence.  BUT if that still fails for any reason, this
+  //  strategy catches the raw DOM text which looks like:
+  //
+  //    tool_call
+  //    {
+  //      "name": "write_file",
+  //      "args": { ... }
+  //    }
+  //
+  const bareMatch = text.match(/^tool_call\s*\n([\s\S]+)$/i);
+  if (bareMatch) {
+    const jsonRaw = bareMatch[1].trim();
+    try {
+      const parsed = JSON.parse(jsonRaw);
+      const name   = parsed.name || parsed.tool || parsed.function;
+      const args   = parsed.args || parsed.arguments || parsed.parameters || parsed.input || {};
+      if (name && typeof name === 'string') {
+        return { type: 'tool_call', name, args, raw: rawText };
+      }
+    } catch {
+      const fixed = attemptJsonFix(jsonRaw);
+      if (fixed) {
+        const name = fixed.name || fixed.tool || fixed.function;
+        const args = fixed.args || fixed.arguments || fixed.parameters || fixed.input || {};
+        if (name) return { type: 'tool_call', name, args, raw: rawText };
+      }
+    }
+  }
+
+  // ── Strategy 1 (PRIMARY): ```tool_call fenced code block ─────────────────
+  //  Our primary format — reconstructed by getFullText() from <pre><code>.
+  const fencedMatch = text.match(/```tool_call\s*([\s\S]*?)```/i);
+  if (fencedMatch) {
+    const raw = fencedMatch[1].trim();
+    try {
+      const parsed = JSON.parse(raw);
+      const name   = parsed.name || parsed.tool || parsed.function;
+      const args   = parsed.args || parsed.arguments || parsed.parameters || parsed.input || {};
+      if (name && typeof name === 'string') {
+        return { type: 'tool_call', name, args, raw: rawText };
+      }
+    } catch (e) {
+      const fixed = attemptJsonFix(raw);
+      if (fixed) {
+        const name = fixed.name || fixed.tool || fixed.function;
+        const args = fixed.args || fixed.arguments || fixed.parameters || fixed.input || {};
+        if (name) return { type: 'tool_call', name, args, raw: rawText };
+      }
+      return {
+        type    : 'error',
+        message : 'tool_call block had invalid JSON: ' + e.message + '\nContent: ' + raw.slice(0, 300),
+        raw     : rawText,
+      };
+    }
+  }
+
+  // ── Strategy 2: ```json block with "name"/"tool" key ──────────────────────
+  const jsonFenceMatch = text.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
+  if (jsonFenceMatch) {
+    try {
+      const parsed = JSON.parse(jsonFenceMatch[1]);
+      const name   = parsed.name || parsed.tool || parsed.function;
+      const args   = parsed.args || parsed.arguments || parsed.parameters || parsed.input || {};
+      if (name && typeof name === 'string') {
+        return { type: 'tool_call', name, args, raw: rawText };
+      }
+    } catch {}
+  }
+
+  // ── Strategy 3: XML <tool_call> ───────────────────────────────────────────
+  const xmlMatch = text.match(
+    /<tool_call[^>]*>\s*(?:<name>([\s\S]*?)<\/name>\s*)?(?:<input>([\s\S]*?)<\/input>|<args>([\s\S]*?)<\/args>)\s*<\/tool_call>/i
+  );
+  if (xmlMatch) {
+    const name     = (xmlMatch[1] || '').trim();
+    const inputRaw = stripCodeFences((xmlMatch[2] || xmlMatch[3] || '').trim());
+    if (name) return tryParseToolCall(name, inputRaw, rawText);
+  }
+
+  // ── Strategy 4: XML with angle-brackets stripped by DOM ───────────────────
+  const domStrippedMatch = text.match(
+    /tool_call\s+name\s+([\w_]+)\s*\/name\s+input\s*([\s\S]*?)\s*\/input\s*\/tool_call/i
+  );
+  if (domStrippedMatch) {
+    const name     = domStrippedMatch[1].trim();
+    const inputRaw = stripCodeFences(domStrippedMatch[2].trim());
+    return tryParseToolCall(name, inputRaw, rawText);
+  }
+
+  // ── Strategy 5: Any JSON object with "name" key anywhere in text ──────────
+  //  Uses a greedy match to find the outermost JSON object (not fragments).
+  if (/["'](?:name|tool|function)["']\s*:\s*["'][\w_]+["']/.test(text)) {
+    const jsonObj = extractLargestJsonObject(text);
+    if (jsonObj) {
+      const name = jsonObj.name || jsonObj.tool || jsonObj.function;
+      const args = jsonObj.args || jsonObj.arguments || jsonObj.parameters || jsonObj.input || {};
+      if (name && typeof name === 'string') {
+        return { type: 'tool_call', name, args, raw: rawText };
+      }
+    }
+  }
+
+  // ── Strategy 6: Python-style function call in code block ──────────────────
+  const funcMatch = text.match(/```\w*\s*([\w_]+)\(([^)]*)\)\s*```/);
+  if (funcMatch) {
+    const name    = funcMatch[1];
+    const argsRaw = funcMatch[2];
+    const args    = {};
+    const argRe   = /(\w+)\s*=\s*(?:"([^"]*?)"|'([^']*?)'|(\d+(?:\.\d+)?)|(\btrue\b|\bfalse\b))/g;
+    let   m;
+    while ((m = argRe.exec(argsRaw)) !== null) {
+      const key = m[1];
+      if      (m[2] !== undefined) args[key] = m[2];
+      else if (m[3] !== undefined) args[key] = m[3];
+      else if (m[4] !== undefined) args[key] = parseFloat(m[4]);
+      else if (m[5] !== undefined) args[key] = m[5] === 'true';
+    }
+    if (Object.keys(args).length > 0) {
+      return { type: 'tool_call', name, args, raw: rawText };
+    }
+  }
+
+  // ── No tool call detected — final prose response ───────────────────────────
+  return { type: 'final', content: text, raw: rawText };
+}
+
+// ─────────────────────────────────────────────
+//  Helpers
+// ─────────────────────────────────────────────
+
+function tryParseToolCall(name, inputRaw, rawText) {
+  try {
+    const args = JSON.parse(inputRaw);
+    return { type: 'tool_call', name, args, raw: rawText };
+  } catch (e) {
+    // Try to fix common JSON issues
+    const fixed = attemptJsonFix(inputRaw);
+    if (fixed !== null) {
+      return { type: 'tool_call', name, args: fixed, raw: rawText };
+    }
+    return {
+      type    : 'error',
+      message : `Tool "${name}" returned invalid JSON: ${e.message}\nRaw input: ${inputRaw.slice(0, 200)}`,
+      raw     : rawText,
+    };
+  }
+}
+
+/** Strip ```json ... ``` or ``` ... ``` fences */
+function stripCodeFences(str) {
+  return str
+    .replace(/^```(?:json)?\s*/i, '')
+    .replace(/\s*```$/, '')
+    .trim();
+}
+
+/** Remove AI thinking blocks (DeepSeek R1 / Yiyan patterns) */
+function stripThinkingBlocks(text) {
+  return text
+    .replace(/<think>[\s\S]*?<\/think>\n?/gi, '')
+    .replace(/^Thinking\.{0,3}\n[\s\S]*?\n\n/m, '')
+    .trim();
+}
+
+/** Attempt to fix common LLM JSON mistakes */
+function attemptJsonFix(str) {
+  try {
+    const fixed = str
+      .replace(/,\s*([}\]])/g, '$1')
+      .replace(/([{,]\s*)(\w+)\s*:/g, '$1"$2":');
+    return JSON.parse(fixed);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract the largest valid JSON object from a string.
+ * Uses a bracket-counting approach rather than regex to handle nested objects.
+ */
+function extractLargestJsonObject(text) {
+  let best = null;
+  let bestLen = 0;
+
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== '{') continue;
+    let depth   = 0;
+    let inStr   = false;
+    let escape  = false;
+
+    for (let j = i; j < text.length; j++) {
+      const ch = text[j];
+      if (escape)          { escape = false; continue; }
+      if (ch === '\\' && inStr) { escape = true; continue; }
+      if (ch === '"')      { inStr = !inStr; continue; }
+      if (inStr)           { continue; }
+      if (ch === '{')      { depth++; }
+      else if (ch === '}') {
+        depth--;
+        if (depth === 0) {
+          const candidate = text.slice(i, j + 1);
+          if (candidate.length > bestLen) {
+            try {
+              const parsed = JSON.parse(candidate);
+              best    = parsed;
+              bestLen = candidate.length;
+            } catch {
+              const fixed = attemptJsonFix(candidate);
+              if (fixed && candidate.length > bestLen) {
+                best    = fixed;
+                bestLen = candidate.length;
+              }
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  return best;
+}
+
+/** Format a tool result for sending back to the AI */
+function formatToolResult(toolName, result, isError = false) {
+  const status = isError ? 'ERROR' : 'SUCCESS';
+  return [
+    `[TOOL RESULT: ${toolName} | ${status}]`,
+    String(result),
+    `[END TOOL RESULT]`,
+  ].join('\n');
+}
+
+/** Check if a response looks like the agent is asking a clarifying question */
+function isAskingQuestion(text) {
+  const questionIndicators = [
+    /\?(\s*$)/m,
+    /could you (please |kindly )?clarify/i,
+    /can you provide more/i,
+    /what (do you|would you) (want|like|prefer)/i,
+    /please (specify|clarify|tell me)/i,
+  ];
+  return questionIndicators.some(re => re.test(text));
+}
+
+module.exports = {
+  parseResponse,
+  formatToolResult,
+  stripThinkingBlocks,
+  isAskingQuestion,
+};

package/src/postinstall.js

@@ -0,0 +1,26 @@
+// src/postinstall.js — Auto-install Playwright Chromium
+'use strict';
+
+const { execSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+
+// Skip in CI
+if (process.env.CI || process.env.SKIP_PLAYWRIGHT_INSTALL) {
+  console.log('[yiyan-agent] Skipping browser install (CI detected)');
+  process.exit(0);
+}
+
+console.log('\n[yiyan-agent] Installing Playwright Chromium...\n');
+
+try {
+  const isWindows = process.platform === 'win32';
+  const playwrightBin = path.join(__dirname, '..', 'node_modules', '.bin',
+    isWindows ? 'playwright.cmd' : 'playwright');
+
+  execSync(`"${playwrightBin}" install chromium`, { stdio: 'inherit' });
+  console.log('\n[yiyan-agent] ✓ Browser installed!\n');
+} catch {
+  console.warn('\n[yiyan-agent] ⚠ Could not auto-install. Run manually:');
+  console.warn('    npx playwright install chromium\n');
+}

package/src/prompt.js

@@ -0,0 +1,188 @@
+// src/prompt.js — System prompt and conversation builder
+'use strict';
+
+const os   = require('os');
+const path = require('path');
+const { getToolDescriptions } = require('./tools');
+const config = require('./config');
+
+// ─────────────────────────────────────────────
+//  System prompt — sent as the first message
+// ─────────────────────────────────────────────
+
+function buildSystemPrompt() {
+  const toolDocs = getToolDescriptions();
+  const cwd      = config.WORKING_DIR;
+  const platform = os.platform() + ' ' + os.release();
+  const nodeVer  = process.version;
+  const now      = new Date().toISOString();
+
+  // NOTE: We intentionally avoid a single template literal for the full prompt
+  // because the tool-call example contains triple backticks which would
+  // terminate the template literal early and cause a SyntaxError.
+  // We build the string with an array join + a FENCE variable instead.
+
+  const FENCE = '```';
+
+  const lines = [
+    'You are Yiyan Agent (文心一言代理) — an expert AI software engineer and coding assistant',
+    'running inside a terminal-based agent framework. You have direct access to the',
+    "user's filesystem and can execute shell commands.",
+    '',
+    'ENVIRONMENT',
+    '───────────',
+    'Platform         : ' + platform,
+    'Node.js          : ' + nodeVer,
+    'Date/Time        : ' + now,
+    'Working Directory: ' + cwd,
+    '',
+    'YOUR CAPABILITIES',
+    '─────────────────',
+    'You can read/write files, run shell commands, search codebases, fetch URLs,',
+    'and scaffold entire projects. You operate in an autonomous loop: you call a',
+    'tool, receive its result, and continue until the task is fully complete.',
+    '',
+    'HOW TO CALL TOOLS',
+    '─────────────────',
+    'When you need to use a tool, your ENTIRE response must be ONLY a fenced code',
+    'block tagged "tool_call" — with NO text before or after it:',
+    '',
+    FENCE + 'tool_call',
+    '{',
+    '  "name": "TOOL_NAME_HERE",',
+    '  "args": {',
+    '    "param1": "value1",',
+    '    "param2": "value2"',
+    '  }',
+    '}',
+    FENCE,
+    '',
+    'CRITICAL RULES:',
+    '- Output ONLY the tool_call block — no prose, no greeting, nothing else.',
+    '- ONE tool call per response. Never multiple.',
+    '- Content must be valid JSON with exactly "name" and "args" keys.',
+    '- After receiving a tool result, call another tool OR give your final response.',
+    '- Only write plain prose (no code block) when the task is 100% complete.',
+    '',
+    'WHEN TO STOP',
+    '────────────',
+    'When fully done, respond with a clear natural language summary.',
+    'Do NOT wrap it in any tags or code blocks. Just plain text.',
+    '',
+    'CODING GUIDELINES',
+    '─────────────────',
+    '- Always read existing files before modifying them.',
+    '- Always check the directory structure before creating new files.',
+    '- Write complete, production-quality code — no TODOs, no placeholders.',
+    '- Include proper error handling in all code you write.',
+    '- After writing code, run it (if applicable) to verify it works.',
+    '- Prefer small focused files over large monolithic ones.',
+    '- When installing packages, check package.json first.',
+    '',
+    'MULTI-STEP APPROACH',
+    '───────────────────',
+    'For complex tasks, break them into steps:',
+    '1. Explore the codebase / understand context',
+    '2. Plan what changes need to be made',
+    '3. Make changes systematically, one file at a time',
+    '4. Test / verify the result',
+    '',
+    'AVAILABLE TOOLS',
+    '───────────────',
+    toolDocs,
+    '',
+    'Remember: You are running autonomously. Be thorough, be precise, and complete',
+    'the task fully. If something is ambiguous, make a sensible decision and note',
+    'it in your final response.',
+  ];
+
+  return lines.join('\n');
+}
+
+// ─────────────────────────────────────────────
+//  Conversation / message history manager
+// ─────────────────────────────────────────────
+
+class ConversationManager {
+  constructor() {
+    this.messages      = [];
+    this._systemPrompt = null;
+  }
+
+  /**
+   * Build the very first user message that includes the system prompt,
+   * working-directory context, and the user's task.
+   */
+  buildFirstMessage(task, workingDirListing) {
+    this._systemPrompt = buildSystemPrompt();
+
+    const dirContext = workingDirListing
+      ? '\nCURRENT WORKING DIRECTORY CONTENTS:\n' + workingDirListing + '\n'
+      : '';
+
+    const firstMessage = [
+      this._systemPrompt,
+      '',
+      '═'.repeat(60),
+      '',
+      dirContext,
+      'USER TASK:',
+      '──────────',
+      task,
+    ].join('\n');
+
+    this.messages.push({ role: 'user', content: firstMessage });
+    return firstMessage;
+  }
+
+  /**
+   * Add a tool result as a user-turn message (feeding results back to the AI).
+   */
+  addToolResult(toolName, result, isError) {
+    const status  = isError ? 'ERROR' : 'SUCCESS';
+    const content = [
+      '[TOOL RESULT: ' + toolName + ' | ' + status + ']',
+      String(result),
+      '[END TOOL RESULT]',
+      '',
+      'Continue with the next step, or provide your final response if the task is complete.',
+    ].join('\n');
+
+    this.messages.push({ role: 'user', content: content });
+    return content;
+  }
+
+  /**
+   * Add an assistant message (the AI's raw response).
+   */
+  addAssistantMessage(content) {
+    this.messages.push({ role: 'assistant', content: content });
+  }
+
+  /**
+   * Get the most recent user message content.
+   */
+  getLatestUserMessage() {
+    const userMessages = this.messages.filter(function(m) { return m.role === 'user'; });
+    return userMessages.length > 0 ? userMessages[userMessages.length - 1].content : '';
+  }
+
+  /**
+   * How many assistant turns have happened.
+   */
+  get turnCount() {
+    return this.messages.filter(function(m) { return m.role === 'assistant'; }).length;
+  }
+
+  /**
+   * Export the full conversation as a readable text log.
+   */
+  exportLog() {
+    return this.messages.map(function(m) {
+      const header = m.role === 'user' ? 'USER' : 'ASSISTANT';
+      return '\n' + '─'.repeat(40) + '\n' + header + '\n' + '─'.repeat(40) + '\n' + m.content;
+    }).join('\n');
+  }
+}
+
+module.exports = { buildSystemPrompt, ConversationManager };