winter-super-cli 2026.5.15

package/src/ai/providers.js

@@ -0,0 +1,427 @@
+/**
+ * ❄️ WINTER AI PROVIDER ❄️
+ * Full Claude Code / Codex compatible AI integration
+ */
+
+export class AIProviderManager {
+  constructor(config) {
+    this.config = config;
+    this.providers = {};
+    this.activeProvider = null;
+    this.cache = new Map();
+    this.tools = [];
+    this.initialized = false;
+    this.authToken = null;
+  }
+
+  async init() {
+    if (this.initialized) return;
+
+    const cfg = await this.config.load();
+
+    // Load auth token from Claude Code's auth.json if available
+    this.authToken = await this.loadAuthToken();
+
+    if (cfg.claude?.baseURL || this.authToken) {
+      this.providers.claude = {
+        name: 'Claude-compatible API',
+        baseURL: cfg.claude?.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',
+      };
+    }
+
+    if (cfg.custom?.baseURL) {
+      this.providers.custom = {
+        name: 'Custom API',
+        baseURL: cfg.custom.baseURL,
+        apiKey: cfg.custom.apiKey || 'not-required',
+        model: cfg.custom.model || 'gpt-4-turbo',
+        ready: true,
+      };
+    }
+
+    if (cfg.ollama?.baseURL) {
+      this.providers.ollama = {
+        name: 'Ollama Local',
+        apiKey: cfg.ollama.apiKey || 'not-required',
+        baseURL: cfg.ollama.baseURL,
+        model: cfg.ollama.model || 'llama3',
+        ready: true,
+      };
+    }
+
+    if (cfg.openai?.apiKey) {
+      this.providers.openai = {
+        name: 'OpenAI',
+        baseURL: cfg.openai.baseURL || 'https://api.openai.com/v1',
+        apiKey: cfg.openai.apiKey,
+        model: cfg.openai.model || 'gpt-4-turbo',
+        ready: true,
+      };
+    }
+
+    if (cfg.groq?.apiKey) {
+      this.providers.groq = {
+        name: 'Groq',
+        baseURL: cfg.groq.baseURL || 'https://api.groq.com/openai/v1',
+        apiKey: cfg.groq.apiKey,
+        model: cfg.groq.model || 'llama-3.1-70b-versatile',
+        ready: true,
+      };
+    }
+
+    // Set default
+    const defaultProvider = cfg.defaultProvider || 'claude';
+    this.activeProvider = this.providers[defaultProvider] ? defaultProvider : 'claude';
+
+    if (!this.providers[this.activeProvider]?.ready) {
+      const available = Object.keys(this.providers).find(k => this.providers[k].ready);
+      if (available) this.activeProvider = available;
+    }
+
+    this.initialized = true;
+  }
+
+  async loadAuthToken() {
+    try {
+      const fs = await import('fs');
+      const authPath = 'C:\\Users\\PHUCANSOLUTIONS\\.codex\\auth.json';
+      const data = JSON.parse(fs.readFileSync(authPath, 'utf8'));
+      return data.tokens?.access_token || null;
+    } catch {
+      // Try Claude's auth
+      try {
+        const fs = await import('fs');
+        const authPath = 'C:\\Users\\PHUCANSOLUTIONS\\.claude\\sessions\\*\\auth.json';
+        // This won't work with glob, so skip
+      } catch {}
+      return null;
+    }
+  }
+
+  setProvider(name) {
+    if (this.providers[name]) {
+      this.activeProvider = name;
+      return true;
+    }
+    return false;
+  }
+
+  getActiveProvider() {
+    return this.activeProvider;
+  }
+
+  listProviders() {
+    return Object.entries(this.providers).map(([name, p]) => ({
+      name,
+      ready: p.ready,
+      model: p.model,
+    }));
+  }
+
+  setTools(tools) {
+    this.tools = tools;
+  }
+
+  async chat(message, options = {}) {
+    await this.init();
+    const messages = [
+      { role: 'system', content: options.system || this.getSystemPrompt() },
+      { role: 'user', content: message }
+    ];
+
+    const data = await this.sendRequest(messages, options);
+    return {
+      content: data.choices?.[0]?.message?.content || '',
+      raw: data,
+    };
+  }
+
+  async sendRequest(messages, options = {}) {
+    await this.init();
+    const provider = this.providers[this.activeProvider];
+    return await this.sendRequestToProvider(provider, messages, options);
+  }
+
+  async *streamRequest(messages, options = {}) {
+    await this.init();
+    const provider = this.providers[this.activeProvider];
+    yield* this.streamRequestToProvider(provider, messages, options);
+  }
+
+  async sendRequestToProvider(provider, messages, options = {}) {
+    if (!provider) {
+      throw new Error('No active provider is configured');
+    }
+
+    const body = {
+      model: options.model || provider.model,
+      messages,
+    };
+
+    if (this.tools.length > 0 && options.enableTools) {
+      body.tools = this.tools;
+    }
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+    };
+
+    if (provider.authToken) {
+      headers['Authorization'] = `Bearer ${provider.authToken}`;
+    } else if (provider.apiKey && provider.apiKey !== 'not-required') {
+      headers['Authorization'] = `Bearer ${provider.apiKey}`;
+    }
+
+    const response = await fetch(`${provider.baseURL}/chat/completions`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`${provider.name} error (${response.status}): ${error}`);
+    }
+
+    return await response.json();
+  }
+
+  async *streamRequestToProvider(provider, messages, options = {}) {
+    if (!provider) {
+      throw new Error('No active provider is configured');
+    }
+
+    const body = {
+      model: options.model || provider.model,
+      messages,
+      stream: true,
+    };
+
+    if (options.includeUsage !== false) {
+      body.stream_options = { include_usage: true };
+    }
+
+    if (this.tools.length > 0 && options.enableTools) {
+      body.tools = this.tools;
+    }
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'text/event-stream',
+    };
+
+    if (provider.authToken) {
+      headers['Authorization'] = `Bearer ${provider.authToken}`;
+    } else if (provider.apiKey && provider.apiKey !== 'not-required') {
+      headers['Authorization'] = `Bearer ${provider.apiKey}`;
+    }
+
+    const response = await fetch(`${provider.baseURL}/chat/completions`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`${provider.name} stream error (${response.status}): ${error}`);
+    }
+
+    if (!response.body) {
+      throw new Error(`${provider.name} did not return a stream body`);
+    }
+
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    for await (const chunk of response.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith('data:')) continue;
+
+        const payload = trimmed.slice(5).trim();
+        if (!payload || payload === '[DONE]') continue;
+
+        let data;
+        try {
+          data = JSON.parse(payload);
+        } catch {
+          continue;
+        }
+
+        const choice = data.choices?.[0] || {};
+        const content = choice.delta?.content ?? choice.message?.content ?? choice.text ?? '';
+        yield {
+          content,
+          usage: data.usage,
+          raw: data,
+        };
+      }
+    }
+
+    const tail = buffer.trim();
+    if (tail.startsWith('data:')) {
+      const payload = tail.slice(5).trim();
+      if (payload && payload !== '[DONE]') {
+        try {
+          const data = JSON.parse(payload);
+          const choice = data.choices?.[0] || {};
+          yield {
+            content: choice.delta?.content ?? choice.message?.content ?? choice.text ?? '',
+            usage: data.usage,
+            raw: data,
+          };
+        } catch {}
+      }
+    }
+  }
+
+  async callAllProviders(prompt, options = {}) {
+    await this.init();
+    const messages = [
+      { role: 'system', content: options.system || this.getSystemPrompt() },
+      { role: 'user', content: prompt },
+    ];
+
+    const results = {};
+    const entries = Object.entries(this.providers).filter(([, provider]) => provider.ready);
+
+    for (const [name, provider] of entries) {
+      try {
+        const data = await this.sendRequestToProvider(provider, messages, {
+          ...options,
+          enableTools: false,
+          model: options.model || provider.model,
+        });
+        results[name] = {
+          content: data.choices?.[0]?.message?.content || '',
+          model: provider.model,
+          raw: data,
+        };
+      } catch (error) {
+        results[name] = {
+          error: error.message,
+          model: provider.model,
+        };
+      }
+    }
+
+    return results;
+  }
+
+  async chatWithTools(messages, options = {}) {
+    await this.init();
+    const provider = this.providers[this.activeProvider];
+
+    let currentMessages = [...messages];
+    let iterations = 0;
+    const maxIterations = 10;
+
+    while (iterations < maxIterations) {
+      iterations++;
+
+      const body = {
+        model: options.model || provider.model,
+        messages: currentMessages,
+        tools: this.tools.length > 0 ? this.tools : undefined,
+      };
+
+      const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      };
+
+      if (provider.authToken) {
+        headers['Authorization'] = `Bearer ${provider.authToken}`;
+      } else if (provider.apiKey && provider.apiKey !== 'not-required') {
+        headers['Authorization'] = `Bearer ${provider.apiKey}`;
+      }
+
+      const response = await fetch(`${provider.baseURL}/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`${this.activeProvider} error (${response.status}): ${error}`);
+      }
+
+      const data = await response.json();
+      const assistantMsg = data.choices?.[0]?.message;
+
+      // Check for tool calls
+      const toolCalls = assistantMsg?.tool_calls || [];
+      if (toolCalls.length === 0) {
+        return {
+          content: assistantMsg?.content || '',
+          toolCalls: [],
+          raw: data,
+        };
+      }
+
+      // Add assistant message
+      currentMessages.push(assistantMsg);
+
+      // Execute tools and add results
+      for (const tc of toolCalls) {
+        const toolResult = await this.executeTool(tc.function.name, tc.function.arguments);
+        currentMessages.push({
+          role: 'tool',
+          tool_call_id: tc.id,
+          content: JSON.stringify(toolResult),
+        });
+      }
+    }
+
+    return {
+      content: 'Max iterations reached',
+      toolCalls: [],
+      error: 'Too many tool calls',
+    };
+  }
+
+  async executeTool(name, args) {
+    // This will be called by the REPL, not here
+    return { error: 'Tool execution handled by REPL' };
+  }
+
+  getSystemPrompt() {
+    return `You are Winter ❄️, an expert AI coding assistant.
+
+## 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
+
+## Tools
+You have access to tools: Read, Write, Edit, Bash, Glob, Grep, TaskCreate, TaskUpdate
+
+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.`;
+  }
+
+  clearCache() {
+    this.cache.clear();
+  }
+
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      activeProvider: this.activeProvider,
+    };
+  }
+}

package/src/ai/providers.test.js

@@ -0,0 +1,102 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { AIProviderManager } from './providers.js';
+
+test('streamRequest parses OpenAI-compatible SSE chunks with usage', async () => {
+  const originalFetch = globalThis.fetch;
+  const encoder = new TextEncoder();
+  const bodies = [];
+
+  globalThis.fetch = async (_url, options) => {
+    bodies.push(JSON.parse(options.body));
+    return {
+      ok: true,
+      body: new ReadableStream({
+        start(controller) {
+          controller.enqueue(encoder.encode('data: {"choices":[{"delta":{"content":"Hello "}}]}\n\n'));
+          controller.enqueue(encoder.encode('data: {"choices":[{"delta":{"content":"world"}}],"usage":{"prompt_tokens":3,"completion_tokens":2,"total_tokens":5}}\n\n'));
+          controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+          controller.close();
+        },
+      }),
+    };
+  };
+
+  try {
+    const ai = new AIProviderManager({
+      async load() {
+        return {
+          defaultProvider: 'custom',
+          custom: {
+            baseURL: 'http://custom.test/v1',
+            apiKey: 'not-required',
+            model: 'custom-model',
+          },
+        };
+      },
+    });
+    ai.loadAuthToken = async () => null;
+
+    const chunks = [];
+    for await (const chunk of ai.streamRequest([{ role: 'user', content: 'hello' }])) {
+      chunks.push(chunk);
+    }
+
+    assert.equal(bodies[0].stream, true);
+    assert.deepEqual(bodies[0].stream_options, { include_usage: true });
+    assert.equal(chunks.map(chunk => chunk.content).join(''), 'Hello world');
+    assert.deepEqual(chunks.at(-1).usage, {
+      prompt_tokens: 3,
+      completion_tokens: 2,
+      total_tokens: 5,
+    });
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('callAllProviders calls every ready configured provider', async () => {
+  const originalFetch = globalThis.fetch;
+  const calls = [];
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url, body: JSON.parse(options.body) });
+    return {
+      ok: true,
+      async json() {
+        return { choices: [{ message: { content: `ok:${url}` } }] };
+      },
+    };
+  };
+
+  try {
+    const ai = new AIProviderManager({
+      async load() {
+        return {
+          defaultProvider: 'custom',
+          custom: {
+            baseURL: 'http://custom.test/v1',
+            apiKey: 'not-required',
+            model: 'custom-model',
+          },
+          ollama: {
+            baseURL: 'http://ollama.test/v1',
+            model: 'llama3',
+          },
+        };
+      },
+    });
+    ai.loadAuthToken = async () => null;
+
+    const results = await ai.callAllProviders('hello');
+
+    assert.equal(calls.length, 2);
+    assert.equal(calls[0].body.model, 'custom-model');
+    assert.equal(calls[1].body.model, 'llama3');
+    assert.equal(results.custom.model, 'custom-model');
+    assert.equal(results.ollama.model, 'llama3');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});

package/src/cache/system.js

@@ -0,0 +1,157 @@
+/**
+ * ❄️ CACHE SYSTEM ❄️
+ * Context embedding and response caching
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import crypto from 'crypto';
+
+export class CacheSystem {
+  constructor() {
+    this.cacheDir = path.join(homedir(), '.winter', 'cache');
+    this.embeddingsDir = path.join(this.cacheDir, 'embeddings');
+    this.responsesDir = path.join(this.cacheDir, 'responses');
+    this.memoryCache = new Map();
+  }
+
+  async init() {
+    await fs.mkdir(this.embeddingsDir, { recursive: true });
+    await fs.mkdir(this.responsesDir, { recursive: true });
+  }
+
+  // Simple hash-based caching
+  async get(key) {
+    // Check memory cache first
+    if (this.memoryCache.has(key)) {
+      return this.memoryCache.get(key);
+    }
+
+    // Check disk cache
+    const hash = this.hashKey(key);
+    const filePath = path.join(this.responsesDir, `${hash}.json`);
+
+    try {
+      const data = await fs.readFile(filePath, 'utf8');
+      const cached = JSON.parse(data);
+
+      // Check expiry
+      if (cached.expiresAt && Date.now() > cached.expiresAt) {
+        await this.delete(key);
+        return null;
+      }
+
+      this.memoryCache.set(key, cached.data);
+      return cached.data;
+    } catch {
+      return null;
+    }
+  }
+
+  async set(key, data, ttl = 3600000) {
+    // Store in memory
+    this.memoryCache.set(key, data);
+
+    // Store on disk
+    const hash = this.hashKey(key);
+    const filePath = path.join(this.responsesDir, `${hash}.json`);
+
+    const cached = {
+      data,
+      createdAt: Date.now(),
+      expiresAt: Date.now() + ttl,
+    };
+
+    await fs.writeFile(filePath, JSON.stringify(cached));
+  }
+
+  async delete(key) {
+    this.memoryCache.delete(key);
+
+    const hash = this.hashKey(key);
+    const filePath = path.join(this.responsesDir, `${hash}.json`);
+
+    try {
+      await fs.unlink(filePath);
+    } catch {
+      // Ignore if file doesn't exist
+    }
+  }
+
+  async clear() {
+    this.memoryCache.clear();
+
+    try {
+      const files = await fs.readdir(this.responsesDir);
+      for (const file of files) {
+        await fs.unlink(path.join(this.responsesDir, file));
+      }
+    } catch {
+      // Ignore errors
+    }
+  }
+
+  async getStats() {
+    const memorySize = this.memoryCache.size;
+
+    let diskSize = 0;
+    let diskCount = 0;
+
+    try {
+      const files = await fs.readdir(this.responsesDir);
+      for (const file of files) {
+        const stat = await fs.stat(path.join(this.responsesDir, file));
+        diskSize += stat.size;
+        diskCount++;
+      }
+    } catch {
+      // Ignore errors
+    }
+
+    return {
+      memory: { count: memorySize },
+      disk: { count: diskCount, size: diskSize },
+      total: { count: memorySize + diskCount, size: diskSize },
+    };
+  }
+
+  hashKey(key) {
+    return crypto.createHash('md5').update(key).digest('hex');
+  }
+
+  // Embedding cache for context
+  async cacheEmbedding(context, embedding) {
+    const hash = this.hashKey(context);
+    const filePath = path.join(this.embeddingsDir, `${hash}.json`);
+
+    await fs.writeFile(filePath, JSON.stringify({
+      context,
+      embedding,
+      createdAt: Date.now(),
+    }));
+  }
+
+  async getEmbedding(context) {
+    const hash = this.hashKey(context);
+    const filePath = path.join(this.embeddingsDir, `${hash}.json`);
+
+    try {
+      const data = await fs.readFile(filePath, 'utf8');
+      return JSON.parse(data).embedding;
+    } catch {
+      return null;
+    }
+  }
+
+  async clearEmbeddings() {
+    try {
+      const files = await fs.readdir(this.embeddingsDir);
+      for (const file of files) {
+        await fs.unlink(path.join(this.embeddingsDir, file));
+      }
+    } catch {
+      // Ignore errors
+    }
+  }
+}