winter-super-cli 2026.5.20 → 2026.5.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "winter-super-cli",
-  "version": "2026.5.20",
+  "version": "2026.5.22",
   "description": "❄️ AI-Powered Development CLI with Interactive REPL",
   "type": "module",
   "main": "bin/winter.js",

package/src/ai/providers.js

@@ -397,7 +397,7 @@ export class AIProviderManager {
   }
 
   getSystemPrompt() {
-    return `You are Winter ❄️, an expert AI coding assistant.
+    return `You are Winter, an expert AI coding assistant.
 
 ## Core Principles
 1. **Think Before Coding** - State assumptions, ask when unclear

package/src/cli/commands.js

@@ -280,7 +280,7 @@ export class CommandParser {
   }
 
   getWinterSystemPrompt() {
-    return `You are Winter ❄️, an expert AI coding assistant.
+    return `You are Winter, an expert AI coding assistant.
 
 Follow these principles:
 
@@ -356,4 +356,4 @@ ${colors.white}Configuration:${colors.reset}
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
     `);
   }
-}
+}

package/src/cli/repl.js

@@ -295,7 +295,7 @@ export class WinterREPL {
     this.rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
-      prompt: `${colors.bright}${colors.cyan}winter ❄ ${colors.reset} `,
+      prompt: `${colors.bright}${colors.cyan}winter > ${colors.reset}`,
       completer: this.completer.bind(this),
     });
     this.installSlashSuggestions();
@@ -1487,6 +1487,7 @@ ${colors.reset}
     const toolCallParts = [];
     let finishReason = null;
     let printed = false;
+    const bufferToolModeContent = options?.enableTools === true;
 
     for await (const chunk of this.ai.streamRequest(messages, options)) {
       if (chunk.usage) this.addUsage(totalUsage, chunk.usage);
@@ -1515,40 +1516,57 @@ ${colors.reset}
       if (chunk.content) {
         if (!printed) {
           if (this.spinner) this.spinner.stop();
-          process.stdout.write(`\n${colors.white}`);
-          printed = true;
+          if (!bufferToolModeContent) {
+            process.stdout.write(`\n${colors.white}`);
+            printed = true;
+          }
         }
         content += chunk.content;
-        process.stdout.write(chunk.content);
+        if (!bufferToolModeContent) {
+          process.stdout.write(chunk.content);
+        }
       }
     }
 
     if (this.spinner) this.spinner.stop();
     if (printed) process.stdout.write(colors.reset);
 
-    const rawToolCalls = toolCallParts
-      .filter(Boolean)
-      .map((toolCall, index) => ({
+    const inlineToolExtraction = this.extractInlineToolCalls(content);
+    const rawToolCalls = [
+      ...toolCallParts.filter(Boolean).map((toolCall, index) => ({
         ...toolCall,
         id: toolCall.id || `call-${index}`,
-      }));
+      })),
+      ...inlineToolExtraction.toolCalls,
+    ];
     const toolCalls = this.normalizeToolCalls(rawToolCalls);
+    const visibleContent = inlineToolExtraction.content || content;
+
+    if (bufferToolModeContent && toolCalls.length === 0 && visibleContent) {
+      this.printAssistantAnswer(visibleContent, startedAt, totalUsage);
+      return {
+        assistantMsg: { content: visibleContent },
+        toolCalls,
+        finalContent: visibleContent,
+        finishReason,
+      };
+    }
 
-    if (toolCalls.length === 0 && content) {
+    if (toolCalls.length === 0 && visibleContent) {
       console.log(`\n${colors.dim}${this.formatAnswerFooter(startedAt, totalUsage)}${colors.reset}\n`);
       return {
-        assistantMsg: { content },
+        assistantMsg: { content: visibleContent },
         toolCalls,
-        finalContent: content,
+        finalContent: visibleContent,
         finishReason,
       };
-    } else if (content) {
+    } else if (printed && visibleContent) {
       process.stdout.write('\n');
     }
 
     return {
       assistantMsg: {
-        content,
+        content: visibleContent,
         tool_calls: this.formatToolCallsForMessage(toolCalls),
       },
       toolCalls,
@@ -1924,6 +1942,42 @@ ${colors.reset}
     });
   }
 
+  extractInlineToolCalls(content) {
+    const text = String(content || '');
+    const toolCalls = [];
+    let cleaned = text;
+    const callPattern = /<minimax:tool_call>\s*<invoke\s+name=["']([^"']+)["']>([\s\S]*?)<\/invoke>\s*<\/minimax:tool_call>/gi;
+
+    cleaned = cleaned.replace(callPattern, (_match, name, body) => {
+      const args = {};
+      const paramPattern = /<parameter\s+name=["']([^"']+)["']>([\s\S]*?)<\/parameter>/gi;
+      let param;
+      while ((param = paramPattern.exec(body))) {
+        args[param[1]] = this.decodeXmlEntities(param[2].trim());
+      }
+      toolCalls.push({
+        id: `inline-${Date.now()}-${toolCalls.length}`,
+        type: 'function',
+        function: {
+          name,
+          arguments: JSON.stringify(args),
+        },
+      });
+      return '';
+    }).trim();
+
+    return { content: cleaned, toolCalls };
+  }
+
+  decodeXmlEntities(value) {
+    return String(value || '')
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&quot;/g, '"')
+      .replace(/&apos;/g, "'")
+      .replace(/&amp;/g, '&');
+  }
+
   parseToolArguments(rawArgs) {
     if (!rawArgs) return {};
     if (typeof rawArgs === 'object') return rawArgs;
@@ -2127,7 +2181,7 @@ ${colors.reset}
     let memoryStr = memories.length > 0 ? `\n## Memories (Important Context)\n${memories.map(m => `- ${m.text}`).join('\n')}` : '';
     let plansStr = plans.length > 0 ? `\n## Active Plans & Tasks\n${plans.map(p => `- [${p.status}] ${p.title}: ${p.description}`).join('\n')}` : '';
 
-    return `You are Winter ❄️, an expert AI coding assistant.
+    return `You are Winter, an expert AI coding assistant.
 
 ## CRITICAL AI RULES (MUST FOLLOW STRICTLY):
 1. [THINKING BEFORE CODING]: Always output your thought process briefly before generating code. Think about edge cases, design structure, and syntax correctness.
@@ -2162,6 +2216,9 @@ ${colors.reset}
 - If a tool name fails, call the canonical tool name next: Write, Edit, Read, Bash, Glob, or Grep.
 - On Windows, Bash accepts both PowerShell and cmd.exe commands. Prefer Write with full content for file writes.
 - After using tools, always provide a direct final answer to the user.
+- Never claim that you changed files unless a Write, Edit, Bash, or equivalent tool result shows the change succeeded in this turn.
+- Never emit XML or provider-specific pseudo tool syntax like <minimax:tool_call>. Use the actual tool-calling API only.
+- If a file path is unknown, search with Glob/Grep first instead of inventing names like Nav.tsx or Footer.tsx.
 - Answer normal questions directly without unnecessary legal or policy disclaimers.
 - If a request is illegal, unsafe, or harmful, refuse briefly and offer a safe alternative.
 - Read files before modifying

package/src/cli/repl.test.js

@@ -215,3 +215,61 @@ test('runConversation reports malformed tool arguments instead of executing empt
   assert.equal(answer, 'Recovered');
   assert.deepEqual(executed, []);
 });
+
+test('runConversation executes inline XML tool calls without printing pseudo syntax', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+
+  let streamCount = 0;
+  const executed = [];
+  const writes = [];
+  const originalWrite = process.stdout.write;
+  repl.ai = {
+    tools: [],
+    providers: { custom: { model: 'test-model' } },
+    getActiveProvider: () => 'custom',
+    setTools(tools) {
+      this.tools = tools;
+    },
+    async *streamRequest() {
+      streamCount++;
+      if (streamCount === 1) {
+        yield {
+          content: 'Để tôi đọc file:\n<minimax:tool_call><invoke name="Read"><parameter name="path">README.md</parameter></invoke></minimax:tool_call>',
+          raw: { choices: [{ delta: { content: 'inline xml' }, finish_reason: 'stop' }] },
+        };
+        return;
+      }
+
+      yield { content: 'Đã đọc xong' };
+    },
+  };
+  repl.tools = {
+    normalizeToolName: name => name,
+    async execute(name, args) {
+      executed.push({ name, args });
+      return { success: true, path: args.path, lines: 1, size: 2, content: 'ok' };
+    },
+  };
+
+  process.stdout.write = (chunk) => {
+    writes.push(String(chunk));
+    return true;
+  };
+
+  try {
+    const answer = await repl.runConversation([{ role: 'user', content: 'read it' }], 'Test', [{ name: 'Read' }]);
+
+    assert.equal(answer, 'Đã đọc xong');
+    assert.deepEqual(executed, [{ name: 'Read', args: { path: 'README.md' } }]);
+    assert.doesNotMatch(writes.join(''), /minimax:tool_call/);
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+});
+
+test('interactive prompt and system prompt do not brand Winter with emoji', () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+
+  assert.match(repl.getSystemPrompt(''), /You are Winter, an expert AI coding assistant/);
+  assert.doesNotMatch(repl.getSystemPrompt(''), /You are Winter ❄️/);
+});

package/src/tools/executor.js

@@ -209,13 +209,7 @@ export class ToolExecutor {
       case 'Write':
         return await this.writeFile(this.resolveInputPath(input.file_path ?? input.path ?? input.file, cwd), input.content);
       case 'Edit':
-        const oldStr = input.old_string ?? input.oldString ?? input.old_text ?? input.oldText ?? input.search ?? input.target;
-        const newStr = input.new_string ?? input.newString ?? input.new_text ?? input.newText ?? input.replace ?? input.content;
-        return await this.editFile(
-          this.resolveInputPath(input.file_path ?? input.path ?? input.file, cwd),
-          oldStr,
-          newStr
-        );
+        return await this.executeEdit(input, cwd);
       case 'Bash':
         return await this.bash(input.command ?? input.cmd, input.cwd || cwd, input.timeout, input.shell);
       case 'Glob':
@@ -410,12 +404,85 @@ export class ToolExecutor {
     }
   }
 
+  async executeEdit(input, cwd) {
+    const request = this.unwrapToolInput(input);
+    const batch = request.edits ?? request.replacements ?? request.changes;
+
+    if (Array.isArray(batch)) {
+      const results = [];
+      for (const item of batch) {
+        const edit = this.normalizeEditArgs({ ...request, ...this.unwrapToolInput(item) }, cwd);
+        const result = await this.editFile(edit.filePath, edit.oldString, edit.newString);
+        results.push(result);
+        if (result.success === false) {
+          return { ...result, batchResults: results };
+        }
+      }
+
+      return {
+        success: true,
+        path: results[results.length - 1]?.path,
+        replacements: results.reduce((sum, result) => sum + (result.replacements || 0), 0),
+        batchResults: results,
+        diff: results.map(result => result.diff).filter(Boolean).join('\n'),
+      };
+    }
+
+    const edit = this.normalizeEditArgs(request, cwd);
+    return await this.editFile(edit.filePath, edit.oldString, edit.newString);
+  }
+
+  unwrapToolInput(input) {
+    let current = input && typeof input === 'object' ? input : {};
+    for (const key of ['input', 'args', 'arguments', 'parameters']) {
+      if (
+        current[key]
+        && typeof current[key] === 'object'
+        && !Array.isArray(current[key])
+        && Object.keys(current).length === 1
+      ) {
+        current = current[key];
+      }
+    }
+    return current;
+  }
+
+  normalizeEditArgs(input, cwd) {
+    const pick = (keys) => {
+      for (const key of keys) {
+        if (typeof input[key] === 'string') return input[key];
+      }
+      return undefined;
+    };
+
+    const filePath = this.resolveInputPath(pick([
+      'file_path', 'filepath', 'filePath', 'path', 'file', 'filename', 'target_file', 'targetFile',
+    ]), cwd);
+    const oldString = pick([
+      'old_string', 'oldString', 'old_text', 'oldText', 'old_str', 'oldStr',
+      'search', 'search_string', 'searchString', 'find', 'find_text', 'findText',
+      'target', 'target_string', 'targetString', 'text_to_replace', 'textToReplace',
+      'pattern', 'original', 'before',
+    ]);
+    const newString = pick([
+      'new_string', 'newString', 'new_text', 'newText', 'new_str', 'newStr',
+      'replace', 'replacement', 'replace_with', 'replaceWith',
+      'new_content', 'newContent', 'content', 'value', 'after',
+    ]);
+
+    return { filePath, oldString, newString };
+  }
+
   async editFile(filePath, oldString, newString) {
     if (!filePath) {
       return { success: false, error: 'file_path is required' };
     }
     if (typeof oldString !== 'string' || typeof newString !== 'string') {
-      return { success: false, error: 'old_string and new_string are required', path: filePath };
+      return {
+        success: false,
+        error: 'old_string and new_string are required. Accepted aliases: oldString/old_str/search/find/text_to_replace and newString/new_str/replace/replacement/replace_with. For full-file replacement use Write instead of Edit.',
+        path: filePath,
+      };
     }
 
     try {

package/src/tools/executor.test.js

@@ -38,6 +38,55 @@ test('tool names accept common model aliases', () => {
   assert.equal(tools.normalizeToolName('web-search'), 'WebSearch');
 });
 
+test('Edit accepts common model argument aliases', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'winter-edit-alias-'));
+  await writeFile(path.join(root, 'file.txt'), 'hello world\n');
+
+  const tools = new ToolExecutor({ projectPath: root });
+  const result = await tools.execute('Edit', {
+    path: 'file.txt',
+    find: 'hello',
+    replacement: 'hi',
+  });
+
+  assert.equal(result.success, true);
+  const read = await tools.execute('Read', { path: 'file.txt' });
+  assert.equal(read.content, 'hi world\n');
+});
+
+test('Edit accepts nested and batch edit arguments', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'winter-edit-batch-'));
+  await writeFile(path.join(root, 'file.txt'), 'alpha beta gamma\n');
+
+  const tools = new ToolExecutor({ projectPath: root });
+  const result = await tools.execute('replace_in_file', {
+    arguments: {
+      file_path: 'file.txt',
+      edits: [
+        { old_str: 'alpha', new_str: 'one' },
+        { text_to_replace: 'gamma', replace_with: 'three' },
+      ],
+    },
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(result.replacements, 2);
+  const read = await tools.execute('Read', { path: 'file.txt' });
+  assert.equal(read.content, 'one beta three\n');
+});
+
+test('Edit missing strings returns recovery guidance', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'winter-edit-recovery-'));
+  await writeFile(path.join(root, 'file.txt'), 'hello\n');
+
+  const tools = new ToolExecutor({ projectPath: root });
+  const result = await tools.execute('Edit', { path: 'file.txt' });
+
+  assert.equal(result.success, false);
+  assert.match(result.error, /Accepted aliases/);
+  assert.match(result.error, /Write instead of Edit/);
+});
+
 test('Bash supports model-style heredoc file writes', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'winter-heredoc-'));
   const tools = new ToolExecutor({ projectPath: root });