winter-super-cli 2026.5.15

package/src/cli/repl.test.js

@@ -0,0 +1,167 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { WinterREPL } from './repl.js';
+
+test('slash suggestions include provider, model, and bundled resources', () => {
+  const repl = new WinterREPL({ projectPath: 'E:\\dev\\app\\winter' });
+  const commands = repl.getSlashSuggestions('/').map(item => item.cmd);
+
+  assert(commands.includes('/provider'));
+  assert(commands.includes('/model'));
+  assert(commands.includes('/resources'));
+  assert(commands.includes('/codex'));
+});
+
+test('resource paths point at bundled project resources', () => {
+  const repl = new WinterREPL({ projectPath: 'E:\\dev\\app\\winter' });
+  const paths = repl.getResourcePaths();
+
+  assert.equal(paths.localRoot, 'E:\\dev\\app\\winter\\resources\\local');
+  assert.equal(paths.codex.skills, 'E:\\dev\\app\\winter\\resources\\local\\codex\\skills');
+  assert.equal(paths.claude.plugins, 'E:\\dev\\app\\winter\\resources\\local\\claude\\plugins');
+  assert.equal(paths.designs, 'E:\\dev\\app\\winter\\resources\\local\\awesome-design-md\\design-md');
+});
+
+test('extractModelIdsFromCache reads model slugs without service tier ids', () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  const raw = JSON.stringify({
+    models: [
+      { slug: 'gpt-5.5', service_tiers: [{ id: 'priority' }] },
+      { id: 'gpt-5.4-mini' },
+      { name: 'custom-model' },
+      { slug: 'gpt-5.5' },
+    ],
+  });
+
+  assert.deepEqual(repl.extractModelIdsFromCache(raw), [
+    'gpt-5.5',
+    'gpt-5.4-mini',
+    'custom-model',
+  ]);
+});
+
+test('readCachedModels returns bundled cache model ids', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  const models = await repl.readCachedModels(repl.getResourcePaths().codex.models);
+
+  assert(models.includes('gpt-5.5'));
+  assert(!models.includes('priority'));
+});
+
+test('shouldUseTools keeps simple chat on the fast path', () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+
+  assert.equal(repl.shouldUseTools('trả lời đúng một từ: ok'), false);
+  assert.equal(repl.shouldUseTools('sửa lỗi trong src/cli/repl.js rồi chạy test'), true);
+  assert.equal(repl.shouldUseTools('git push lên github đi'), true);
+});
+
+test('runConversation streams direct assistant answers', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  repl.simulateTyping = async (text) => {
+    process.stdout.write(text);
+  };
+
+  const writes = [];
+  const originalWrite = process.stdout.write;
+  repl.ai = {
+    tools: [],
+    providers: { custom: { model: 'test-model' } },
+    getActiveProvider: () => 'custom',
+    setTools(tools) {
+      this.tools = tools;
+    },
+    async *streamRequest() {
+      yield { content: 'Real ', raw: { choices: [{ delta: { content: 'Real ' } }] } };
+      yield {
+        content: 'time',
+        usage: { prompt_tokens: 3, completion_tokens: 2, total_tokens: 5 },
+        raw: { choices: [{ delta: { content: 'time' }, finish_reason: 'stop' }] },
+      };
+    },
+    async sendRequest() {
+      throw new Error('sendRequest should not be used for streamed answers');
+    },
+  };
+
+  process.stdout.write = (chunk) => {
+    writes.push(String(chunk));
+    return true;
+  };
+
+  try {
+    const answer = await repl.runConversation([{ role: 'user', content: 'hello' }], 'Test', [{ name: 'Read' }]);
+
+    assert.equal(answer, 'Real time');
+    assert.match(writes.join(''), /Real time/);
+    assert.match(writes.join(''), /Tokens: 5 total \(3 in, 2 out\)/);
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+});
+
+test('runConversation executes streamed tool calls then streams final answer', async () => {
+  const repl = new WinterREPL({ projectPath: process.cwd() });
+  repl.simulateTyping = async (text) => {
+    process.stdout.write(text);
+  };
+
+  let streamCount = 0;
+  const executed = [];
+  repl.ai = {
+    tools: [],
+    providers: { custom: { model: 'test-model' } },
+    getActiveProvider: () => 'custom',
+    setTools(tools) {
+      this.tools = tools;
+    },
+    async *streamRequest() {
+      streamCount++;
+      if (streamCount === 1) {
+        yield {
+          raw: {
+            choices: [{
+              delta: {
+                tool_calls: [{
+                  index: 0,
+                  id: 'call-1',
+                  type: 'function',
+                  function: { name: 'Read', arguments: '{"file_path":' },
+                }],
+              },
+            }],
+          },
+        };
+        yield {
+          raw: {
+            choices: [{
+              delta: {
+                tool_calls: [{
+                  index: 0,
+                  function: { arguments: '"README.md"}' },
+                }],
+              },
+              finish_reason: 'tool_calls',
+            }],
+          },
+        };
+        return;
+      }
+
+      yield { content: 'Done', usage: { prompt_tokens: 5, completion_tokens: 1, total_tokens: 6 } };
+    },
+  };
+  repl.tools = {
+    normalizeToolName: name => name,
+    async execute(name, args) {
+      executed.push({ name, args });
+      return { success: true, path: args.file_path, lines: 1, size: 2, content: 'ok' };
+    },
+  };
+
+  const answer = await repl.runConversation([{ role: 'user', content: 'read it' }], 'Test', [{ name: 'Read' }]);
+
+  assert.equal(answer, 'Done');
+  assert.deepEqual(executed, [{ name: 'Read', args: { file_path: 'README.md' } }]);
+});

package/src/cli/snowflake-logo.js

@@ -0,0 +1,106 @@
+export const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  cyan: '\x1b[36m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  white: '\x1b[37m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+  bgCyan: '\x1b[46m',
+  bgMagenta: '\x1b[45m',
+};
+
+const snowflakeArt = String.raw`
+                          ii
+                         .i;
+                 ,        ;i        ,
+                       ;i::;:i;
+                         ,i1:
+        :,,    ,,     ;:,::i,;:i: ,   i    ii;
+        ,ii;;: ii  ,1  :;iiiii:  ;1  .1, i;:,
+            :::ii,,;1.   ;iii;   :1:,:i1;,
+            ,;i:,i:i1:i, ,;i;  ;i;1i;;  :;:
+            ,.  ,i1iii11, ,;, ,11ii;ii;
+               :;:  ::,,:i111i:  ,,   ,:
+               ::   ,,, :i111i:,,,:  :;:
+                :ii;ii11: ,;,  11iii1i:
+            :i:  ;;i1;;;  ;i;, ,i:1i:i,:i;:
+             ,;1i;,:1;   ;iiii    1;,,i1::,
+          ,,;i, 1,  i;  :iiiii;:  1:  ii ,;;ii,
+         ;ii    i,  , :i::,;:,::;.    ,:    ,,:
+                          :ii:
+                        ;i:;;:i;
+                           ;i
+                           ;i,
+                           ;i. 
+`;
+
+export const miniLogo = `${colors.cyan}❄${colors.reset}`;
+
+export function welcomeBanner(version, info = {}) {
+  const pPath = info.project || 'Unknown';
+  const displayPath = pPath; // Hiển thị đầy đủ đường dẫn chính xác
+  const pId = info.session || 'New';
+  const provider = info.provider || 'default';
+  const model = info.model || 'unknown';
+
+  // Tính toán chiều rộng động (nhỏ hơn 5% cửa sổ, tối thiểu 60, tối đa 100 cho đẹp)
+  const columns = process.stdout.columns || 80;
+  const W = Math.max(60, Math.min(Math.floor(columns * 0.95), 100));
+  const line = '═'.repeat(W);
+  const dot = `${colors.green}●${colors.reset}`;
+
+  // Căn giữa Snowflake Art
+  const artLines = snowflakeArt.split('\n').filter(l => l.trim() !== '' || l.length > 0);
+  // Tìm chiều dài thực tế lớn nhất của art (bỏ qua khoảng trắng thừa ở cuối)
+  const maxArtWidth = Math.max(...artLines.map(l => l.trimEnd().length));
+  const artPadding = Math.max(0, Math.floor((W - maxArtWidth) / 2));
+  const centeredArt = artLines.map(l => ' '.repeat(artPadding) + l.trimEnd()).join('\n');
+
+  // Căn giữa tiêu đề
+  const title = `W I N T E R   v${version}`;
+  const titlePadding = Math.max(0, Math.floor((W - title.length) / 2));
+
+  const subtitle = `Build by Atus | fb: iam.anhtu | github: anhtu1707`;
+  const subPadding = Math.max(0, Math.floor((W - subtitle.length) / 2));
+
+  const banner = `${colors.cyan}${centeredArt}${colors.reset}
+
+${' '.repeat(titlePadding)}${colors.bright}${colors.magenta}W I N T E R${colors.reset}  ${colors.dim}v${version}${colors.reset}
+${' '.repeat(subPadding)}${colors.dim}${subtitle}${colors.reset}
+${colors.blue}${line}${colors.reset}
+  ${dot} ${colors.cyan}Project:${colors.reset} ${colors.green}${displayPath}${colors.reset}
+  ${dot} ${colors.cyan}Model:  ${colors.reset} ${model} ${colors.dim}(${provider})${colors.reset}
+  ${dot} ${colors.cyan}Session:${colors.reset} ${colors.yellow}${pId}${colors.reset}
+${colors.blue}${line}${colors.reset}
+${colors.dim}Gõ ${colors.cyan}/help${colors.dim} để xem lệnh · ${colors.cyan}/auto${colors.dim} chế độ tự sửa · ${colors.cyan}ESC${colors.dim} để hủy${colors.reset}
+`;
+  return banner;
+}
+
+export const statusIcons = {
+  online: `${colors.green}●${colors.reset}`,
+  offline: `${colors.dim}○${colors.reset}`,
+  warning: `${colors.yellow}◆${colors.reset}`,
+  error: `${colors.red}✖${colors.reset}`,
+  success: `${colors.green}✓${colors.reset}`,
+  thinking: `${colors.cyan}◉${colors.reset}`,
+  queue: `${colors.magenta}◎${colors.reset}`,
+};
+
+export function sessionIndicator(sessionId) {
+  const id = sessionId ? sessionId.substring(0, 8) : 'none';
+  return `${colors.dim}[${colors.cyan}session:${id}${colors.dim}]${colors.reset}`;
+}
+
+export function providerStatus(name, status) {
+  const icon = status === 'ready' ? statusIcons.online : statusIcons.offline;
+  return `${icon} ${name}`;
+}
+
+export const snowflake = snowflakeArt;

package/src/design/commands.js

@@ -0,0 +1,187 @@
+/**
+ * ❄️ DESIGN COMMANDS ❄️
+ * Design system integration with brand guidelines
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { colors, statusIcons } from '../cli/snowflake-logo.js';
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+export class DesignCommands {
+  constructor(session, config) {
+    this.session = session;
+    this.config = config;
+    this.brandsDir = path.join(packageRoot, 'resources', 'local', 'awesome-design-md', 'design-md');
+  }
+
+  async execute(action, args) {
+    switch (action) {
+      case 'search':
+      case 'find':
+        await this.search(args[0] || '');
+        break;
+      case 'add':
+        await this.addBrand(args[0]);
+        break;
+      case 'list':
+        await this.listBrands();
+        break;
+      case 'preview':
+        await this.previewBrand(args[0]);
+        break;
+      case 'init':
+        await this.initBrandsDir();
+        break;
+      default:
+        await this.listBrands();
+    }
+  }
+
+  async search(query) {
+    if (!query) {
+      console.log(`${colors.yellow}Usage: winter design search <query>${colors.reset}`);
+      return;
+    }
+
+    try {
+      const brands = await fs.readdir(this.brandsDir);
+      const matches = brands.filter(b =>
+        b.toLowerCase().includes(query.toLowerCase())
+      );
+
+      if (matches.length === 0) {
+        console.log(`${colors.yellow}No matches found for "${query}"${colors.reset}`);
+        return;
+      }
+
+      console.log(`\n${colors.cyan}Found ${matches.length} matches:${colors.reset}`);
+      matches.forEach((brand, i) => {
+        console.log(`  ${i + 1}. ${brand}`);
+      });
+      console.log('');
+
+      await this.session.addToMemory(`Searched design brands for: ${query}`, 'search');
+    } catch (error) {
+      console.log(`${colors.red}${statusIcons.error} Error: ${error.message}${colors.reset}`);
+      console.log(`${colors.dim}Make sure you have awesome-design-md installed${colors.reset}`);
+    }
+  }
+
+  async addBrand(brand) {
+    if (!brand) {
+      console.log(`${colors.yellow}Usage: winter design add <brand>${colors.reset}`);
+      return;
+    }
+
+    try {
+      const brandDir = path.join(this.brandsDir, brand);
+      let fileContent = null;
+      let fileName = null;
+
+      // Check for DESIGN.md or README.md
+      const designPath = path.join(brandDir, 'DESIGN.md');
+      const readmePath = path.join(brandDir, 'README.md');
+
+      if (await fs.access(designPath).then(() => true).catch(() => false)) {
+        fileContent = await fs.readFile(designPath, 'utf8');
+        fileName = 'DESIGN.md';
+      } else if (await fs.access(readmePath).then(() => true).catch(() => false)) {
+        fileContent = await fs.readFile(readmePath, 'utf8');
+        fileName = 'README.md';
+      }
+
+      if (!fileContent) {
+        console.log(`${colors.red}${statusIcons.error} Brand "${brand}" not found${colors.reset}`);
+        return;
+      }
+
+      // Write to current project
+      const targetPath = path.join(process.cwd(), fileName);
+      await fs.writeFile(targetPath, fileContent);
+
+      console.log(`${statusIcons.success} Added ${fileName} for ${brand}`);
+      await this.session.addToMemory(`Added design file: ${brand}`, 'design');
+    } catch (error) {
+      console.log(`${colors.red}${statusIcons.error} Error: ${error.message}${colors.reset}`);
+    }
+  }
+
+  async listBrands() {
+    try {
+      const brands = await fs.readdir(this.brandsDir);
+      const sortedBrands = brands.sort();
+
+      console.log(`\n${colors.cyan}Available Design Systems (${sortedBrands.length}):${colors.reset}\n`);
+
+      // Group by first letter
+      const grouped = {};
+      sortedBrands.forEach(b => {
+        const letter = b[0].toUpperCase();
+        if (!grouped[letter]) grouped[letter] = [];
+        grouped[letter].push(b);
+      });
+
+      Object.keys(grouped).sort().forEach(letter => {
+        console.log(`${colors.yellow}[${letter}]${colors.reset}`);
+        grouped[letter].forEach(b => console.log(`  ${b}`));
+        console.log('');
+      });
+    } catch (error) {
+      console.log(`${colors.red}${statusIcons.error} Error: ${error.message}${colors.reset}`);
+      console.log(`${colors.dim}Make sure you have awesome-design-md installed${colors.reset}`);
+    }
+  }
+
+  async previewBrand(brand) {
+    if (!brand) {
+      console.log(`${colors.yellow}Usage: winter design preview <brand>${colors.reset}`);
+      return;
+    }
+
+    try {
+      const brandDir = path.join(this.brandsDir, brand);
+      let content = null;
+      let fileName = null;
+
+      const designPath = path.join(brandDir, 'DESIGN.md');
+      const readmePath = path.join(brandDir, 'README.md');
+
+      if (await fs.access(designPath).then(() => true).catch(() => false)) {
+        content = await fs.readFile(designPath, 'utf8');
+        fileName = 'DESIGN.md';
+      } else if (await fs.access(readmePath).then(() => true).catch(() => false)) {
+        content = await fs.readFile(readmePath, 'utf8');
+        fileName = 'README.md';
+      }
+
+      if (!content) {
+        console.log(`${colors.red}${statusIcons.error} Brand "${brand}" not found${colors.reset}`);
+        return;
+      }
+
+      console.log(`\n${'='.repeat(60)}`);
+      console.log(`${colors.cyan}📋 ${brand} - ${fileName}${colors.reset}`);
+      console.log('='.repeat(60));
+      console.log('');
+
+      // Show first 80 lines
+      const lines = content.split('\n').slice(0, 80);
+      console.log(lines.join('\n'));
+
+      if (content.split('\n').length > 80) {
+        console.log(`\n${colors.dim}... (truncated, ${content.split('\n').length - 80} more lines)${colors.reset}`);
+      }
+    } catch (error) {
+      console.log(`${colors.red}${statusIcons.error} Error: ${error.message}${colors.reset}`);
+    }
+  }
+
+  async initBrandsDir() {
+    const localDir = path.join(process.cwd(), '.design-systems');
+    await fs.mkdir(localDir, { recursive: true });
+    console.log(`${statusIcons.success} Created ${localDir}/`);
+  }
+}

package/src/plugins/manager.js

@@ -0,0 +1,146 @@
+/**
+ * ❄️ PLUGIN MANAGER ❄️
+ * Manage Winter CLI plugins
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { colors, statusIcons } from '../cli/snowflake-logo.js';
+
+export class PluginManager {
+  constructor(session) {
+    this.session = session;
+    this.pluginsDir = path.join(homedir(), '.winter', 'plugins');
+    this.loadedPlugins = new Map();
+  }
+
+  getBuiltinPlugins() {
+    return [
+      {
+        name: 'winter-core',
+        version: '1.0.0',
+        icon: '❄️',
+        description: 'Core Winter CLI functionality',
+        hooks: {},
+        commands: {},
+        tools: {},
+      },
+      {
+        name: 'winter-design',
+        version: '1.0.0',
+        icon: '🎨',
+        description: 'Design system integration',
+        hooks: {},
+        commands: {},
+        tools: {},
+      },
+      {
+        name: 'winter-coding',
+        version: '1.0.0',
+        icon: '💻',
+        description: 'Coding assistance tools',
+        hooks: {},
+        commands: {},
+        tools: {},
+      },
+    ];
+  }
+
+  async listPlugins() {
+    const installedPlugins = await this.getInstalledPlugins();
+    return [...this.getBuiltinPlugins(), ...installedPlugins];
+  }
+
+  async getInstalledPlugins() {
+    try {
+      await fs.mkdir(this.pluginsDir, { recursive: true });
+      const files = await fs.readdir(this.pluginsDir);
+      const plugins = [];
+
+      for (const file of files) {
+        if (file.endsWith('.js')) {
+          try {
+            const plugin = await import(path.join(this.pluginsDir, file));
+            plugins.push({
+              name: plugin.default?.name || file.replace('.js', ''),
+              version: plugin.default?.version || '1.0.0',
+              icon: plugin.default?.icon || '🔌',
+              description: plugin.default?.description || 'Plugin',
+              hooks: plugin.default?.hooks || {},
+              commands: plugin.default?.commands || {},
+              tools: plugin.default?.tools || {},
+            });
+          } catch (e) {
+            // Skip invalid plugins
+          }
+        }
+      }
+
+      return plugins;
+    } catch {
+      return [];
+    }
+  }
+
+  async installPlugin(name) {
+    console.log(`${statusIcons.success} Installing plugin: ${name}`);
+    await this.session.addToMemory(`Installed plugin: ${name}`, 'plugin');
+  }
+
+  async removePlugin(name) {
+    console.log(`${statusIcons.success} Removed plugin: ${name}`);
+    await this.session.addToMemory(`Removed plugin: ${name}`, 'plugin');
+  }
+
+  async updatePlugin(name) {
+    console.log(`${statusIcons.success} Updated plugin: ${name}`);
+  }
+
+  async loadPlugin(name) {
+    const plugins = await this.listPlugins();
+    const plugin = plugins.find(p => p.name === name);
+
+    if (plugin) {
+      this.loadedPlugins.set(name, plugin);
+      return plugin;
+    }
+
+    return null;
+  }
+
+  getLoadedPlugins() {
+    return Array.from(this.loadedPlugins.values());
+  }
+
+  async executeHook(hookName, context) {
+    const results = [];
+    for (const [, plugin] of this.loadedPlugins) {
+      if (plugin.hooks[hookName]) {
+        try {
+          const result = await plugin.hooks[hookName](context);
+          results.push({ plugin: plugin.name, result });
+        } catch (e) {
+          console.log(`${colors.red}${statusIcons.error} Hook error in ${plugin.name}: ${e.message}${colors.reset}`);
+        }
+      }
+    }
+    return results;
+  }
+
+  getPluginCommands() {
+    const commands = {};
+    for (const [, plugin] of this.loadedPlugins) {
+      Object.assign(commands, plugin.commands);
+    }
+    return commands;
+  }
+
+  getPluginTools() {
+    const tools = {};
+    for (const [, plugin] of this.loadedPlugins) {
+      Object.assign(tools, plugin.tools);
+    }
+    return tools;
+  }
+}