winter-super-cli 2026.5.21 → 2026.5.24

package/package.json

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

package/rules/default.md

@@ -80,6 +80,7 @@ Check for these files in order:
 
 ### Tool Guidelines
 - Call tools proactively - don't just describe, DO
+- CHỦ ĐỘNG TÌM KIẾM: Khi người dùng yêu cầu sửa đổi hoặc thêm tính năng mà không chỉ định file cụ thể, AI PHẢI TỰ DÙNG các công cụ như `list_dir` hoặc `grep_search` để tìm kiếm file liên quan trong dự án. TUYỆT ĐỐI KHÔNG ĐƯỢC hỏi xin code hoặc xin đường dẫn file từ người dùng nếu có thể tự tìm thấy!
 - Prefer Read over describing code
 - Use Edit for small changes, Write for new files
 - Verify changes after execution

package/src/cli/repl.js

@@ -1422,17 +1422,25 @@ ${colors.reset}
             const maxLen = BOX_WIDTH - 8;
             const lines = summary.split('\n');
             for (const line of lines) {
-              if (line.length <= maxLen) {
-                console.log(`${colors.magenta}│${colors.reset}   ${statusIcon} ${colors.dim}${line}${colors.reset}`);
+              // Loại bỏ mã màu ANSI để tính toán độ dài và cắt dòng chuẩn xác
+              const cleanLine = line.replace(/\x1b\[[0-9;]*m/g, '');
+              
+              if (cleanLine.length <= maxLen) {
+                const padLen = BOX_WIDTH - 7 - cleanLine.length;
+                const padding = ' '.repeat(Math.max(0, padLen));
+                console.log(`${colors.magenta}│${colors.reset}   ${statusIcon} ${colors.dim}${cleanLine}${colors.reset}${padding}${colors.magenta}│${colors.reset}`);
               } else {
                 // Word wrap
-                let remaining = line;
+                let remaining = cleanLine;
                 let first = true;
                 while (remaining.length > 0) {
                   const chunk = remaining.substring(0, maxLen);
                   remaining = remaining.substring(maxLen);
                   const prefix = first ? statusIcon : ' ';
-                  console.log(`${colors.magenta}│${colors.reset}   ${prefix} ${colors.dim}${chunk}${colors.reset}`);
+                  
+                  const padLen = BOX_WIDTH - 7 - chunk.length;
+                  const padding = ' '.repeat(Math.max(0, padLen));
+                  console.log(`${colors.magenta}│${colors.reset}   ${prefix} ${colors.dim}${chunk}${colors.reset}${padding}${colors.magenta}│${colors.reset}`);
                   first = false;
                 }
               }
@@ -1676,19 +1684,41 @@ ${colors.reset}
 
     if (this.slashMenu.printedLines) {
       readline.moveCursor(process.stdout, 0, -this.slashMenu.printedLines);
-      readline.clearScreenDown(process.stdout);
     }
 
     process.stdout.write('\n');
+    readline.clearLine(process.stdout, 1);
     process.stdout.write(`${colors.dim}Commands${colors.reset}\n`);
-    matches.forEach((item, index) => {
+    
+    const maxDisplay = 5;
+    const displayedMatches = matches.slice(0, maxDisplay);
+
+    displayedMatches.forEach((item, index) => {
+      readline.clearLine(process.stdout, 1);
       const usage = item.usage ? ` ${colors.dim}${item.usage}${colors.reset}` : '';
       const pointer = index === this.slashMenu.selected ? `${colors.green}>${colors.reset}` : ' ';
       process.stdout.write(`${pointer} ${colors.cyan}${item.cmd}${colors.reset} ${colors.dim}${item.desc}${colors.reset}${usage}\n`);
     });
+
+    if (matches.length > maxDisplay) {
+      readline.clearLine(process.stdout, 1);
+      process.stdout.write(`  ${colors.dim}... và ${matches.length - maxDisplay} lệnh khác (gõ tiếp để lọc)${colors.reset}\n`);
+    }
+
+    readline.clearLine(process.stdout, 1);
     process.stdout.write(`${colors.dim}↑/↓ chọn · Enter/Tab dùng · Esc đóng${colors.reset}\n`);
 
-    this.slashMenu.printedLines = matches.length + 3;
+    // Xóa các dòng thừa nếu số lượng dòng mới ít hơn số lượng dòng cũ
+    const currentLines = Math.min(matches.length, maxDisplay) + 3 + (matches.length > maxDisplay ? 1 : 0);
+    if (this.slashMenu.printedLines > currentLines) {
+      for (let i = 0; i < this.slashMenu.printedLines - currentLines; i++) {
+        readline.clearLine(process.stdout, 1);
+        process.stdout.write('\n');
+      }
+      readline.moveCursor(process.stdout, 0, -(this.slashMenu.printedLines - currentLines));
+    }
+
+    this.slashMenu.printedLines = currentLines;
     this.rl.prompt(true);
   }
 

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 });