winter-super-cli 2026.5.19 → 2026.5.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "winter-super-cli",
-  "version": "2026.5.19",
+  "version": "2026.5.21",
   "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.
@@ -2149,7 +2203,7 @@ ${colors.reset}
 - Read, Write, Edit - File operations
 - Write - Create/overwrite files directly. Use this instead of Bash echo/cat/heredoc for writing code.
 - Edit - Replace exact text in existing files.
-- Bash - Execute shell commands. Current OS is ${process.platform === 'win32' ? 'Windows; Bash runs through PowerShell, not Linux bash. Use PowerShell-compatible commands.' : process.platform}.
+- Bash - Execute shell commands. Current OS is ${process.platform === 'win32' ? 'Windows; Bash auto-detects PowerShell and cmd.exe syntax. Use shell="powershell" or shell="cmd" when needed.' : process.platform}.
 - Glob - Find files
 - Grep - Search content
 - TaskCreate, TaskUpdate, TaskList - Task management
@@ -2160,8 +2214,11 @@ ${colors.reset}
 - Call tools when they help - be proactive
 - You DO have file write tools. Never say "there is no write tool"; use Write or Edit.
 - If a tool name fails, call the canonical tool name next: Write, Edit, Read, Bash, Glob, or Grep.
-- Do not use Linux-only heredoc/echo chains to write files on Windows. Prefer Write with full content.
+- 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
@@ -2246,8 +2303,8 @@ ${rolePrompt}
 
 ## Tool Rules
 - Canonical tools: Read, Write, Edit, Bash, Glob, Grep, TaskCreate, TaskUpdate, TaskList, BrowserDebug, WebFetch, WebSearch.
-- Current OS is ${process.platform === 'win32' ? 'Windows; Bash runs through PowerShell, not Linux bash. Use PowerShell-compatible commands.' : process.platform}.
-- Prefer Write/Edit for writing files. Do not use Linux-only heredoc or long echo chains for code files.
+- Current OS is ${process.platform === 'win32' ? 'Windows; Bash auto-detects PowerShell and cmd.exe syntax. Use shell="powershell" or shell="cmd" when needed.' : process.platform}.
+- Prefer Write/Edit for writing files. Bash accepts both PowerShell and cmd.exe on Windows, but do not use long echo chains for code files.
 - If a tool call fails because of an unknown alias, call the canonical tool name next.
 
 ## Project

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

@@ -64,13 +64,14 @@ export class ToolExecutor {
       {
         type: 'function',
         name: 'Bash',
-        description: 'Execute a shell command. On Windows this runs in PowerShell, not Linux bash. Prefer Write/Edit for file writes.',
+        description: 'Execute a shell command. On Windows, shell auto-detects PowerShell or cmd.exe syntax. Prefer Write/Edit for file writes.',
         parameters: {
           type: 'object',
           properties: {
             command: { type: 'string', description: 'Shell command to execute' },
             cwd: { type: 'string', description: 'Working directory' },
-            timeout: { type: 'number', description: 'Timeout in ms (default: 60000)' }
+            timeout: { type: 'number', description: 'Timeout in ms (default: 60000)' },
+            shell: { type: 'string', description: 'Windows shell: auto, powershell, or cmd' }
           },
           required: ['command']
         }
@@ -216,7 +217,7 @@ export class ToolExecutor {
           newStr
         );
       case 'Bash':
-        return await this.bash(input.command ?? input.cmd, input.cwd || cwd, input.timeout);
+        return await this.bash(input.command ?? input.cmd, input.cwd || cwd, input.timeout, input.shell);
       case 'Glob':
         return await this.glob(input.pattern ?? input.glob ?? '**/*', input.cwd || input.path || cwd);
       case 'Grep':
@@ -444,7 +445,7 @@ export class ToolExecutor {
     }
   }
 
-  async bash(command, cwd, timeout = 60000) {
+  async bash(command, cwd, timeout = 60000, shell = 'auto') {
     if (typeof command !== 'string' || command.trim() === '') {
       return { success: false, error: 'command is required', exitCode: 1 };
     }
@@ -455,7 +456,10 @@ export class ToolExecutor {
     const heredocResult = await this.tryHandleHeredocWrite(command, cwd);
     if (heredocResult) return heredocResult;
 
-    command = await this.translateWindowsCommand(command);
+    let requestedShell = this.normalizeWindowsShell(shell);
+    const translated = await this.translateWindowsCommand(command);
+    command = translated.command;
+    if (requestedShell === 'auto' && translated.shell) requestedShell = translated.shell;
 
     // Security check
     const lowerCommand = command.toLowerCase();
@@ -467,12 +471,7 @@ export class ToolExecutor {
 
     try {
       const { stdout, stderr } = process.platform === 'win32'
-        ? await execFileAsync('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', command], {
-            cwd,
-            timeout,
-            windowsHide: true,
-            maxBuffer: 10 * 1024 * 1024,
-          })
+        ? await this.execWindowsCommand(command, cwd, timeout, requestedShell)
         : await execAsync(command, { cwd, timeout, shell: true, maxBuffer: 10 * 1024 * 1024 });
       return {
         success: true,
@@ -491,6 +490,50 @@ export class ToolExecutor {
     }
   }
 
+  normalizeWindowsShell(shell) {
+    const value = String(shell || 'auto').toLowerCase();
+    if (['cmd', 'cmd.exe', 'commandprompt', 'command-prompt'].includes(value)) return 'cmd';
+    if (['powershell', 'pwsh', 'ps', 'powershell.exe'].includes(value)) return 'powershell';
+    return 'auto';
+  }
+
+  async execWindowsCommand(command, cwd, timeout, requestedShell = 'auto') {
+    const shell = requestedShell === 'auto' ? this.detectWindowsShell(command) : requestedShell;
+    if (shell === 'cmd') {
+      return await execFileAsync('cmd.exe', ['/d', '/s', '/c', command], {
+        cwd,
+        timeout,
+        windowsHide: true,
+        maxBuffer: 10 * 1024 * 1024,
+      });
+    }
+
+    return await execFileAsync('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', command], {
+      cwd,
+      timeout,
+      windowsHide: true,
+      maxBuffer: 10 * 1024 * 1024,
+    });
+  }
+
+  detectWindowsShell(command) {
+    const trimmed = String(command || '').trim();
+    if (this.looksLikePowerShell(trimmed)) return 'powershell';
+    if (this.looksLikeCmd(trimmed)) return 'cmd';
+    return 'powershell';
+  }
+
+  looksLikePowerShell(command) {
+    return /(^|[;&|]\s*)(Get-|Set-|New-|Remove-|Copy-|Move-|Select-|Where-|ForEach-|Test-Path|Out-File|Write-Host|powershell(?:\.exe)?\b|pwsh\b)/i.test(command);
+  }
+
+  looksLikeCmd(command) {
+    return /\s(&&|\|\|)\s/.test(command)
+      || /(^|[&]\s*)(dir|copy|xcopy|del|erase|move|ren|type|echo|set|if|for|mkdir|rmdir)\b/i.test(command)
+      || /^\s*@?echo\s+/i.test(command)
+      || /(^|\s)(\/b|\/s|\/q|\/y)\b/i.test(command);
+  }
+
   async glob(pattern, cwd) {
     const normalizedRequest = await this.normalizeGlobRequest(pattern, cwd);
     if (normalizedRequest.file) {
@@ -571,7 +614,7 @@ export class ToolExecutor {
   }
 
   async translateWindowsCommand(command) {
-    if (process.platform !== 'win32') return command;
+    if (process.platform !== 'win32') return { command };
 
     const trimmed = command.trim();
     const ls = trimmed.match(/^ls(?:\s+(.+))?$/i);
@@ -584,7 +627,10 @@ export class ToolExecutor {
       const fields = long
         ? 'Mode,Length,LastWriteTime,Name'
         : 'Name';
-      return `Get-ChildItem -LiteralPath ${this.quotePowerShellString(target)}${recurse ? ' -Recurse' : ''}${force ? ' -Force' : ''} | Select-Object ${fields}`;
+      return {
+        command: `Get-ChildItem -LiteralPath ${this.quotePowerShellString(target)}${recurse ? ' -Recurse' : ''}${force ? ' -Force' : ''} | Select-Object ${fields}`,
+        shell: 'powershell',
+      };
     }
 
     const cat = trimmed.match(/^cat\s+(.+)$/i);
@@ -594,13 +640,19 @@ export class ToolExecutor {
       try {
         const stat = await fs.stat(normalizedTarget);
         if (stat.isDirectory()) {
-          return `Get-ChildItem -LiteralPath ${this.quotePowerShellString(target)} -Force | Select-Object -ExpandProperty Name`;
+          return {
+            command: `Get-ChildItem -LiteralPath ${this.quotePowerShellString(target)} -Force | Select-Object -ExpandProperty Name`,
+            shell: 'powershell',
+          };
         }
       } catch {}
-      return `Get-Content -LiteralPath ${this.quotePowerShellString(target)}`;
+      return {
+        command: `Get-Content -LiteralPath ${this.quotePowerShellString(target)}`,
+        shell: 'powershell',
+      };
     }
 
-    return command;
+    return { command };
   }
 
   async tryHandleHeredocWrite(command, cwd) {

package/src/tools/executor.test.js

@@ -72,6 +72,46 @@ test('Windows Bash runs PowerShell commands and translates ls flags', async (t)
   assert.match(ps.stdout, /a\.txt/);
 });
 
+test('Windows Bash accepts explicit cmd and PowerShell shells', async (t) => {
+  if (process.platform !== 'win32') {
+    t.skip('Windows-only shell behavior');
+    return;
+  }
+
+  const root = await mkdtemp(path.join(tmpdir(), 'winter-shells-'));
+  const tools = new ToolExecutor({ projectPath: root });
+
+  const cmd = await tools.execute('Bash', {
+    shell: 'cmd',
+    command: 'echo hello>cmd.txt && type cmd.txt',
+  });
+  assert.equal(cmd.success, true);
+  assert.match(cmd.stdout, /hello/);
+
+  const ps = await tools.execute('Bash', {
+    shell: 'powershell',
+    command: "Set-Content -LiteralPath ps.txt -Value 'world'; Get-Content -LiteralPath ps.txt",
+  });
+  assert.equal(ps.success, true);
+  assert.match(ps.stdout, /world/);
+});
+
+test('Windows Bash auto-detects cmd chaining syntax', async (t) => {
+  if (process.platform !== 'win32') {
+    t.skip('Windows-only shell behavior');
+    return;
+  }
+
+  const root = await mkdtemp(path.join(tmpdir(), 'winter-cmd-auto-'));
+  const tools = new ToolExecutor({ projectPath: root });
+  const result = await tools.execute('Bash', {
+    command: 'echo auto>auto.txt && type auto.txt',
+  });
+
+  assert.equal(result.success, true);
+  assert.match(result.stdout, /auto/);
+});
+
 test('Read lists directories instead of failing on directory paths', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'winter-tools-'));
   await mkdir(path.join(root, 'sub'));