winter-super-cli 2026.5.27 → 2026.5.29

package/src/context/resource-loader.js

@@ -0,0 +1,136 @@
+/**
+ * Resource Loader - Auto-discovers and indexes local resources
+ * (design systems, agent instructions, skills) for contextual injection.
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
+const LOCAL_ROOT = path.join(PROJECT_ROOT, 'resources', 'local');
+
+// ── Design Systems ──────────────────────────────────────────────────────────
+
+const DESIGN_MD_DIR = path.join(LOCAL_ROOT, 'awesome-design-md', 'design-md');
+
+/**
+ * Discover all available design system brands.
+ */
+export async function discoverDesignBrands() {
+  try {
+    const entries = await fs.readdir(DESIGN_MD_DIR, { withFileTypes: true });
+    return entries
+      .filter(e => e.isDirectory())
+      .map(e => e.name)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Load a DESIGN.md file for a specific brand.
+ */
+export async function loadDesignMd(brand) {
+  try {
+    const dir = path.join(DESIGN_MD_DIR, brand);
+    const files = ['DESIGN.md', 'README.md'];
+    for (const file of files) {
+      const filePath = path.join(dir, file);
+      await fs.access(filePath);
+      return { brand, file, content: await fs.readFile(filePath, 'utf8') };
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Search design systems by keyword (brand name or description).
+ */
+export async function searchDesignSystems(query) {
+  const brands = await discoverDesignBrands();
+  const q = query.toLowerCase();
+  const matched = brands.filter(b => b.includes(q));
+  return matched.slice(0, 10);
+}
+
+// ── Resource Manifest ──────────────────────────────────────────────────────
+
+const MANIFEST_PATH = path.join(LOCAL_ROOT, 'manifest.json');
+
+export async function loadResourceManifest() {
+  try {
+    const raw = await fs.readFile(MANIFEST_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return { localResources: [] };
+  }
+}
+
+// ── Context Builder ─────────────────────────────────────────────────────────
+
+/**
+ * Build a concise context summary of all available local resources.
+ * Used for automatic injection into system prompts.
+ */
+export async function buildResourceContext() {
+  const manifest = await loadResourceManifest();
+  const resources = manifest.localResources || [];
+  const designBrands = await discoverDesignBrands();
+
+  const parts = [];
+
+  if (resources.length > 0) {
+    parts.push('## Local Resources');
+    resources.forEach(r => {
+      parts.push(`  - ${r.name}: ${r.fileCount} files, ${(r.size / 1024).toFixed(0)}KB`);
+    });
+    parts.push('');
+  }
+
+  if (designBrands.length > 0) {
+    const brandsStr = designBrands.slice(0, 40).join(', ');
+    const leftover = designBrands.length - 40;
+    parts.push(`## Design Systems (${designBrands.length} available)`);
+    parts.push(`  ${brandsStr}${leftover > 0 ? `, +${leftover} more` : ''}`);
+    parts.push('');
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Get a relevant DESIGN.md content based on the task description.
+ * Uses keyword matching between the task text and design system brand names.
+ */
+export async function getRelevantDesignGuide(taskText) {
+  if (!taskText) return null;
+
+  const brands = await discoverDesignBrands();
+  const text = taskText.toLowerCase();
+
+  // Match by brand name in task text
+  for (const brand of brands) {
+    if (text.includes(brand)) {
+      const design = await loadDesignMd(brand);
+      if (design) return design;
+    }
+  }
+
+  // Match by context clues (e.g., "design", "ui", "looks like", "brand")
+  const designHint = /\b(design|ui|looks? like|brand guide|style guide|make it look)\b/i.test(text);
+  if (designHint && brands.length > 0) {
+    // Return the first few brands as options
+    return {
+      brand: null,
+      type: 'design_hint',
+      brands: brands.slice(0, 5),
+      note: 'Design-related task detected. Available design systems listed above.',
+    };
+  }
+
+  return null;
+}

package/src/context/router.js

@@ -11,26 +11,83 @@ function flattenMessageText(messages) {
     : String(messages || '').toLowerCase();
 }
 
-export function selectExecutionProfile({ messages = [], activeProvider = null, providers = {}, options = {} } = {}) {
-  const text = flattenMessageText(messages);
-  const providerNames = Object.keys(providers).filter(name => providers[name]?.ready || providers[name]?.model);
-  const hasProvider = name => providerNames.includes(name);
+import { ReasoningConfig, REASONING_LEVELS } from '../ai/reasoning.js';
+import { classifyModelTier, isSmallModel, getReasoningBump, MODEL_TIERS } from '../ai/model-capabilities.js';
 
-  const explicitProvider = options.provider && hasProvider(options.provider) ? options.provider : null;
-  let provider = explicitProvider || (activeProvider && hasProvider(activeProvider) ? activeProvider : providerNames[0] || null);
-
-  if (explicitProvider) {
-    provider = explicitProvider;
-  } else if (/\b(review|refactor|debug|fix|bug|error|stack trace|test|tool|patch|code)\b/.test(text) && hasProvider('claude')) {
-    provider = 'claude';
-  } else if (/\b(summary|summarize|commit message|changelog|docs|explain|rewrite)\b/.test(text) && hasProvider('openai')) {
-    provider = 'openai';
-  } else if (/\b(local|offline|privacy|private|on-device)\b/.test(text) && hasProvider('ollama')) {
-    provider = 'ollama';
-  } else if (/\b(quick|brief|short|fast)\b/.test(text) && hasProvider('groq')) {
-    provider = 'groq';
-  }
+/**
+ * Bump reasoning level by N steps.
+ */
+function bumpReasoningLevel(level, steps) {
+  const order = [REASONING_LEVELS.NONE, REASONING_LEVELS.LOW, REASONING_LEVELS.MEDIUM, REASONING_LEVELS.HIGH, REASONING_LEVELS.MAX];
+  const idx = order.indexOf(level);
+  if (idx === -1) return level;
+  const newIdx = Math.min(idx + steps, order.length - 1);
+  return order[newIdx];
+}	export function selectExecutionProfile({ messages = [], activeProvider = null, providers = {}, options = {} } = {}) {
+	  const text = flattenMessageText(messages);
+	  const providerNames = Object.keys(providers).filter(name => providers[name]?.ready || providers[name]?.model);
+	  const hasProvider = name => providerNames.includes(name);
+	
+	  const explicitProvider = options.provider && hasProvider(options.provider) ? options.provider : null;
+	  let provider = explicitProvider || (activeProvider && hasProvider(activeProvider) ? activeProvider : providerNames[0] || null);
+	
+	  if (explicitProvider) {
+	    provider = explicitProvider;
+	  } else if (/\b(review|refactor|debug|fix|bug|error|stack trace|test|tool|patch|code)\b/.test(text) && hasProvider('claude')) {
+	    provider = 'claude';
+	  } else if (/\b(summary|summarize|commit message|changelog|docs|explain|rewrite)\b/.test(text) && hasProvider('openai')) {
+	    provider = 'openai';
+	  } else if (/\b(local|offline|privacy|private|on-device)\b/.test(text) && hasProvider('ollama')) {
+	    provider = 'ollama';
+	  } else if (/\b(quick|brief|short|fast)\b/.test(text) && hasProvider('groq')) {
+	    provider = 'groq';
+	  }
+	
+	  const providerConfig = providers[provider] || providers[activeProvider] || {};
+	  const model = options.model || providerConfig.model || providers[activeProvider]?.model || null;
+	
+	  // Detect model capability tier
+	  const modelTier = classifyModelTier(model, provider);
+	  const isSmall = isSmallModel(modelTier);
+	  const reasoningBump = getReasoningBump(modelTier);
+	
+	  // Determine reasoning level based on task complexity signals
+	  // Default: HIGH for coding — all models must think deeply
+	  let reasoningLevel = options.reasoningLevel || REASONING_LEVELS.HIGH;
+	  if (!options.reasoningLevel) {
+	    const hasDeepSignals = /\b(refactor|architecture|redesign|migrate|complex|full stack|e2e|end to end|security|optimize|performance|implement|build|create)\b/.test(text);
+	    const hasComplexSignals = /\b(debug|fix|test|multiple|integrate|design|plan|review|analyze)\b/.test(text);
+	
+	    if (hasDeepSignals && text.length > 30) {
+	      reasoningLevel = REASONING_LEVELS.MAX;
+	    } else if (hasComplexSignals && text.length > 20) {
+	      reasoningLevel = REASONING_LEVELS.MAX;
+	    } else if (text.split(/\s+/).length > 10) {
+	      reasoningLevel = REASONING_LEVELS.HIGH;
+	    } else if (text.split(/\s+/).length < 3) {
+	      reasoningLevel = REASONING_LEVELS.MEDIUM;
+	    } else {
+	      reasoningLevel = REASONING_LEVELS.HIGH;
+	    }
+	
+	    // If small model, bump reasoning level even more to compensate
+	    if (isSmall && reasoningBump > 0) {
+	      reasoningLevel = bumpReasoningLevel(reasoningLevel, reasoningBump);
+	    }
+	  }
 
-  const model = options.model || providers[provider]?.model || providers[activeProvider]?.model || null;
-  return { provider, model };
+  const reasoning = new ReasoningConfig({
+    level: reasoningLevel,
+    provider: provider || activeProvider,
+    modelTier,
+  });
+
+  return {
+    provider,
+    model,
+    modelTier,
+    reasoningLevel,
+    reasoningParam: reasoning.getApiReasoningParam(),
+    reasoningPrompt: reasoning.getPromptInstructions(),
+  };
 }

package/src/tools/executor.js

@@ -470,26 +470,26 @@ export class ToolExecutor {
   }
 
   async executeInternal(toolName, input, context = {}) {
-    input = input && typeof input === 'object' ? input : {};
     toolName = this.normalizeToolName(toolName);
+    input = this.normalizeToolInput(toolName, input);
     const cwd = context.cwd || this.projectPath;
     const resolvedPath = (p) => this.resolveInputPath(p, cwd);
 
     switch (toolName) {
       case 'Read':
-        return await this.readFile(this.resolveInputPath(input.file_path ?? input.path ?? input.file, cwd));
+        return await this.readFile(this.resolveInputPath(input.file_path ?? input.filePath ?? input.filepath ?? input.path ?? input.file ?? input.filename ?? input.target_file ?? input.targetFile, cwd));
       case 'Write':
-        return await this.writeFile(this.resolveInputPath(input.file_path ?? input.path ?? input.file, cwd), input.content);
+        return await this.writeFile(this.resolveInputPath(input.file_path ?? input.filePath ?? input.filepath ?? input.path ?? input.file ?? input.filename ?? input.target_file ?? input.targetFile, cwd), input.content ?? input.text ?? input.data ?? input.value ?? input.body);
       case 'Edit':
         return await this.executeEdit(input, cwd);
       case 'Bash':
-        return await this.bash(input.command ?? input.cmd, input.cwd || cwd, input.timeout, input.shell);
+        return await this.bash(input.command ?? input.cmd ?? input.script ?? input.code ?? input.input, input.cwd || input.path || cwd, input.timeout, input.shell);
       case 'Glob':
         return await this.glob(input.pattern ?? input.glob ?? '**/*', input.cwd || input.path || cwd);
       case 'Grep':
         return await this.grep(
           input.pattern ?? input.query ?? input.q,
-          input.path || cwd,
+          input.path || input.cwd || cwd,
           input.glob,
           input.output_mode,
           {
@@ -519,9 +519,9 @@ export class ToolExecutor {
       case 'BrowserDebug':
         return await this.browserDebug(input.url ?? input.uri, input.action);
       case 'WebFetch':
-        return await this.webFetch(input.url ?? input.uri, input.prompt);
+        return await this.webFetch(input.url ?? input.uri ?? input.href, input.prompt ?? input.query ?? input.extract);
       case 'WebSearch':
-        return await this.webSearch(input.query ?? input.q);
+        return await this.webSearch(input.query ?? input.q ?? input.search ?? input.search_query ?? input.searchQuery);
       case 'NotebookRead':
         return await this.notebookTool.read(this.resolveInputPath(input.notebook_path ?? input.path ?? input.file, cwd));
       case 'NotebookEdit':
@@ -651,41 +651,67 @@ export class ToolExecutor {
   }
 
   normalizeToolName(toolName) {
-    const normalized = String(toolName || '').replace(/[-_\s]/g, '').toLowerCase();
+    const raw = String(toolName || '').trim();
+    const normalized = raw
+      .replace(/^functions[._-]/i, '')
+      .replace(/^tools?[._-]/i, '')
+      .replace(/^winter[._-]/i, '')
+      .replace(/^[\w-]+[.:/](?=[A-Za-z])/i, '')
+      .replace(/[-_\s]/g, '')
+      .toLowerCase();
     const aliases = {
       read: 'Read',
       readfile: 'Read',
+      fileread: 'Read',
       openfile: 'Read',
       viewfile: 'Read',
+      view: 'Read',
       cat: 'Read',
+      getfile: 'Read',
+      readfilecontent: 'Read',
       write: 'Write',
       writefile: 'Write',
+      filewrite: 'Write',
       writetofile: 'Write',
       createfile: 'Write',
       savefile: 'Write',
+      create: 'Write',
+      overwritefile: 'Write',
       edit: 'Edit',
       editfile: 'Edit',
+      fileedit: 'Edit',
       replaceinfile: 'Edit',
       strreplace: 'Edit',
       strreplaceeditor: 'Edit',
+      strreplaceedit: 'Edit',
       applydiff: 'Edit',
+      applypatch: 'Edit',
       patch: 'Edit',
       bash: 'Bash',
       shell: 'Bash',
       command: 'Bash',
       commandexecutor: 'Bash',
       executecommand: 'Bash',
+      runterminalcmd: 'Bash',
+      runterminalcommand: 'Bash',
       runcommand: 'Bash',
+      runcmd: 'Bash',
+      exec: 'Bash',
       terminal: 'Bash',
       powershell: 'Bash',
+      cmd: 'Bash',
       glob: 'Glob',
       listfiles: 'Glob',
+      list: 'Glob',
       ls: 'Glob',
       findfiles: 'Glob',
+      find: 'Glob',
       grep: 'Grep',
       search: 'Grep',
       searchfiles: 'Grep',
+      grepsearch: 'Grep',
       searchtext: 'Grep',
+      searchcode: 'Grep',
       rg: 'Grep',
       rgfull: 'Grep',
       searchadvanced: 'Grep',
@@ -707,12 +733,17 @@ export class ToolExecutor {
       webfetch: 'WebFetch',
       fetch: 'WebFetch',
       fetchurl: 'WebFetch',
+      geturl: 'WebFetch',
       websearch: 'WebSearch',
       searchweb: 'WebSearch',
+      internetsearch: 'WebSearch',
+      googlesearch: 'WebSearch',
       browserdebug: 'BrowserDebug',
       browser: 'BrowserDebug',
+      browserinspect: 'BrowserDebug',
       parallel: 'Parallel',
       parallelexecute: 'Parallel',
+      paralleltools: 'Parallel',
       batch: 'Parallel',
       // New tools
       webarchive: 'WebArchive',
@@ -746,7 +777,45 @@ export class ToolExecutor {
       subagent: 'Agent',
       agentrun: 'Agent',
     };
-    return aliases[normalized] || toolName;
+    return aliases[normalized] || raw;
+  }
+
+  normalizeToolInput(toolName, input) {
+    if (input && typeof input === 'object' && !Array.isArray(input)) {
+      return this.unwrapToolInput(input);
+    }
+
+    if (typeof input !== 'string') return {};
+    const value = input.trim();
+    if (!value) return {};
+
+    switch (toolName) {
+      case 'Read':
+      case 'NotebookRead':
+        return { file_path: value };
+      case 'Write':
+        return { content: value };
+      case 'Bash':
+        return { command: value };
+      case 'Glob':
+        return { pattern: value };
+      case 'Grep':
+      case 'WebSearch':
+        return { query: value };
+      case 'WebFetch':
+      case 'WebArchive':
+      case 'BrowserDebug':
+        return { url: value };
+      case 'TaskCreate':
+      case 'TodoWrite':
+        return { title: value };
+      case 'ScheduleWakeup':
+        return { prompt: value };
+      case 'Agent':
+        return { task: value };
+      default:
+        return { input: value };
+    }
   }
 
   resolveInputPath(filePath, cwd) {