winter-super-cli 2026.5.26 → 2026.5.28

package/src/ai/providers.js

@@ -3,6 +3,20 @@
  * Full Claude Code / Codex compatible AI integration
  */
 
+import { withRetry } from '../tools/retry.js';
+import { selectExecutionProfile } from '../context/router.js';
+import { buildSystemPrompt, buildFastSystemPrompt, buildAgentSystemPrompt } from './prompts/system-prompt.js';
+import { classifyTask } from './prompts/task-classifier.js';
+import SuccessCriteria from './prompts/success-criteria.js';
+import { ReasoningConfig, REASONING_LEVELS, complexityToReasoningLevel } from './reasoning.js';
+import { buildResourceContext, getRelevantDesignGuide } from '../context/resource-loader.js';
+import { classifyModelTier } from './model-capabilities.js';
+
+function isAuthError(error) {
+  const msg = String(error?.message || error || '');
+  return /\b(401|403)\b/.test(msg) || /authentication_error|invalid_api_key|unauthorized|auth\s*failed/i.test(msg);
+}
+
 export class AIProviderManager {
   constructor(config) {
     this.config = config;
@@ -12,24 +26,29 @@ export class AIProviderManager {
     this.tools = [];
     this.initialized = false;
     this.authToken = null;
+    this._cachedResourceContext = '';
+    this._cachedDesignGuide = null;
+    this._fallbackWarned = false;
+    this._modelTier = null;
   }
 
   async init() {
     if (this.initialized) return;
 
     const cfg = await this.config.load();
+    const claudeConfig = cfg.claude || cfg.anthropic || null;
 
     // Load auth token from Claude Code's auth.json if available
     this.authToken = await this.loadAuthToken();
 
-    if (cfg.claude?.baseURL || this.authToken) {
+    if (claudeConfig?.baseURL || this.authToken) {
       this.providers.claude = {
         name: 'Claude-compatible API',
-        baseURL: cfg.claude?.baseURL || 'http://localhost:4000/v1',
+        baseURL: claudeConfig?.baseURL || 'http://localhost:4000/v1',
         authToken: this.authToken,
-        apiKey: cfg.claude?.apiKey,
-        model: cfg.claude?.model || 'nvidia/moonshotai/kimi-k2.6',
-        ready: !!this.authToken || !!cfg.claude?.apiKey || cfg.claude?.apiKey === 'not-required',
+        apiKey: claudeConfig?.apiKey,
+        model: claudeConfig?.model || 'nvidia/moonshotai/kimi-k2.6',
+        ready: !!this.authToken || !!claudeConfig?.apiKey || claudeConfig?.apiKey === 'not-required',
       };
     }
 
@@ -74,7 +93,9 @@ export class AIProviderManager {
     }
 
     // Set default
-    const defaultProvider = cfg.defaultProvider || 'claude';
+    const defaultProvider = this.normalizeProviderName(cfg.defaultProvider || 'claude') === 'anthropic'
+      ? 'claude'
+      : this.normalizeProviderName(cfg.defaultProvider || 'claude');
     this.activeProvider = this.providers[defaultProvider] ? defaultProvider : 'claude';
 
     if (!this.providers[this.activeProvider]?.ready) {
@@ -82,6 +103,13 @@ export class AIProviderManager {
       if (available) this.activeProvider = available;
     }
 
+    // Auto-detect model capability tier
+    const providerConfig = this.providers[this.activeProvider] || {};
+    this._modelTier = classifyModelTier(providerConfig.model, this.activeProvider);
+
+    // Eager-load local resources (design systems, agent instructions) for contextual injection
+    this._loadResourceContext(); // fire-and-forget
+
     this.initialized = true;
   }
 
@@ -173,6 +201,19 @@ export class AIProviderManager {
     }));
   }
 
+  selectExecutionProfile(messageOrMessages, options = {}) {
+    const messages = typeof messageOrMessages === 'string'
+      ? [{ role: 'user', content: messageOrMessages }]
+      : messageOrMessages;
+
+    return selectExecutionProfile({
+      messages,
+      activeProvider: this.activeProvider,
+      providers: this.providers,
+      options,
+    });
+  }
+
   setTools(tools) {
     this.tools = tools;
   }
@@ -193,14 +234,79 @@ export class AIProviderManager {
 
   async sendRequest(messages, options = {}) {
     await this.init();
-    const provider = this.providers[this.activeProvider];
-    return await this.sendRequestToProvider(provider, messages, options);
+    const executionProfile = selectExecutionProfile({
+      messages,
+      activeProvider: this.activeProvider,
+      providers: this.providers,
+      options,
+    });
+    const routedProvider = this.providers[executionProfile.provider] || this.providers[this.activeProvider];
+    const defaultProvider = this.providers[this.activeProvider];
+
+    const routingModel = options.model || executionProfile.model;
+    const routingReasoning = options.reasoning || executionProfile.reasoningParam;
+
+    try {
+      return await withRetry(() => this.sendRequestToProvider(routedProvider, messages, {
+        ...options,
+        model: routingModel,
+        reasoning: routingReasoning,
+        reasoningLevel: options.reasoningLevel || executionProfile.reasoningLevel,
+      }), { maxAttempts: 3, baseDelayMs: 150 });
+    } catch (error) {
+      if (isAuthError(error) && routedProvider !== defaultProvider && defaultProvider) {
+        if (!this._fallbackWarned) {
+          console.warn(`[winter] ${executionProfile.provider} auth error, falling back to ${this.activeProvider}`);
+          this._fallbackWarned = true;
+        }
+        return await withRetry(() => this.sendRequestToProvider(defaultProvider, messages, {
+          ...options,
+          model: options.model || defaultProvider.model,
+          reasoning: routingReasoning,
+          reasoningLevel: options.reasoningLevel || executionProfile.reasoningLevel,
+        }), { maxAttempts: 1, baseDelayMs: 0 });
+      }
+      throw error;
+    }
   }
 
   async *streamRequest(messages, options = {}) {
     await this.init();
-    const provider = this.providers[this.activeProvider];
-    yield* this.streamRequestToProvider(provider, messages, options);
+    const executionProfile = selectExecutionProfile({
+      messages,
+      activeProvider: this.activeProvider,
+      providers: this.providers,
+      options,
+    });
+    const routedProvider = this.providers[executionProfile.provider] || this.providers[this.activeProvider];
+    const defaultProvider = this.providers[this.activeProvider];
+
+    const routingModel = options.model || executionProfile.model;
+    const routingReasoning = options.reasoning || executionProfile.reasoningParam;
+
+    try {
+      yield* this.streamRequestToProvider(routedProvider, messages, {
+        ...options,
+        model: routingModel,
+        reasoning: routingReasoning,
+        reasoningLevel: options.reasoningLevel || executionProfile.reasoningLevel,
+      });
+    } catch (error) {
+      if (isAuthError(error) && routedProvider !== defaultProvider && defaultProvider) {
+        if (!this._fallbackWarned) {
+          console.warn(`[winter] ${executionProfile.provider} auth error, falling back to ${this.activeProvider}`);
+          this._fallbackWarned = true;
+        }
+        yield* this.streamRequestToProvider(defaultProvider, messages, {
+          ...options,
+          model: options.model || defaultProvider.model,
+          reasoning: routingReasoning,
+          reasoningLevel: options.reasoningLevel || executionProfile.reasoningLevel,
+        });
+      } else {
+        throw error;
+      }
+    }
   }
 
   async sendRequestToProvider(provider, messages, options = {}) {
@@ -213,6 +319,17 @@ export class AIProviderManager {
       messages,
     };
 
+    // Apply reasoning configuration
+    const reasoningParam = options.reasoning || this._getReasoningParam(options, provider);
+    if (reasoningParam) {
+      if (reasoningParam.reasoning_effort) {
+        body.reasoning_effort = reasoningParam.reasoning_effort;
+      }
+      if (reasoningParam.thinking) {
+        body.thinking = reasoningParam.thinking;
+      }
+    }
+
     if (this.tools.length > 0 && options.enableTools) {
       body.tools = this.tools;
     }
@@ -257,6 +374,17 @@ export class AIProviderManager {
       body.stream_options = { include_usage: true };
     }
 
+    // Apply reasoning configuration
+    const reasoningParam = options.reasoning || this._getReasoningParam(options, provider);
+    if (reasoningParam) {
+      if (reasoningParam.reasoning_effort) {
+        body.reasoning_effort = reasoningParam.reasoning_effort;
+      }
+      if (reasoningParam.thinking) {
+        body.thinking = reasoningParam.thinking;
+      }
+    }
+
     if (this.tools.length > 0 && options.enableTools) {
       body.tools = this.tools;
     }
@@ -447,22 +575,118 @@ export class AIProviderManager {
     return { error: 'Tool execution handled by REPL' };
   }
 
-  getSystemPrompt() {
-    return `You are Winter, an expert AI coding assistant.
+  _getReasoningParam(options, provider) {
+    // 1. Explicit reasoning param passed through options
+    if (options.reasoning) return options.reasoning;
+
+    // 2. Reasoning level specified -> build from level
+    if (options.reasoningLevel) {
+      const config = new ReasoningConfig({
+        level: options.reasoningLevel,
+        provider: provider?.name || this.activeProvider,
+      });
+      return config.getApiReasoningParam();
+    }
+
+    // 3. No reasoning config at all
+    return null;
+  }
+
+  getSystemPrompt(options = {}) {
+    const taskInfo = options.task ? classifyTask(options.task) : null;
+    const tools = this.tools ? Object.keys(this.tools) : [];
+    const sessionInfo = {
+      memory: options.memory || [],
+      plans: options.plans || [],
+    };
+
+    // Inject reasoning instructions if applicable
+    let reasoningPrompt = '';
+    if (options.reasoningLevel || options.reasoningPrompt) {
+      reasoningPrompt = options.reasoningPrompt || new ReasoningConfig({
+        level: options.reasoningLevel || REASONING_LEVELS.MEDIUM,
+        provider: this.activeProvider,
+        modelTier: this._modelTier,
+      }).getPromptInstructions();
+    } else if (taskInfo) {
+      // Auto-inject based on task complexity for providers without API reasoning
+      const level = complexityToReasoningLevel(taskInfo.type);
+      const config = new ReasoningConfig({
+        level,
+        provider: this.activeProvider,
+        modelTier: this._modelTier,
+      });
+      if (config.needsPromptInjection && level !== REASONING_LEVELS.NONE) {
+        reasoningPrompt = config.getPromptInstructions();
+      }
+    }
+
+    if (options.role === 'agent') {
+      return buildAgentSystemPrompt(options.agentRole || 'coding', { tools, modelTier: this._modelTier }) + reasoningPrompt;
+    }
+
+    if (options.fast) {
+      return buildFastSystemPrompt({ role: 'coding', tools, modelTier: this._modelTier });
+    }
+
+    const successPrompt = options.task
+      ? '\n\n' + SuccessCriteria.fromRequest(options.task).buildPrompt()
+      : '';
+
+    // Use cached resource context (eager-loaded in init())
+    const resourceContext = this._cachedResourceContext || '';
+
+    // Auto-detect relevant design guide for UI/design tasks
+    let designGuide = null;
+    if (taskInfo && (taskInfo.category === 'design' || taskInfo.category === 'ui')) {
+      this._designGuidePromise = this._designGuidePromise || this._loadDesignGuide(options.task);
+    }
+    const design = this._cachedDesignGuide || null;
+
+    return buildSystemPrompt({
+      role: taskInfo?.category || 'coding',
+      context: taskInfo,
+      tools,
+      session: sessionInfo,
+      design,
+      resourceContext,
+      modelTier: this._modelTier,
+    }) + reasoningPrompt + successPrompt;
+  }
+
+  /**
+   * Load resource context (cached for session lifetime).
+   */
+  async _loadResourceContext() {
+    try {
+      this._cachedResourceContext = await buildResourceContext();
+    } catch (e) {
+      this._cachedResourceContext = '';
+    }
+    return this._cachedResourceContext;
+  }
 
-## Core Principles
-1. **Think Before Coding** - State assumptions, ask when unclear
-2. **Simplicity First** - Minimum code that solves the problem
-3. **Surgical Changes** - Touch only what you must
-4. **Goal-Driven Execution** - Define success criteria, verify results
+  /**
+   * Load relevant design guide for a task.
+   */
+  async _loadDesignGuide(task) {
+    try {
+      const guide = await getRelevantDesignGuide(task);
+      if (guide) {
+        this._cachedDesignGuide = guide;
+      }
+    } catch (e) {
+      // Silently fail - design context is optional
+    }
+    return this._cachedDesignGuide;
+  }
 
-## Tools
-You have access to tools: Read, Write, Edit, Bash, Glob, Grep, TaskCreate, TaskUpdate
+  classifyTask(userInput) {
+    return classifyTask(userInput);
+  }
 
-Use tools when they help. Be proactive.
-After using tools, always provide a direct final answer to the user.
-Answer normal questions directly without unnecessary legal or policy disclaimers.
-If a request is illegal, unsafe, or harmful, refuse briefly and offer a safe alternative.`;
+  buildSuccessCriteria(userInput) {
+    return SuccessCriteria.fromRequest(userInput);
   }
 
   clearCache() {

package/src/ai/reasoning.js

@@ -0,0 +1,266 @@
+/**
+ * Reasoning Configuration Manager
+ * 
+ * Controls reasoning effort / extended thinking per provider and task complexity.
+ * 
+ * Supported APIs:
+ * - OpenAI: reasoning_effort ("low" | "medium" | "high") — o1, o3 models
+ * - Anthropic: thinking ({ type: "enabled", budget_tokens: number }) — Claude 3.7+ Sonnet
+ * - DeepSeek: built-in CoT reasoning (no explicit param needed)
+ * - Others: falls back to prompt-level reasoning instructions
+ */
+
+import { isSmallModel } from './model-capabilities.js';
+
+export const REASONING_LEVELS = {
+  NONE: 'none',
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high',
+  MAX: 'max',
+};
+
+const REASONING_EFFORT_MAP = {
+  [REASONING_LEVELS.NONE]: null,
+  [REASONING_LEVELS.LOW]: 'low',
+  [REASONING_LEVELS.MEDIUM]: 'medium',
+  [REASONING_LEVELS.HIGH]: 'high',
+  [REASONING_LEVELS.MAX]: 'high',
+};
+
+const EXTENDED_THINKING_BUDGET_MAP = {
+  [REASONING_LEVELS.NONE]: null,
+  [REASONING_LEVELS.LOW]: 1024,
+  [REASONING_LEVELS.MEDIUM]: 4096,
+  [REASONING_LEVELS.HIGH]: 8192,
+  [REASONING_LEVELS.MAX]: 16384,
+};
+
+/**
+ * Standard reasoning prompt templates for API-level reasoning models.
+ */
+/**
+ * Unified deep reasoning prompts — ALL models use these aggressive templates.
+ * Every model, regardless of size, must think step by step with explicit structure.
+ * The structured <thinking> format forces deep reasoning, catches edge cases,
+ * and produces significantly higher quality code.
+ */
+const REASONING_PROMPT_TEMPLATES = {
+  [REASONING_LEVELS.NONE]: '',
+  [REASONING_LEVELS.LOW]:
+    'Think step by step before responding. Use <thinking> tags for your reasoning, then provide your answer.',
+  [REASONING_LEVELS.MEDIUM]:
+    'CRITICAL: You MUST think step by step inside <thinking> tags before every response.\n' +
+    '\n' +
+    '<thinking>\n' +
+    '1. What is the user asking for? (restate briefly)\n' +
+    '2. What do I know / what files do I need?\n' +
+    '3. What is the correct approach?\n' +
+    '4. What could go wrong? (edge cases, errors)\n' +
+    '5. How do I verify my solution?\n' +
+    '</thinking>\n' +
+    'Then provide your answer clearly and directly.',
+  [REASONING_LEVELS.HIGH]:
+    'CRITICAL DEEP REASONING REQUIRED. Use this EXACT structured thinking process:\n' +
+    '\n' +
+    '<thinking>\n' +
+    '## STEP 1: UNDERSTAND\n' +
+    '- Restate the problem in your own words\n' +
+    '- Identify all key requirements (explicit + implicit)\n' +
+    '\n' +
+    '## STEP 2: ANALYZE\n' +
+    '- What information is provided? What is missing?\n' +
+    '- Consider multiple approaches\n' +
+    '- List potential edge cases and pitfalls\n' +
+    '\n' +
+    '## STEP 3: PLAN\n' +
+    '- Outline your solution step by step\n' +
+    '- For code: plan the exact files and changes needed\n' +
+    '- Verify each step makes sense\n' +
+    '\n' +
+    '## STEP 4: VERIFY\n' +
+    '- Check your solution against all requirements\n' +
+    '- Look for mistakes, regressions, or missing pieces\n' +
+    '- How will you confirm it works?\n' +
+    '</thinking>\n' +
+    'After thinking, provide your final answer. The thinking is internal — be concise in your response.',
+  [REASONING_LEVELS.MAX]:
+    '## MANDATORY DEEP REASONING\n' +
+    'You MUST do extremely thorough reasoning before every response. Do not skip any step.\n' +
+    '\n' +
+    'Follow this EXACT thinking structure — fill out every section:\n' +
+    '\n' +
+    '<thinking>\n' +
+    '## PROBLEM RESTATEMENT\n' +
+    'State what the user needs in one sentence.\n' +
+    '\n' +
+    '## REQUIREMENTS ANALYSIS\n' +
+    '- Explicit requirements:\n' +
+    '- Implicit requirements:\n' +
+    '- Constraints / boundaries:\n' +
+    '\n' +
+    '## CONTEXT & CODEBASE ANALYSIS\n' +
+    '- What files are relevant?\n' +
+    '- What existing patterns should I follow?\n' +
+    '- What assumptions am I making?\n' +
+    '\n' +
+    '## APPROACH COMPARISON\n' +
+    '- Option 1: [describe]\n' +
+    '  Pros: ... Cons: ...\n' +
+    '- Option 2: [describe]\n' +
+    '  Pros: ... Cons: ...\n' +
+    '- Best choice: [pick and explain why]\n' +
+    '\n' +
+    '## IMPLEMENTATION PLAN\n' +
+    'Step-by-step what needs to happen:\n' +
+    '1. ...\n' +
+    '2. ...\n' +
+    '3. ...\n' +
+    '(For code: include exact files to read, edit, or create)\n' +
+    '\n' +
+    '## EDGE CASES & RISKS\n' +
+    '- What could go wrong?\n' +
+    '- How will I handle errors?\n' +
+    '- What about performance / security?\n' +
+    '\n' +
+    '## VERIFICATION STRATEGY\n' +
+    '- How will I confirm this works?\n' +
+    '- What tests or checks should be run?\n' +
+    '- What could break with these changes?\n' +
+    '</thinking>\n' +
+    '\n' +
+    'After closing </thinking>, provide your final implementation.\n' +
+    'Keep the reasoning internal — only show the user your result and a brief summary.',
+};
+
+/**
+ * Maps task complexity to recommended reasoning level.
+ */
+export function complexityToReasoningLevel(taskType) {
+  switch (taskType) {
+    case 'quick': return REASONING_LEVELS.NONE;
+    case 'simple': return REASONING_LEVELS.LOW;
+    case 'moderate': return REASONING_LEVELS.MEDIUM;
+    case 'complex': return REASONING_LEVELS.HIGH;
+    case 'deep': return REASONING_LEVELS.MAX;
+    default: return REASONING_LEVELS.MEDIUM;
+  }
+}
+
+export class ReasoningConfig {
+  /**
+   * @param {object} options
+   * @param {string} options.level - One of REASONING_LEVELS
+   * @param {string} options.provider - Provider name (for API-specific config)
+   * @param {string} [options.modelTier] - Model capability tier from model-capabilities.js
+   * @param {object} [options.modelInfo] - Model metadata
+   * @param {object} [options.taskInfo] - Task classification result from task-classifier
+   */
+  constructor(options = {}) {
+    this.level = options.level || REASONING_LEVELS.MEDIUM;
+    this.provider = options.provider || '';
+    this.modelTier = options.modelTier || null;
+    this.modelInfo = options.modelInfo || {};
+    this.taskInfo = options.taskInfo || null;
+  }
+
+  /**
+   * Whether reasoning is enabled at all.
+   */
+  get enabled() {
+    return this.level !== REASONING_LEVELS.NONE && this.level !== null;
+  }
+
+  /**
+   * Whether this level should inject reasoning instructions into the system prompt.
+   */
+  get needsPromptInjection() {
+    return this.providerSupportsApiReasoning === false || !this.provider;
+  }
+
+  /**
+   * Check if provider has native API-level reasoning support.
+   */
+  get providerSupportsApiReasoning() {
+    const p = (this.provider || '').toLowerCase();
+    if (p === 'openai') return true;
+    if (p === 'anthropic' || p === 'claude') return true;
+    return false;
+  }
+
+  /**
+   * Whether this is a small model that needs aggressive prompting.
+   */
+  get isSmall() {
+    return this.modelTier ? isSmallModel(this.modelTier) : false;
+  }
+
+  /**
+   * Get the API-level reasoning parameter for the request body.
+   * Returns null if provider doesn't support API reasoning or level is NONE.
+   */
+  getApiReasoningParam() {
+    if (!this.enabled) return null;
+
+    const p = (this.provider || '').toLowerCase();
+
+    if (p === 'openai') {
+      const effort = REASONING_EFFORT_MAP[this.level];
+      if (!effort) return null;
+      return { reasoning_effort: effort };
+    }
+
+    if (p === 'anthropic' || p === 'claude') {
+      const budget = EXTENDED_THINKING_BUDGET_MAP[this.level];
+      if (!budget) return null;
+      return {
+        thinking: {
+          type: 'enabled',
+          budget_tokens: budget,
+        },
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Get reasoning prompt instructions to inject into the system prompt.
+   * ALL models use the unified deep-reasoning templates.
+   * @param {string} [modelTier] - Unused, kept for backward compatibility.
+   * @returns {string}
+   */
+  getPromptInstructions(modelTier) {
+    if (!this.enabled || this.providerSupportsApiReasoning) return '';
+    return REASONING_PROMPT_TEMPLATES[this.level] || '';
+  }
+
+  /**
+   * Build a reasoning config for a given provider and task info.
+   */
+  static fromTask(taskInfo, provider, options = {}) {
+    const level = options.reasoningLevel
+      || (taskInfo ? complexityToReasoningLevel(taskInfo.type) : REASONING_LEVELS.MEDIUM);
+
+    return new ReasoningConfig({
+      level,
+      provider: provider || '',
+      taskInfo: taskInfo || null,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Default reasoning configuration for the system.
+ */
+export const DEFAULT_REASONING_CONFIG = {
+  defaultLevel: REASONING_LEVELS.MEDIUM,
+  maxBudgetTokens: 16384,
+  // Per-provider overrides
+  providers: {
+    openai: { supports: true, paramType: 'reasoning_effort' },
+    anthropic: { supports: true, paramType: 'thinking' },
+    claude: { supports: true, paramType: 'thinking' },
+  },
+};