winter-super-cli 2026.6.23 → 2026.6.26

package/src/mcp/presets.js

@@ -0,0 +1,114 @@
+export const CHROME_DEVTOOLS_MCP_NAME = 'chrome-devtools';
+
+const CHROME_DEVTOOLS_PACKAGE = 'chrome-devtools-mcp@latest';
+const CHROME_DEVTOOLS_SOURCE = 'https://github.com/ChromeDevTools/chrome-devtools-mcp';
+
+const CHROME_DEVTOOLS_FLAGS_WITH_VALUES = new Set([
+  '--browser-url',
+  '--channel',
+  '--executablePath',
+  '--logFile',
+  '--viewport',
+  '--proxy-server',
+]);
+
+const CHROME_DEVTOOLS_BOOLEAN_FLAGS = new Set([
+  '--headless',
+  '--isolated',
+  '--acceptInsecureCerts',
+  '--help',
+]);
+
+export function normalizeMcpPresetName(name = '') {
+  return String(name || '').trim().toLowerCase();
+}
+
+export function isChromeDevtoolsPreset(name = '') {
+  return ['chrome-devtools', 'chromedevtools', 'chrome', 'devtools', 'cdp'].includes(normalizeMcpPresetName(name));
+}
+
+export function buildChromeDevtoolsArgs(options = []) {
+  const input = Array.isArray(options) ? [...options] : [];
+  const args = ['-y', CHROME_DEVTOOLS_PACKAGE];
+
+  for (let index = 0; index < input.length; index += 1) {
+    const flag = input[index];
+    if (!String(flag || '').startsWith('--')) continue;
+
+    if (CHROME_DEVTOOLS_BOOLEAN_FLAGS.has(flag)) {
+      args.push(flag);
+      continue;
+    }
+
+    if (CHROME_DEVTOOLS_FLAGS_WITH_VALUES.has(flag)) {
+      const value = input[index + 1];
+      if (value === undefined || String(value).startsWith('--')) {
+        throw new Error(`Missing value for ${flag}`);
+      }
+      args.push(flag, String(value));
+      index += 1;
+    }
+  }
+
+  return args;
+}
+
+export function createChromeDevtoolsMcpServer(options = [], platform = process.platform, env = process.env) {
+  const npxArgs = buildChromeDevtoolsArgs(options);
+  const common = {
+    name: CHROME_DEVTOOLS_MCP_NAME,
+    enabled: true,
+    requestTimeoutMs: 60000,
+    metadata: {
+      preset: CHROME_DEVTOOLS_MCP_NAME,
+      source: CHROME_DEVTOOLS_SOURCE,
+      purpose: 'Chrome DevTools MCP for live browser automation, debugging, screenshots, console, network, and performance traces.',
+    },
+  };
+
+  if (platform === 'win32') {
+    return {
+      ...common,
+      command: 'cmd',
+      args: ['/c', 'npx', ...npxArgs],
+      env: {
+        SystemRoot: env.SystemRoot || 'C:\\Windows',
+        PROGRAMFILES: env.PROGRAMFILES || 'C:\\Program Files',
+      },
+    };
+  }
+
+  return {
+    ...common,
+    command: 'npx',
+    args: npxArgs,
+  };
+}
+
+export function getMcpPreset(name, options = []) {
+  if (isChromeDevtoolsPreset(name)) {
+    return createChromeDevtoolsMcpServer(options);
+  }
+  throw new Error(`Unknown MCP preset: ${name}`);
+}
+
+export function ensureMcpConfigShape(config = {}) {
+  config.mcp = config.mcp || { servers: [] };
+  config.mcp.servers = Array.isArray(config.mcp.servers) ? config.mcp.servers : [];
+  config.permissions = config.permissions || { allowlist: {} };
+  config.permissions.allowlist = config.permissions.allowlist || {};
+  config.permissions.allowlist.tools = config.permissions.allowlist.tools || [];
+  config.permissions.allowlist.commands = config.permissions.allowlist.commands || [];
+  config.permissions.allowlist.mcpServers = config.permissions.allowlist.mcpServers || [];
+  return config;
+}
+
+export function upsertMcpServer(config, server) {
+  ensureMcpConfigShape(config);
+  config.mcp.servers = config.mcp.servers.filter(item => item.name !== server.name);
+  config.mcp.servers.push(server);
+  config.permissions.allowlist.mcpServers = [
+    ...new Set([...(config.permissions.allowlist.mcpServers || []), server.name]),
+  ];
+  return config;
+}

package/src/rag/cli.js

@@ -0,0 +1,195 @@
+/**
+ * RAG CLI commands: /rag query, /rag index, /rag status, /rag reset.
+ */
+
+import { RAGEngine } from './rag-engine.js';
+import { colors, statusIcons } from '../cli/snowflake-logo.js';
+
+let ragEngine = null;
+
+export function initRAG(config) {
+  ragEngine = new RAGEngine(config);
+  return ragEngine;
+}
+
+export function getRAGEngine() {
+  return ragEngine;
+}
+
+async function getEngine(config) {
+  if (!ragEngine) {
+    ragEngine = new RAGEngine(config);
+    await ragEngine.init();
+  }
+  return ragEngine;
+}
+
+export async function handleRagCommand(query, config) {
+  const engine = await getEngine(config);
+  const results = await engine.search(query, { topK: 5, threshold: 0.5 });
+
+  if (results.count === 0) {
+    return {
+      success: true,
+      message: 'No relevant documents found. Try running /rag index first.',
+      results: [],
+    };
+  }
+
+  return {
+    success: true,
+    query: results.query,
+    count: results.count,
+    results: results.results.map(doc => ({
+      id: doc.id,
+      source: doc.source,
+      score: doc.score.toFixed(3),
+      text: doc.text.slice(0, 500) + (doc.text.length > 500 ? '...' : ''),
+    })),
+  };
+}
+
+export async function handleRagCommandFromRepl(repl, args = []) {
+  const config = repl.config ? await repl.config.load() : {};
+  config.projectPath = repl.projectPath;
+  await printRagCommand(args, config);
+}
+
+export async function handleRagCommandFromParser(parser, args = []) {
+  const config = parser.config ? await parser.config.load() : {};
+  config.projectPath = parser.projectPath || process.cwd();
+  await printRagCommand(args, config);
+}
+
+async function printRagCommand(args, config) {
+  const [action = 'query', ...rest] = args;
+  const normalizedAction = String(action || 'query').toLowerCase();
+
+  switch (normalizedAction) {
+    case 'query':
+    case 'search': {
+      const query = rest.join(' ');
+      if (!query) {
+        console.log(`${colors.yellow}Usage: /rag query <search-term>${colors.reset}`);
+        return;
+      }
+
+      const result = await handleRagCommand(query, config);
+      console.log(`${colors.cyan}RAG Search: "${query}"${colors.reset}`);
+      console.log(`${colors.dim}Found ${result.count || 0} results${colors.reset}`);
+      result.results?.forEach((r, i) => {
+        console.log(`\n${colors.green}[${i + 1}] ${r.source}${colors.reset} ${colors.dim}(score: ${r.score})${colors.reset}`);
+        console.log(`${r.text}\n`);
+      });
+      if (result.message) console.log(`${colors.dim}${result.message}${colors.reset}`);
+      return;
+    }
+
+    case 'index': {
+      console.log(`${colors.cyan}RAG Indexing...${colors.reset}`);
+      const force = rest.includes('--force');
+      const result = await handleRagIndexCommand(config, { force });
+      const color = result.success ? colors.green : colors.yellow;
+      const icon = result.success ? `${statusIcons.success} ` : '';
+      console.log(`${color}${icon}${result.message}${colors.reset}`);
+      return;
+    }
+
+    case 'status': {
+      const result = await handleRagStatusCommand(config);
+      console.log(`${colors.cyan}RAG Status:${colors.reset}`);
+      console.log(`  Enabled: ${result.enabled}`);
+      console.log(`  Documents: ${result.totalDocuments}`);
+      console.log(`  Dimension: ${result.dimension}`);
+      console.log(`  Provider: ${result.provider}`);
+      console.log(`  Store: ${result.storeFile || 'default'}`);
+      return;
+    }
+
+    case 'reset': {
+      console.log(`${colors.cyan}RAG Resetting...${colors.reset}`);
+      const result = await handleRagResetCommand(config);
+      console.log(`${colors.green}${statusIcons.success} ${result.message}${colors.reset}`);
+      return;
+    }
+
+    case 'help':
+    default:
+      console.log(`${colors.cyan}RAG Commands:${colors.reset}`);
+      console.log('  /rag query <term>    - Semantic search');
+      console.log('  /rag index [--force] - Index codebase');
+      console.log('  /rag status          - Show RAG status');
+      console.log('  /rag reset           - Clear vector store');
+  }
+}
+
+export async function handleRagIndexCommand(config, options = {}) {
+  const engine = await getEngine(config);
+  const stats = engine.getStatus();
+
+  if (stats.totalDocuments > 0 && !options.force) {
+    return {
+      success: false,
+      message: `Already indexed ${stats.totalDocuments} documents. Use /rag index --force to re-index.`,
+    };
+  }
+
+  if (options.force) {
+    await engine.reset();
+  }
+
+  const result = await engine.indexCodebase(options);
+  return {
+    success: true,
+    message: `Indexed ${result.totalDocuments} documents from ${result.totalFiles} files.`,
+    ...result,
+  };
+}
+
+export async function handleRagResetCommand(config) {
+  const engine = await getEngine(config);
+  await engine.reset();
+  return {
+    success: true,
+    message: 'Vector store cleared.',
+  };
+}
+
+export async function handleRagStatusCommand(config) {
+  const engine = await getEngine(config);
+  const status = engine.getStatus();
+
+  return {
+    success: true,
+    enabled: status.enabled,
+    totalDocuments: status.totalDocuments,
+    dimension: status.dimension,
+    provider: status.provider,
+    createdAt: status.createdAt,
+    updatedAt: status.updatedAt,
+    storeFile: status.storeFile,
+  };
+}
+
+export function handleRagEnableCommand(enabled) {
+  if (ragEngine) {
+    ragEngine.setEnabled(enabled);
+  }
+
+  return {
+    success: true,
+    message: `RAG ${enabled ? 'enabled' : 'disabled'}.`,
+  };
+}
+
+export default {
+  initRAG,
+  getRAGEngine,
+  handleRagCommand,
+  handleRagCommandFromRepl,
+  handleRagCommandFromParser,
+  handleRagIndexCommand,
+  handleRagResetCommand,
+  handleRagStatusCommand,
+  handleRagEnableCommand,
+};

package/src/rag/embeddings.js

@@ -0,0 +1,183 @@
+/**
+ * ❄ EMBEDDING PROVIDERS ❄
+ * Abstraction layer for embedding models (Qwen, MiniMax, Ollama, OpenAI, custom)
+ */
+
+import { getProviderPreset } from '../ai/provider-adapters.js';
+
+const DEFAULT_EMBED_MODEL = {
+  qwen: 'text-embedding-v3',
+  minimax: 'embedding-2',
+  ollama: 'nomic-embed-text',
+  openai: 'text-embedding-3-small',
+};
+
+/**
+ * Get embedding provider config
+ * @param {string} providerName - Provider name (qwen, minimax, ollama, openai, custom)
+ * @param {object} config - Full Winter config
+ * @returns {object} Embedding config
+ */
+export function getEmbeddingConfig(providerName, config) {
+  const preset = getProviderPreset(providerName);
+  const configuredProvider = config?.providers?.[providerName] || config?.[providerName] || {};
+  
+  if (!preset) {
+    // For custom providers, use the config directly
+    const customProvider = configuredProvider;
+    if (customProvider) {
+      return {
+        ...customProvider,
+        embedModel: customProvider.embedModel || DEFAULT_EMBED_MODEL[providerName] || 'text-embedding-3-small',
+        embedProvider: providerName,
+      };
+    }
+    throw new Error(`Provider '${providerName}' not found in config`);
+  }
+
+  const model = configuredProvider.embedModel
+    || DEFAULT_EMBED_MODEL[providerName]
+    || preset.embedModel
+    || preset.model;
+  
+  return {
+    ...preset,
+    ...configuredProvider,
+    embedModel: model,
+    embedProvider: providerName,
+  };
+}
+
+/**
+ * Create embedding request body for a provider
+ * @param {string} providerName - Provider name
+ * @param {string} text - Text to embed
+ * @param {object} cfg - Provider config
+ * @returns {object} Request body
+ */
+export function createEmbeddingRequest(providerName, text, cfg) {
+  const normalizedText = text.replace(/\n/g, ' ').trim();
+  
+  switch (providerName) {
+    case 'qwen':
+      return {
+        model: cfg.embedModel,
+        input: normalizedText,
+      };
+      
+    case 'minimax':
+      return {
+        model: cfg.embedModel,
+        text: normalizedText,
+      };
+      
+    case 'ollama':
+      return {
+        model: cfg.embedModel,
+        prompt: normalizedText,
+      };
+      
+    case 'openai':
+    case 'custom':
+    default:
+      return {
+        model: cfg.embedModel,
+        input: normalizedText,
+      };
+  }
+}
+
+/**
+ * Parse embedding response from provider
+ * @param {string} providerName - Provider name
+ * @param {object} data - Response data
+ * @returns {number[]} Embedding vector
+ */
+export function parseEmbeddingResponse(providerName, data) {
+  switch (providerName) {
+    case 'qwen':
+      return data.output?.embeddings?.[0]?.embedding || data.data?.[0]?.embedding;
+      
+    case 'minimax':
+      return data.data?.embedding || data.data?.[0]?.embedding;
+      
+    case 'ollama':
+      return data.embedding;
+      
+    case 'openai':
+    case 'custom':
+    default:
+      return data.data?.[0]?.embedding;
+  }
+}
+
+/**
+ * Get base URL for embedding provider
+ * @param {string} providerName - Provider name
+ * @param {object} cfg - Provider config
+ * @returns {string} Base URL
+ */
+export function getEmbeddingBaseURL(providerName, cfg) {
+  const baseURL = cfg.baseURL;
+  
+  if (baseURL) {
+    const trimmed = String(baseURL).replace(/\/+$/, '');
+    if (/\/embeddings$/i.test(trimmed)) return trimmed;
+    if (providerName === 'ollama' && !/\/v1$/i.test(trimmed)) return `${trimmed}/api/embeddings`;
+    return `${trimmed}/embeddings`;
+  }
+  
+  const EMBED_ENDPOINTS = {
+    qwen: 'https://dashscope.aliyuncs.com/compatible-mode/v1/embeddings',
+    minimax: 'https://api.minimax.chat/v1/text/embeddings',
+    ollama: 'http://localhost:11434/api/embeddings',
+    openai: 'https://api.openai.com/v1/embeddings',
+  };
+  
+  return EMBED_ENDPOINTS[providerName] || EMBED_ENDPOINTS.openai;
+}
+
+/**
+ * Get headers for embedding request
+ * @param {string} providerName - Provider name
+ * @param {object} cfg - Provider config
+ * @returns {object} Headers
+ */
+export function getEmbeddingHeaders(providerName, cfg) {
+  const headers = {
+    'Content-Type': 'application/json',
+  };
+  
+  switch (providerName) {
+    case 'qwen':
+      headers['Authorization'] = `Bearer ${cfg.apiKey}`;
+      break;
+      
+    case 'minimax':
+      headers['Authorization'] = `Bearer ${cfg.apiKey}`;
+      break;
+      
+    case 'ollama':
+      // No auth needed for local
+      break;
+      
+    case 'openai':
+      headers['Authorization'] = `Bearer ${cfg.apiKey}`;
+      break;
+      
+    case 'custom':
+      if (cfg.apiKey) headers['Authorization'] = `Bearer ${cfg.apiKey}`;
+      if (cfg.authToken) headers['Authorization'] = `Bearer ${cfg.authToken}`;
+      break;
+  }
+  
+  return headers;
+}
+
+export default {
+  getEmbeddingConfig,
+  createEmbeddingRequest,
+  parseEmbeddingResponse,
+  getEmbeddingBaseURL,
+  getEmbeddingHeaders,
+};

package/src/rag/rag-engine.js

@@ -0,0 +1,187 @@
+/**
+ * ❄ RAG ENGINE ❄
+ * Core RAG engine - orchestrates retrieval + augmentation
+ */
+
+import { VectorStore } from './vector-store.js';
+import { Retriever } from './retriever.js';
+import { getEmbeddingConfig } from './embeddings.js';
+import { glob } from 'glob';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+/**
+ * RAG Engine class
+ */
+export class RAGEngine {
+  constructor(config) {
+    this.config = config;
+    this.projectPath = path.resolve(config.projectPath || config.project?.current || process.cwd());
+    this.vectorStore = new VectorStore(config);
+    this.retriever = new Retriever(config, this.vectorStore);
+    this.enabled = config.rag?.enabled !== false;
+  }
+
+  /**
+   * Initialize RAG engine
+   */
+  async init() {
+    await this.vectorStore.init();
+  }
+
+  /**
+   * Check if RAG is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+
+  /**
+   * Enable/disable RAG
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+
+  /**
+   * Index codebase
+   * @param {object} options - Indexing options
+   */
+  async indexCodebase(options = {}) {
+    const {
+      patterns = ['src/**/*.js', 'src/**/*.ts', '*.md', 'docs/**/*.md'],
+      exclude = ['node_modules/**', 'dist/**', 'build/**', '.git/**', '.winter/**', 'resources/local/**', '**/*.test.js', '**/*.min.js'],
+      chunkSize = 1000,
+      chunkOverlap = 200,
+    } = options;
+
+    const files = await glob(patterns, {
+      cwd: this.projectPath,
+      ignore: exclude,
+      absolute: true,
+      nodir: true,
+    });
+    
+    const docs = [];
+    
+    for (const file of files) {
+      try {
+        const content = await fs.readFile(file, 'utf-8');
+        
+        // Chunk large files
+        if (content.length <= chunkSize) {
+          docs.push({
+            id: `file_${path.basename(file)}`,
+            text: content,
+            source: path.relative(this.projectPath, file).replace(/\\/g, '/'),
+            metadata: {
+              type: 'file',
+              name: path.basename(file),
+              ext: path.extname(file),
+            },
+          });
+        } else {
+          // Split into chunks
+          const chunks = this.chunkText(content, chunkSize, chunkOverlap);
+          
+          chunks.forEach((chunk, idx) => {
+            docs.push({
+              id: `chunk_${path.basename(file)}_${idx}`,
+              text: chunk,
+              source: path.relative(this.projectPath, file).replace(/\\/g, '/'),
+              metadata: {
+                type: 'chunk',
+                name: path.basename(file),
+                ext: path.extname(file),
+                chunkIndex: idx,
+                totalChunks: chunks.length,
+              },
+            });
+          });
+        }
+      } catch (err) {
+        console.warn(`Failed to read ${file}: ${err.message}`);
+      }
+    }
+
+    const ids = await this.vectorStore.addDocuments(docs);
+    
+    return {
+      totalFiles: files.length,
+      totalDocuments: ids.length,
+    };
+  }
+
+  /**
+   * Chunk text with overlap
+   * @param {string} text - Text to chunk
+   * @param {number} chunkSize - Chunk size in chars
+   * @param {number} overlap - Overlap between chunks
+   * @returns {string[]} Chunks
+   */
+  chunkText(text, chunkSize, overlap) {
+    const chunks = [];
+    const lines = text.split('\n');
+    let currentChunk = '';
+    
+    for (const line of lines) {
+      if (currentChunk.length + line.length > chunkSize && currentChunk.length > 0) {
+        chunks.push(currentChunk.trim());
+        
+        // Keep overlap
+        const overlapLines = currentChunk.split('\n').slice(-Math.floor(overlap / 50));
+        currentChunk = overlapLines.join('\n') + '\n' + line;
+      } else {
+        currentChunk += line + '\n';
+      }
+    }
+    
+    if (currentChunk.trim()) {
+      chunks.push(currentChunk.trim());
+    }
+    
+    return chunks;
+  }
+
+  /**
+   * Search
+   * @param {string} query - Query
+   * @param {object} options - Search options
+   */
+  async search(query, options = {}) {
+    return this.retriever.retrieve(query, options);
+  }
+
+  /**
+   * Augment prompt with context
+   * @param {string} prompt - Original prompt
+   * @param {object} options - Augmentation options
+   */
+  async augmentPrompt(prompt, options = {}) {
+    if (!this.enabled) {
+      return prompt;
+    }
+    
+    return this.retriever.augmentPrompt(prompt, options);
+  }
+
+  /**
+   * Get RAG status
+   */
+  getStatus() {
+    const stats = this.vectorStore.getStats();
+    return {
+      enabled: this.enabled,
+      ...stats,
+    };
+  }
+
+  /**
+   * Reset vector store
+   */
+  async reset() {
+    await this.vectorStore.clear();
+  }
+}
+
+export default RAGEngine;