winter-super-cli 2026.5.27 → 2026.5.29

package/src/cli/commands.js

@@ -10,6 +10,7 @@ import { DesignCommands } from '../design/commands.js';
 import { SkillManager } from '../skills/manager.js';
 import { PluginManager } from '../plugins/manager.js';
 import { MCPClient } from '../mcp/client.js';
+import { BenchmarkRunner } from '../ai/benchmark.js';
 import { redactSecrets } from './secret-env.js';
 
 export { redactSecrets } from './secret-env.js';
@@ -45,6 +46,7 @@ export class CommandParser {
     this.commands = {
       chat: this.handleChat.bind(this),
       call: this.handleCallAll.bind(this),
+      benchmark: this.handleBenchmark.bind(this),
       session: this.handleSession.bind(this),
       project: this.handleProject.bind(this),
       skill: this.handleSkill.bind(this),
@@ -158,6 +160,66 @@ export class CommandParser {
     }
   }
 
+  async handleBenchmark(args) {
+    const runner = new BenchmarkRunner(this.ai);
+
+    // Parse arguments: winter benchmark [providers...] [--tasks] [--questions]
+    const providerNames = [];
+    let runTasks = true;
+    let runQuestions = true;
+
+    for (const arg of args) {
+      if (arg === '--tasks-only') {
+        runQuestions = false;
+      } else if (arg === '--questions-only') {
+        runTasks = false;
+      } else if (arg.startsWith('--')) {
+        // skip unknown flags
+      } else {
+        providerNames.push(arg);
+      }
+    }
+
+    // If no providers specified, use active
+    if (providerNames.length === 0) {
+      await this.ai.init();
+      const active = this.ai.getActiveProvider();
+      if (active) providerNames.push(active);
+      // Also add any other ready providers
+      const providers = this.ai.listProviders?.() || [];
+      for (const p of providers) {
+        if (p.name !== active && p.ready && !providerNames.includes(p.name)) {
+          providerNames.push(p.name);
+        }
+      }
+    }
+
+    if (providerNames.length === 0) {
+      console.log(`${colors.yellow}No providers configured. Run 'winter config' first.${colors.reset}`);
+      return;
+    }
+
+    console.log(`\n${colors.dim}Benchmarking providers: ${providerNames.join(', ')}${colors.reset}`);
+    if (!runQuestions) console.log(`${colors.dim}(Coding tasks only)${colors.reset}`);
+    if (!runTasks) console.log(`${colors.dim}(Questions only)${colors.reset}`);
+    console.log('');
+
+    try {
+      const result = await runner.run(providerNames, { questions: runQuestions, tasks: runTasks });
+      console.log(runner.formatResults(result));
+
+      // Save to session history
+      try {
+        await this.session.addToHistory({
+          role: 'system',
+          content: `[Benchmark Results]\n${runner.formatHistorySummary(result)}`,
+        });
+      } catch {}
+    } catch (err) {
+      console.log(`${colors.red}${statusIcons.error} Benchmark failed: ${err.message}${colors.reset}`);
+    }
+  }
+
   async handleSession(args) {
     const [action, ...rest] = args;
 

package/src/cli/context-loader.js

@@ -14,7 +14,7 @@ export class ContextLoader {
   }
 
   getProjectInstructionFiles() {
-    return ['winter.md', 'WINTER.md', 'CLAUDE.md', '.claude/CLAUDE.md'];
+    return ['winter.md', 'WINTER.md', 'CLAUDE.md', '.claude/CLAUDE.md', 'design.md', 'skill.md', 'rule.md'];
   }
 
   async readProjectInstructionFiles() {
@@ -68,6 +68,17 @@ export class ContextLoader {
     };
   }
 
+  async readTextIfExists(filePath, maxChars = 2000) {
+    try {
+      const stat = await fs.stat(filePath).catch(() => null);
+      if (!stat || !stat.isFile()) return '';
+      const content = await fs.readFile(filePath, 'utf8');
+      return this.compactText(content.replace(/^\uFEFF/, ''), maxChars, filePath);
+    } catch {
+      return '';
+    }
+  }
+
   getUserResourcePaths() {
     const home = homedir();
     return {
@@ -180,6 +191,58 @@ export class ContextLoader {
     }
   }
 
+  async getRequiredLocalResourceSummary() {
+    const paths = this.getResourcePaths();
+    const karpathyPath = path.join(paths.karpathy, 'CLAUDE.md');
+    const agentsPath = path.join(paths.agents, 'AGENTS.md');
+    const designReadmePath = path.join(paths.localRoot, 'awesome-design-md', 'README.md');
+
+    const [karpathy, agents, designReadme, designBrands] = await Promise.all([
+      this.readTextIfExists(karpathyPath, 2200),
+      this.readTextIfExists(agentsPath, 1800),
+      this.readTextIfExists(designReadmePath, 1600),
+      this.listPathEntries(paths.designs, 40),
+    ]);
+
+    const hasRequired = Boolean(karpathy || agents || designReadme || designBrands.length > 0);
+    if (!hasRequired) return '';
+
+    const lines = [];
+    lines.push('[Required Local Resource Rules]');
+    lines.push('- These rules are mandatory for every project session and every model size. Do not route quality down for smaller models.');
+    lines.push(`- Karpathy tools: ${path.relative(this.projectPath, karpathyPath)}`);
+    lines.push('  Apply: think before coding, state assumptions when needed, keep solutions simple, make surgical changes, and verify against concrete success criteria.');
+    lines.push(`- Agent rules: ${path.relative(this.projectPath, agentsPath)}`);
+    lines.push('  Apply: inspect source before edits, keep dependency and lockfile changes synced, prefer TypeScript for new TS/Next utilities, and use the appropriate dev/test command for the task.');
+    lines.push(`- Design system corpus: ${path.relative(this.projectPath, designReadmePath)} and ${path.relative(this.projectPath, paths.designs)}`);
+    lines.push('  Apply: for UI/brand/design tasks, search the design-md corpus first and follow the closest existing brand/design guidance instead of inventing style from scratch.');
+    lines.push('- Use Read/Grep/Glob to inspect the full resource files whenever task details require more than this startup summary.');
+
+    const brandNames = designBrands
+      .filter(item => item.isDirectory)
+      .map(item => item.name)
+      .slice(0, 16);
+    if (brandNames.length > 0) {
+      lines.push(`- Available design-md examples include: ${brandNames.join(', ')}${designBrands.length > brandNames.length ? ', ...' : ''}`);
+    }
+
+    const evidence = [];
+    if (/Think Before Coding|Simplicity First|Surgical Changes|Goal-Driven Execution/i.test(karpathy)) {
+      evidence.push('karpathy-tools confirms Think Before Coding, Simplicity First, Surgical Changes, and Goal-Driven Execution.');
+    }
+    if (/development server|dependencies|lockfile|TypeScript/i.test(agents)) {
+      evidence.push('agents.md confirms workflow, dependency, lockfile, and TypeScript guidance.');
+    }
+    if (/design|brand|guideline/i.test(designReadme)) {
+      evidence.push('awesome-design-md provides brand/design guidance to consult on UI work.');
+    }
+    if (evidence.length > 0) {
+      lines.push(`- Startup evidence: ${evidence.join(' ')}`);
+    }
+
+    return lines.join('\n');
+  }
+
   async getProjectSignals() {
     const signals = [];
 

package/src/cli/conversation-format.js

@@ -90,12 +90,15 @@ export function normalizeToolCalls(toolCalls, parseArguments = parseToolArgument
   return toolCalls.map((tc, index) => {
     const fn = tc.function || {};
     const rawArgs = fn.arguments ?? tc.arguments ?? tc.input ?? {};
+    const parsedArgs = parseArguments(rawArgs);
+    const nestedName = parsedArgs?.name || parsedArgs?.tool || parsedArgs?.tool_name;
+    const nestedArgs = parsedArgs?.arguments ?? parsedArgs?.args ?? parsedArgs?.input;
 
     return {
       ...tc,
       id: tc.id || `call-${index}`,
-      toolName: fn.name || tc.name || tc.tool_name || tc.type,
-      toolArgs: parseArguments(rawArgs),
+      toolName: fn.name || tc.name || tc.tool_name || nestedName || tc.type,
+      toolArgs: nestedName && nestedArgs !== undefined ? parseArguments(nestedArgs) : parsedArgs,
     };
   });
 }
@@ -104,26 +107,68 @@ export function extractInlineToolCalls(content, idFactory = index => `inline-${D
   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]] = decodeXmlEntities(param[2].trim());
-    }
+  const pushToolCall = (name, args) => {
     toolCalls.push({
       id: idFactory(toolCalls.length),
       type: 'function',
       function: {
         name,
-        arguments: JSON.stringify(args),
+        arguments: typeof args === 'string' ? args : JSON.stringify(args || {}),
       },
     });
+  };
+
+  const invokePattern = /(?:<minimax:tool_call>\s*)?<invoke\s+name=["']([^"']+)["']>([\s\S]*?)<\/invoke>\s*(?:<\/minimax:tool_call>)?/gi;
+
+  cleaned = cleaned.replace(invokePattern, (_match, name, body) => {
+    const args = {};
+    const paramPattern = /<parameter\s+name=["']([^"']+)["']>([\s\S]*?)<\/parameter>/gi;
+    let param;
+    while ((param = paramPattern.exec(body))) {
+      args[param[1]] = decodeXmlEntities(param[2].trim());
+    }
+    pushToolCall(name, args);
     return '';
   }).trim();
 
+  const namedToolPattern = /<tool_call\s+name=["']([^"']+)["']>([\s\S]*?)<\/tool_call>/gi;
+  cleaned = cleaned.replace(namedToolPattern, (_match, name, body) => {
+    pushToolCall(name, decodeXmlEntities(body.trim()));
+    return '';
+  }).trim();
+
+  const jsonToolPattern = /<tool_call>([\s\S]*?)<\/tool_call>/gi;
+  cleaned = cleaned.replace(jsonToolPattern, (_match, body) => {
+    const parsed = parseToolArguments(decodeXmlEntities(body.trim()));
+    const name = parsed.name || parsed.tool || parsed.tool_name;
+    const args = parsed.arguments ?? parsed.args ?? parsed.input ?? parsed;
+    if (name) pushToolCall(name, args);
+    return name ? '' : _match;
+  }).trim();
+
+  const functionPattern = /<function(?:\s+name=["']([^"']+)["']|=([^>\s]+))>([\s\S]*?)<\/function>/gi;
+  cleaned = cleaned.replace(functionPattern, (_match, quotedName, bareName, body) => {
+    pushToolCall(quotedName || bareName, decodeXmlEntities(body.trim()));
+    return '';
+  }).trim();
+
+  const fencedToolPattern = /```(?:tool|tool_call|function)\s*\n([\s\S]*?)```/gi;
+  cleaned = cleaned.replace(fencedToolPattern, (_match, body) => {
+    const trimmed = body.trim();
+    const parsed = parseToolArguments(trimmed);
+    const name = parsed.name || parsed.tool || parsed.tool_name;
+    if (name) {
+      pushToolCall(name, parsed.arguments ?? parsed.args ?? parsed.input ?? parsed);
+      return '';
+    }
+    const lineMatch = trimmed.match(/^([A-Za-z][\w.-]*)\s+([\s\S]+)$/);
+    if (lineMatch) {
+      pushToolCall(lineMatch[1], lineMatch[2].trim());
+      return '';
+    }
+    return _match;
+  }).trim();
+
   return { content: cleaned, toolCalls };
 }
 
@@ -154,6 +199,12 @@ export function parseToolArguments(rawArgs) {
       } catch {}
     }
 
+    for (const repaired of buildJsonRepairCandidates(extracted || text)) {
+      try {
+        return JSON.parse(repaired);
+      } catch {}
+    }
+
     return {
       __toolArgParseError: error.message,
       __rawToolArgs: text.length > 800 ? `${text.slice(0, 800)}...` : text,
@@ -161,6 +212,33 @@ export function parseToolArguments(rawArgs) {
   }
 }
 
+export function buildJsonRepairCandidates(text) {
+  const value = String(text || '').trim();
+  if (!value) return [];
+  const candidates = [];
+
+  candidates.push(
+    value
+      .replace(/([{,]\s*)([A-Za-z_$][\w$-]*)(\s*:)/g, '$1"$2"$3')
+      .replace(/:\s*'([^'\\]*(?:\\.[^'\\]*)*)'/g, (_m, inner) => `: "${inner.replace(/"/g, '\\"')}"`)
+      .replace(/:\s*([^'",{}\[\]\r\n][^,}\]\r\n]*)/g, (_m, inner) => {
+        const trimmed = inner.trim();
+        if (trimmed.startsWith('"')) return `: ${trimmed}`;
+        if (/^(true|false|null|-?\d+(?:\.\d+)?)$/i.test(trimmed)) return `: ${trimmed}`;
+        return `: "${trimmed.replace(/"/g, '\\"')}"`;
+      })
+      .replace(/,\s*([}\]])/g, '$1')
+  );
+
+  candidates.push(
+    value
+      .replace(/'/g, '"')
+      .replace(/,\s*([}\]])/g, '$1')
+  );
+
+  return [...new Set(candidates)].filter(candidate => candidate && candidate !== value);
+}
+
 export function extractFirstJsonObject(text) {
   const start = text.indexOf('{');
   if (start === -1) return null;

package/src/cli/prompt-builder.js

@@ -3,8 +3,9 @@
  * Extracted from WinterREPL to reduce repl.js size.
  */
 export class PromptBuilder {
-  constructor({ session, tools, projectPath, sessionPermissionGrants, compactText, summarizePrompts } = {}) {
+  constructor({ session, ai, tools, projectPath, sessionPermissionGrants, compactText, summarizePrompts } = {}) {
     this.session = session;
+    this.ai = ai;
     this.tools = tools;
     this.projectPath = projectPath;
     this.sessionPermissionGrants = sessionPermissionGrants;
@@ -13,10 +14,12 @@ export class PromptBuilder {
   }
 
   buildSessionSignalsPrompt() {
-    const activeProvider = this.session?.ai?.getActiveProvider?.() || 'unavailable';
-    const activeModel = this.session?.ai?.providers?.[activeProvider]?.model || 'unavailable';
+    const activeProvider = this.ai?.getActiveProvider?.() || 'unavailable';
+    const activeModel = this.ai?.providers?.[activeProvider]?.model || 'unavailable';
     const sessionContext = this.session?.getContext?.() || {};
-    const activeSkills = sessionContext.activeSkills?.value || [];
+    const activeSkills = Array.isArray(sessionContext.activeSkills?.value)
+      ? sessionContext.activeSkills.value
+      : (Array.isArray(sessionContext.activeSkills) ? sessionContext.activeSkills : []);
     const toolAllowlist = [...(this.sessionPermissionGrants || [])];
 
     return [
@@ -29,15 +32,25 @@ export class PromptBuilder {
     ].join('\n');
   }
 
-  buildSystemPrompt(context = '') {
+  getRequiredLocalResources() {
+    const sessionContext = this.session?.getContext?.() || {};
+    const value = sessionContext.requiredLocalResources?.value ?? sessionContext.requiredLocalResources;
+    return typeof value === 'string' ? value : '';
+  }
+
+  buildSystemPrompt(context = '', options = {}) {
     const memories = this.session?.getMemory?.() || [];
     const plans = this.session?.getPlans?.() || [];
     const sessionContext = this.session?.getContext?.() || {};
     const environmentSummary = this.tools?.getRuntimeEnvironmentSummary?.() || this._defaultEnvironmentSummary();
+    const requiredLocalResources = this.getRequiredLocalResources();
 
     const memoryStr = memories.length > 0
       ? this._formatMemories(memories)
       : '';
+    const requiredResourcesStr = requiredLocalResources
+      ? `\n## Required Local Resource Rules\n${this._compactText(requiredLocalResources, 1800, 'required local resources')}`
+      : '';
     const plansStr = plans.length > 0
       ? this._formatPlans(plans)
       : '';
@@ -56,20 +69,22 @@ export class PromptBuilder {
       environmentSummary,
       ``,
       `## Core Principles`,
+      `0. Required Local Resources - Always follow Required Local Resource Rules when present; they override generic behavior.`,
       `1. Think Before Coding — State assumptions, ask when uncertain, surface tradeoffs.`,
       `2. Simplicity First — Minimum code that solves the problem. Nothing speculative.`,
       `3. Surgical Changes — Touch only what you must. Clean up only your own mess.`,
       `4. Goal-Driven Execution — Define success criteria. Loop until verified.`,
       ``,
       `## Tool Usage`,
-      `You have access to various tools (Read, Write, Edit, Bash, Glob, Grep, etc.).`,
-      `Use tools proactively. If you need information, look it up — don't guess.`,
+      `Use tools when they materially help. For coding tasks: inspect first, edit second, verify third.`,
+      `Prefer Read/Grep/Glob before editing. Use Write/Edit for file changes.`,
+      `When a task touches coding, agents, UI, brand, or design, inspect the relevant required local resource in depth before deciding.`,
       ``,
       `## Session`,
       `Working directory: ${this.projectPath}`,
       `Current session: ${this.session?.getSessionId?.()?.substring(0, 8) || 'unknown'}`,
-      `${memoryStr}${plansStr}${skillsStr}${startupPlanStr}${sessionSignalsStr}`,
-      context ? `\n## Project Context\n${this._compactText(context, 6000, 'project context')}` : '',
+      `${requiredResourcesStr}${memoryStr}${plansStr}${skillsStr}${startupPlanStr}${sessionSignalsStr}`,
+      context ? `\n## Project Context\n${this._compactText(context, options.projectContextBudget || 3200, 'project context')}` : '',
       ``,
       `Be helpful, be precise, and get things done. Always respond in Vietnamese.`,
     ].join('\n');
@@ -77,6 +92,10 @@ export class PromptBuilder {
 
   buildFastSystemPrompt() {
     const memories = this.session?.getMemory?.() || [];
+    const requiredLocalResources = this.getRequiredLocalResources();
+    const requiredResourcesStr = requiredLocalResources
+      ? `\nQuy tac resource bat buoc:\n${this._compactText(requiredLocalResources, 900, 'required local resources')}`
+      : '';
     const memoryStr = memories.length > 0
       ? `\nContext nhớ ngắn:\n${this._summarizePrompts(memories.slice(-8), {
           limit: 8,
@@ -90,6 +109,8 @@ export class PromptBuilder {
       'Bạn là Winter, trợ lý AI trả lời ngắn gọn bằng tiếng Việt.',
       'Ưu tiên dùng tool và context khi cần; không bịa thông tin.',
       'Nếu người dùng yêu cầu sửa file/chạy lệnh/đọc dự án thì hãy gọi tool tương ứng thay vì chỉ nói chung chung.',
+      'Luon tuan thu Required Local Resource Rules neu co; khong ha chat luong theo model.',
+      requiredResourcesStr,
       memoryStr,
     ].filter(Boolean).join('\n');
   }
@@ -98,9 +119,13 @@ export class PromptBuilder {
     const memories = this.session?.getMemory?.() || [];
     const plans = this.session?.getPlans?.() || [];
     const sessionContext = this.session?.getContext?.() || {};
+    const requiredLocalResources = this.getRequiredLocalResources();
 
-    const memoryStr = memories.length > 0 ? this._formatMemories(memories) : '';
-    const plansStr = plans.length > 0 ? this._formatPlans(plans) : '';
+    const memoryStr = memories.length > 0 ? this._formatMemories(memories, { maxTotalChars: 900 }) : '';
+    const requiredResourcesStr = requiredLocalResources
+      ? `\n## Required Local Resource Rules\n${this._compactText(requiredLocalResources, 1600, 'required local resources')}`
+      : '';
+    const plansStr = plans.length > 0 ? this._formatPlans(plans, { maxTotalChars: 900 }) : '';
     const skillsStr = Array.isArray(sessionContext.activeSkills) && sessionContext.activeSkills.length > 0
       ? `\n## Auto-applied Skills\n${sessionContext.activeSkills.slice(0, 12).map(skill => `- ${skill}`).join('\n')}${sessionContext.activeSkills.length > 12 ? '\n- ...' : ''}`
       : '';
@@ -124,6 +149,7 @@ export class PromptBuilder {
 
     return [
       '## CRITICAL AI RULES (MUST FOLLOW STRICTLY):',
+      '0. [REQUIRED LOCAL RESOURCES]: Always obey Required Local Resource Rules when present. They override generic behavior and apply to every model size.',
       '1. [THINKING BEFORE CODING]: State assumptions, constraints, and a brief plan before making changes. Be thorough enough to be useful, and do not invent facts.',
       '2. [DESIGN EXCELLENCE]: Use rich aesthetics. Default to modern UI frameworks if applicable. Never output plain, ugly HTML/CSS. Ensure responsive, premium feel with micro-animations.',
       '3. [CODE QUALITY]: Write clean, modular, SOLID code. Check for syntax errors carefully. Do not generate incomplete code blocks.',
@@ -143,27 +169,27 @@ export class PromptBuilder {
       '## Project',
       `Working directory: ${this.projectPath}`,
       `Current session: ${this.session?.getSessionId?.()?.substring(0, 8) || 'unknown'}`,
-      `${memoryStr}${plansStr}${skillsStr}${startupPlanStr}`,
-      context ? `\n## Project Context\n${this._compactText(context, 6000, 'project context')}` : '',
+      `${requiredResourcesStr}${memoryStr}${plansStr}${skillsStr}${startupPlanStr}`,
+      context ? `\n## Project Context\n${this._compactText(context, 3200, 'project context')}` : '',
     ].join('\n');
   }
 
   /** @private */
-  _formatMemories(memories) {
+  _formatMemories(memories, options = {}) {
     return `\n## Memories (Important Context)\n${this._summarizePrompts(memories, {
       limit: 8,
       maxEntryChars: 220,
-      maxTotalChars: 1600,
+      maxTotalChars: options.maxTotalChars || 1200,
       mapper: memory => memory.text,
     })}`;
   }
 
   /** @private */
-  _formatPlans(plans) {
+  _formatPlans(plans, options = {}) {
     return `\n## Active Plans & Tasks\n${this._summarizePrompts(plans, {
       limit: 6,
       maxEntryChars: 260,
-      maxTotalChars: 1600,
+      maxTotalChars: options.maxTotalChars || 1200,
       mapper: plan => `[${plan.status}] ${plan.title}: ${plan.description}`,
     })}`;
   }

package/src/cli/repl-commands.js

@@ -1,5 +1,6 @@
 import path from 'path';
 import { colors } from './snowflake-logo.js';
+import { SLASH_COMMANDS } from './slash-commands.js';
 
 /**
  * Handle slash commands in the Winter REPL.
@@ -293,10 +294,21 @@ export async function handleSlashCommand(repl, input) {
       break;
     case '/model':
       if (args[0]) {
-        await repl.tools.execute('SetModel', { model: args[0] });
-        console.log(`${colors.green}✓ Model set to ${args[0]}${colors.reset}`);
+        const providerName = repl.ai?.getActiveProvider?.();
+        const model = args.join(' ');
+        if (!providerName) {
+          console.log(`${colors.red}No active provider${colors.reset}`);
+          break;
+        }
+        await repl.config?.setProviderModel?.(providerName, model);
+        if (repl.ai?.providers?.[providerName]) {
+          repl.ai.providers[providerName].model = model;
+        }
+        repl.ai?.updateActiveModelTier?.();
+        console.log(`${colors.green}OK Model for ${providerName}: ${model}${colors.reset}`);
       } else {
-        console.log(`${colors.yellow}Usage: /model <id>${colors.reset}`);
+        const providerName = repl.ai?.getActiveProvider?.();
+        console.log(`${colors.cyan}Model: ${repl.ai?.providers?.[providerName]?.model || 'unknown'}${colors.reset}`);
       }
       break;
     case '/models':