winter-super-cli 2026.5.25 → 2026.5.26

package/package.json

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

package/src/ai/providers.js

@@ -129,14 +129,38 @@ export class AIProviderManager {
     return null;
   }
 
+  normalizeProviderName(name) {
+    return String(name || '').trim().toLowerCase();
+  }
+
+  async reload() {
+    this.providers = {};
+    this.activeProvider = null;
+    this.initialized = false;
+    await this.init();
+  }
+
   setProvider(name) {
-    if (this.providers[name]) {
-      this.activeProvider = name;
+    const providerName = this.normalizeProviderName(name);
+    if (this.providers[providerName]) {
+      this.activeProvider = providerName;
       return true;
     }
     return false;
   }
 
+  async switchProvider(name) {
+    const providerName = this.normalizeProviderName(name);
+    await this.init();
+
+    if (this.setProvider(providerName)) {
+      return providerName;
+    }
+
+    await this.reload();
+    return this.setProvider(providerName) ? providerName : null;
+  }
+
   getActiveProvider() {
     return this.activeProvider;
   }

package/src/ai/providers.test.js

@@ -100,3 +100,38 @@ test('callAllProviders calls every ready configured provider', async () => {
     globalThis.fetch = originalFetch;
   }
 });
+
+test('switchProvider reloads config before rejecting a provider', async () => {
+  let cfg = {
+    defaultProvider: 'ollama',
+    ollama: {
+      baseURL: 'http://ollama.test/v1',
+      model: 'llama3',
+    },
+  };
+
+  const ai = new AIProviderManager({
+    async load() {
+      return cfg;
+    },
+  });
+  ai.loadAuthToken = async () => null;
+
+  await ai.init();
+  assert.equal(ai.getActiveProvider(), 'ollama');
+
+  cfg = {
+    ...cfg,
+    custom: {
+      baseURL: 'http://custom.test/v1',
+      apiKey: 'not-required',
+      model: 'custom-model',
+    },
+  };
+
+  const switched = await ai.switchProvider(' CUSTOM ');
+
+  assert.equal(switched, 'custom');
+  assert.equal(ai.getActiveProvider(), 'custom');
+  assert.equal(ai.providers.custom.model, 'custom-model');
+});

package/src/cli/commands.js

@@ -86,6 +86,8 @@ export class CommandParser {
       '/memories': () => this.showMemories(),
       '/plans': () => this.showPlans(),
       '/cache': () => this.handleCache(args),
+      '/provider': () => this.handleProvider(args),
+      '/providers': () => this.showProviders(),
       '/exit': () => process.exit(0),
     };
 
@@ -280,6 +282,41 @@ export class CommandParser {
     }
   }
 
+  async handleProvider(args) {
+    const providerName = args[0]?.trim().toLowerCase();
+
+    if (!providerName) {
+      await this.ai.init?.();
+      console.log(`${colors.cyan}Provider: ${this.ai.getActiveProvider()}${colors.reset}`);
+      return;
+    }
+
+    const switched = typeof this.ai.switchProvider === 'function'
+      ? await this.ai.switchProvider(providerName)
+      : (this.ai.setProvider(providerName) ? providerName : null);
+
+    if (switched) {
+      await this.config.setDefaultProvider(switched);
+      console.log(`${statusIcons.success} Provider: ${switched}`);
+      return;
+    }
+
+    const available = this.ai.listProviders?.().map(p => p.name).join(', ') || 'none';
+    console.log(`${colors.red}${statusIcons.error} Unknown provider: ${providerName}${colors.reset}`);
+    console.log(`${colors.dim}Available providers: ${available}${colors.reset}`);
+  }
+
+  async showProviders() {
+    await this.ai.init?.();
+    const providers = this.ai.listProviders?.() || [];
+    console.log(`\n${colors.cyan}Providers:${colors.reset}`);
+    providers.forEach(p => {
+      const status = p.ready ? statusIcons.online : statusIcons.offline;
+      const active = p.name === this.ai.getActiveProvider?.() ? ` ${colors.green}< active${colors.reset}` : '';
+      console.log(`  ${status} ${p.name} (${p.model})${active}`);
+    });
+  }
+
   async showMemories() {
     const memories = this.session.getMemory();
     console.log(`\n${colors.cyan}Memories:${colors.reset}`);

package/src/cli/commands.test.js

@@ -90,10 +90,73 @@ test('skill and plugin commands default to list output', async () => {
   }
 
   assert(logs.some(line => line.includes('Available Skills')));
-  assert(logs.some(line => line.includes('Installed Plugins')));
-});
-
-test('plugin manager loads local plugin files via file URLs', async () => {
+  assert(logs.some(line => line.includes('Installed Plugins')));
+});
+
+test('slash provider command switches and persists provider', async () => {
+  const session = {
+    getSessionId: () => '12345678-1234-1234-1234-123456789abc',
+    addToMemory: async () => {},
+    getMemory: () => [],
+    getPlans: () => [],
+  };
+  const saved = [];
+  const ai = {
+    active: 'ollama',
+    providers: {
+      custom: { model: 'custom-model', ready: true },
+      ollama: { model: 'llama3', ready: true },
+    },
+    async switchProvider(name) {
+      if (!this.providers[name]) return null;
+      this.active = name;
+      return name;
+    },
+    getActiveProvider() {
+      return this.active;
+    },
+    listProviders() {
+      return Object.entries(this.providers).map(([name, provider]) => ({ name, ...provider }));
+    },
+  };
+  const parser = new CommandParser({
+    session,
+    ai,
+    config: {
+      setDefaultProvider: async provider => saved.push(provider),
+    },
+  });
+
+  await parser.parse(['/provider', 'custom']);
+
+  assert.equal(ai.getActiveProvider(), 'custom');
+  assert.deepEqual(saved, ['custom']);
+});
+
+test('slash providers command lists available providers', async () => {
+  const parser = createParser();
+  parser.ai = {
+    init: async () => {},
+    getActiveProvider: () => 'custom',
+    listProviders: () => [
+      { name: 'custom', ready: true, model: 'custom-model' },
+    ],
+  };
+  const logs = [];
+  const originalLog = console.log;
+
+  console.log = (...args) => logs.push(args.join(' '));
+  try {
+    await parser.parse(['/providers']);
+  } finally {
+    console.log = originalLog;
+  }
+
+  assert(logs.some(line => line.includes('custom')));
+  assert(logs.some(line => line.includes('custom-model')));
+});
+
+test('plugin manager loads local plugin files via file URLs', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'winter-plugin-load-'));
   const pluginsDir = path.join(root, '.winter', 'plugins');
   await mkdir(pluginsDir, { recursive: true });

package/src/cli/repl.js

@@ -1094,12 +1094,18 @@ export class WinterREPL {
       // Provider commands
       case '/provider':
         if (args[0]) {
-          const providerName = args[0];
-          if (this.ai.setProvider(providerName)) {
-            await this.config.setDefaultProvider(providerName);
-            console.log(`${colors.green}✓ Provider: ${providerName}${colors.reset}`);
+          const providerName = args[0].trim().toLowerCase();
+          const switched = typeof this.ai.switchProvider === 'function'
+            ? await this.ai.switchProvider(providerName)
+            : (this.ai.setProvider(providerName) ? providerName : null);
+
+          if (switched) {
+            await this.config.setDefaultProvider(switched);
+            console.log(`${colors.green}✓ Provider: ${switched}${colors.reset}`);
           } else {
+            const available = this.ai.listProviders().map(p => p.name).join(', ') || 'none';
             console.log(`${colors.red}Unknown provider: ${providerName}${colors.reset}`);
+            console.log(`${colors.dim}Available providers: ${available}${colors.reset}`);
           }
         } else {
           console.log(`${colors.cyan}Provider: ${this.ai.getActiveProvider()}${colors.reset}`);

package/src/cli/repl.test.js

@@ -169,6 +169,37 @@ test('readCachedModels returns bundled cache model ids', async () => {
   assert(!models.includes('priority'));
 });
 
+test('provider slash command switches and persists configured provider', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  const saved = [];
+  repl.config = {
+    setDefaultProvider: async provider => saved.push(provider),
+  };
+  repl.ai = {
+    active: 'ollama',
+    providers: {
+      custom: { model: 'custom-model', ready: true },
+      ollama: { model: 'llama3', ready: true },
+    },
+    async switchProvider(name) {
+      if (!this.providers[name]) return null;
+      this.active = name;
+      return name;
+    },
+    getActiveProvider() {
+      return this.active;
+    },
+    listProviders() {
+      return Object.entries(this.providers).map(([name, provider]) => ({ name, ...provider }));
+    },
+  };
+
+  await repl.handleSlashCommand('/provider custom');
+
+  assert.equal(repl.ai.getActiveProvider(), 'custom');
+  assert.deepEqual(saved, ['custom']);
+});
+
 test('shouldUseTools keeps agent mode enabled by default', () => {
   const repl = new WinterREPL({ projectPath: process.cwd() });