winter-super-cli 2026.5.15 → 2026.5.17

package/package.json

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

package/src/cli/repl.js

@@ -1374,13 +1374,14 @@ ${colors.reset}
         for (const tc of toolCalls) {
           const { toolName, toolArgs } = tc;
           const canonicalToolName = this.tools.normalizeToolName(toolName);
-          const enrichedArgs = this.enrichToolArgs(canonicalToolName, toolArgs, messages);
+          const argParseError = toolArgs?.__toolArgParseError;
+          const enrichedArgs = argParseError ? {} : this.enrichToolArgs(canonicalToolName, toolArgs, messages);
 
           const icon = canonicalToolName === 'Bash' ? '⚙' : canonicalToolName === 'Read' ? '📖' : canonicalToolName === 'Write' ? '✏️' : canonicalToolName === 'Edit' ? '🔧' : canonicalToolName === 'Grep' ? '🔍' : canonicalToolName === 'Glob' ? '📂' : '⚡';
           console.log(`${colors.magenta}│${colors.reset} ${icon} ${colors.cyan}${colors.bright}${toolName}${colors.reset}`);
 
           let proceed = true;
-          if (canonicalToolName === 'Bash') {
+          if (canonicalToolName === 'Bash' && !argParseError) {
             const cmd = enrichedArgs.command || enrichedArgs.cmd || 'unknown';
             process.stdout.write(`${colors.magenta}│${colors.reset}   ${colors.yellow}⚠  AI muốn chạy: ${colors.bright}${cmd}${colors.reset}\n`);
             proceed = await new Promise(resolve => {
@@ -1394,7 +1395,13 @@ ${colors.reset}
           }
 
           let result;
-          if (!proceed) {
+          if (argParseError) {
+            result = {
+              success: false,
+              error: `Invalid ${canonicalToolName} tool arguments JSON: ${toolArgs.__toolArgParseError}`,
+              rawArgs: toolArgs.__rawToolArgs,
+            };
+          } else if (!proceed) {
             result = { success: false, error: 'User denied permission to execute this command.' };
           } else {
             result = toolName
@@ -1922,13 +1929,59 @@ ${colors.reset}
     if (typeof rawArgs === 'object') return rawArgs;
     if (typeof rawArgs !== 'string') return {};
 
+    const text = rawArgs.trim();
+    if (!text) return {};
+
     try {
-      return JSON.parse(rawArgs);
-    } catch {
-      return {};
+      return JSON.parse(text);
+    } catch (error) {
+      const extracted = this.extractFirstJsonObject(text);
+      if (extracted && extracted !== text) {
+        try {
+          return JSON.parse(extracted);
+        } catch {}
+      }
+
+      return {
+        __toolArgParseError: error.message,
+        __rawToolArgs: text.length > 800 ? `${text.slice(0, 800)}...` : text,
+      };
     }
   }
 
+  extractFirstJsonObject(text) {
+    const start = text.indexOf('{');
+    if (start === -1) return null;
+
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+
+    for (let i = start; i < text.length; i++) {
+      const ch = text[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === '\\') {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === '{') depth++;
+      if (ch === '}') {
+        depth--;
+        if (depth === 0) return text.slice(start, i + 1);
+      }
+    }
+
+    return null;
+  }
+
   formatToolCallsForMessage(toolCalls) {
     return toolCalls.map((tc) => ({
       id: tc.id,

package/src/cli/repl.test.js

@@ -165,3 +165,53 @@ test('runConversation executes streamed tool calls then streams final answer', a
   assert.equal(answer, 'Done');
   assert.deepEqual(executed, [{ name: 'Read', args: { file_path: 'README.md' } }]);
 });
+
+test('runConversation reports malformed tool arguments instead of executing empty args', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+
+  let streamCount = 0;
+  const executed = [];
+  repl.ai = {
+    tools: [],
+    providers: { custom: { model: 'test-model' } },
+    getActiveProvider: () => 'custom',
+    setTools(tools) {
+      this.tools = tools;
+    },
+    async *streamRequest() {
+      streamCount++;
+      if (streamCount === 1) {
+        yield {
+          raw: {
+            choices: [{
+              delta: {
+                tool_calls: [{
+                  index: 0,
+                  id: 'call-bad',
+                  type: 'function',
+                  function: { name: 'Bash', arguments: '{"command":' },
+                }],
+              },
+              finish_reason: 'tool_calls',
+            }],
+          },
+        };
+        return;
+      }
+
+      yield { content: 'Recovered' };
+    },
+  };
+  repl.tools = {
+    normalizeToolName: name => name,
+    async execute(name, args) {
+      executed.push({ name, args });
+      return { success: true };
+    },
+  };
+
+  const answer = await repl.runConversation([{ role: 'user', content: 'run it' }], 'Test', [{ name: 'Bash' }]);
+
+  assert.equal(answer, 'Recovered');
+  assert.deepEqual(executed, []);
+});

package/src/tools/executor.js

@@ -244,26 +244,52 @@ export class ToolExecutor {
     const aliases = {
       read: 'Read',
       readfile: 'Read',
+      openfile: 'Read',
+      viewfile: 'Read',
+      cat: 'Read',
       write: 'Write',
       writefile: 'Write',
+      writetofile: 'Write',
+      createfile: 'Write',
+      savefile: 'Write',
       edit: 'Edit',
       editfile: 'Edit',
+      replaceinfile: 'Edit',
+      strreplace: 'Edit',
+      strreplaceeditor: 'Edit',
+      applydiff: 'Edit',
+      patch: 'Edit',
       bash: 'Bash',
       shell: 'Bash',
       command: 'Bash',
+      executecommand: 'Bash',
+      runcommand: 'Bash',
+      terminal: 'Bash',
+      powershell: 'Bash',
       glob: 'Glob',
+      listfiles: 'Glob',
+      ls: 'Glob',
+      findfiles: 'Glob',
       grep: 'Grep',
       search: 'Grep',
+      searchfiles: 'Grep',
+      searchtext: 'Grep',
+      rg: 'Grep',
       lsp: 'LSP',
+      listcodedefinitionnames: 'LSP',
       taskcreate: 'TaskCreate',
       createtask: 'TaskCreate',
+      newtask: 'TaskCreate',
       taskupdate: 'TaskUpdate',
       updatetask: 'TaskUpdate',
       tasklist: 'TaskList',
       listtasks: 'TaskList',
+      plan: 'TaskList',
       webfetch: 'WebFetch',
       fetch: 'WebFetch',
+      fetchurl: 'WebFetch',
       websearch: 'WebSearch',
+      searchweb: 'WebSearch',
       browserdebug: 'BrowserDebug',
       browser: 'BrowserDebug',
     };

package/src/tools/executor.test.js

@@ -18,6 +18,11 @@ test('tool names accept common model aliases', () => {
   const tools = new ToolExecutor({ projectPath: process.cwd() });
 
   assert.equal(tools.normalizeToolName('read_file'), 'Read');
+  assert.equal(tools.normalizeToolName('write_to_file'), 'Write');
+  assert.equal(tools.normalizeToolName('replace_in_file'), 'Edit');
+  assert.equal(tools.normalizeToolName('execute_command'), 'Bash');
+  assert.equal(tools.normalizeToolName('list_files'), 'Glob');
+  assert.equal(tools.normalizeToolName('search_files'), 'Grep');
   assert.equal(tools.normalizeToolName('shell'), 'Bash');
   assert.equal(tools.normalizeToolName('web-search'), 'WebSearch');
 });