winter-super-cli 2026.5.16 → 2026.5.18

package/package.json

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

package/src/tools/executor.js

@@ -5,11 +5,12 @@
 
 import { promises as fs } from 'fs';
 import path from 'path';
-import { exec } from 'child_process';
+import { exec, execFile } from 'child_process';
 import { promisify } from 'util';
 import { diffLines } from 'diff';
 
 const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 
 export class ToolExecutor {
   constructor(repl) {
@@ -244,26 +245,53 @@ 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',
+      commandexecutor: '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',
     };
@@ -419,6 +447,9 @@ export class ToolExecutor {
     timeout = parseInt(timeout, 10);
     if (isNaN(timeout) || timeout < 0) timeout = 60000;
 
+    const heredocResult = await this.tryHandleHeredocWrite(command, cwd);
+    if (heredocResult) return heredocResult;
+
     command = await this.translateWindowsCommand(command);
 
     // Security check
@@ -430,7 +461,14 @@ export class ToolExecutor {
     }
 
     try {
-      const { stdout, stderr } = await execAsync(command, { cwd, timeout, shell: true });
+      const { stdout, stderr } = process.platform === 'win32'
+        ? await execFileAsync('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', command], {
+            cwd,
+            timeout,
+            windowsHide: true,
+            maxBuffer: 10 * 1024 * 1024,
+          })
+        : await execAsync(command, { cwd, timeout, shell: true, maxBuffer: 10 * 1024 * 1024 });
       return {
         success: true,
         stdout: stdout || '',
@@ -531,16 +569,17 @@ export class ToolExecutor {
     if (process.platform !== 'win32') return command;
 
     const trimmed = command.trim();
-    const lsRecursive = trimmed.match(/^ls\s+-R\s+(.+)$/i);
-    if (lsRecursive) {
-      const target = lsRecursive[1].trim();
-      return `powershell -NoProfile -Command "Get-ChildItem -LiteralPath ${this.quotePowerShellString(target)} -Recurse -Force | Select-Object -ExpandProperty FullName"`;
-    }
-
-    const ls = trimmed.match(/^ls\s+(.+)$/i);
+    const ls = trimmed.match(/^ls(?:\s+(.+))?$/i);
     if (ls) {
-      const target = ls[1].trim();
-      return `powershell -NoProfile -Command "Get-ChildItem -LiteralPath ${this.quotePowerShellString(target)} -Force | Select-Object -ExpandProperty Name"`;
+      const parsed = this.parseLsArgs(ls[1] || '');
+      const target = parsed.target || '.';
+      const recurse = parsed.flags.has('r') || parsed.flags.has('recursive');
+      const long = parsed.flags.has('l') || parsed.flags.has('la') || parsed.flags.has('al');
+      const force = parsed.flags.has('a') || parsed.flags.has('force') || parsed.flags.has('la') || parsed.flags.has('al');
+      const fields = long
+        ? 'Mode,Length,LastWriteTime,Name'
+        : 'Name';
+      return `Get-ChildItem -LiteralPath ${this.quotePowerShellString(target)}${recurse ? ' -Recurse' : ''}${force ? ' -Force' : ''} | Select-Object ${fields}`;
     }
 
     const cat = trimmed.match(/^cat\s+(.+)$/i);
@@ -550,15 +589,82 @@ export class ToolExecutor {
       try {
         const stat = await fs.stat(normalizedTarget);
         if (stat.isDirectory()) {
-          return `powershell -NoProfile -Command "Get-ChildItem -LiteralPath ${this.quotePowerShellString(target)} -Force | Select-Object -ExpandProperty Name"`;
+          return `Get-ChildItem -LiteralPath ${this.quotePowerShellString(target)} -Force | Select-Object -ExpandProperty Name`;
         }
       } catch {}
-      return `powershell -NoProfile -Command "Get-Content -LiteralPath ${this.quotePowerShellString(target)}"`;
+      return `Get-Content -LiteralPath ${this.quotePowerShellString(target)}`;
     }
 
     return command;
   }
 
+  async tryHandleHeredocWrite(command, cwd) {
+    const match = String(command || '').match(/^cat\s*>\s*(.+?)\s*<<\s*['"]?([A-Za-z0-9_-]+)['"]?\r?\n([\s\S]*?)\r?\n\2\s*$/);
+    if (!match) return null;
+
+    const [, rawTarget, , content] = match;
+    const target = this.resolveInputPath(rawTarget.trim(), cwd);
+    return await this.writeFile(target, content.endsWith('\n') ? content : `${content}\n`);
+  }
+
+  parseLsArgs(rawArgs) {
+    const tokens = this.splitShellLike(rawArgs);
+    const flags = new Set();
+    const paths = [];
+
+    for (const token of tokens) {
+      if (token.startsWith('-') && token.length > 1) {
+        const flag = token.replace(/^-+/, '').toLowerCase();
+        flags.add(flag);
+        if (!flag.includes('=')) {
+          for (const ch of flag) flags.add(ch);
+        }
+      } else {
+        paths.push(token);
+      }
+    }
+
+    return { flags, target: paths.join(' ') };
+  }
+
+  splitShellLike(text) {
+    const tokens = [];
+    let current = '';
+    let quote = null;
+    let escaped = false;
+
+    for (const ch of String(text || '')) {
+      if (escaped) {
+        current += ch;
+        escaped = false;
+        continue;
+      }
+      if (ch === '\\') {
+        escaped = true;
+        continue;
+      }
+      if ((ch === '"' || ch === "'") && !quote) {
+        quote = ch;
+        continue;
+      }
+      if (ch === quote) {
+        quote = null;
+        continue;
+      }
+      if (/\s/.test(ch) && !quote) {
+        if (current) {
+          tokens.push(current);
+          current = '';
+        }
+        continue;
+      }
+      current += ch;
+    }
+
+    if (current) tokens.push(current);
+    return tokens;
+  }
+
   quotePowerShellString(value) {
     const unquoted = value.replace(/^['"]|['"]$/g, '');
     return `'${unquoted.replace(/'/g, "''")}'`;

package/src/tools/executor.test.js

@@ -18,10 +18,50 @@ 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('command_executor'), 'Bash');
+  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');
 });
 
+test('Bash supports model-style heredoc file writes', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'winter-heredoc-'));
+  const tools = new ToolExecutor({ projectPath: root });
+  const result = await tools.execute('command_executor', {
+    command: "cat > src/components/InstallSection.tsx << 'EOF'\nconst ok = true;\nEOF",
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(result.path, path.join(root, 'src', 'components', 'InstallSection.tsx'));
+
+  const read = await tools.execute('Read', { file_path: 'src/components/InstallSection.tsx' });
+  assert.equal(read.content, 'const ok = true;\n');
+});
+
+test('Windows Bash runs PowerShell commands and translates ls flags', async (t) => {
+  if (process.platform !== 'win32') {
+    t.skip('Windows-only shell behavior');
+    return;
+  }
+
+  const root = await mkdtemp(path.join(tmpdir(), 'winter-powershell-'));
+  await mkdir(path.join(root, 'src', 'components'), { recursive: true });
+  await writeFile(path.join(root, 'src', 'components', 'a.txt'), 'hello');
+
+  const tools = new ToolExecutor({ projectPath: root });
+  const ls = await tools.execute('Bash', { command: 'ls -la src/components/' });
+  assert.equal(ls.success, true);
+  assert.match(ls.stdout, /a\.txt/);
+
+  const ps = await tools.execute('Bash', { command: 'Get-ChildItem -Path src/components/ -Name' });
+  assert.equal(ps.success, true);
+  assert.match(ps.stdout, /a\.txt/);
+});
+
 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'));