winter-super-cli 2026.6.23 → 2026.6.26

package/src/rag/retriever.js

@@ -0,0 +1,112 @@
+/**
+ * ❄ RETRIEVER ❄
+ * Retrieval logic for RAG - handles similarity search and result formatting
+ */
+
+import { VectorStore } from './vector-store.js';
+
+/**
+ * Retriever class - handles document retrieval
+ */
+export class Retriever {
+  constructor(config, vectorStore) {
+    this.config = config;
+    this.vectorStore = vectorStore;
+  }
+
+  /**
+   * Retrieve relevant documents for a query
+   * @param {string} query - User query
+   * @param {object} options - Retrieval options
+   * @returns {object} Retrieval results
+   */
+  async retrieve(query, options = {}) {
+    const {
+      topK = 5,
+      threshold = 0.5,
+      includeMetadata = true,
+    } = options;
+
+    if (!query || query.trim().length === 0) {
+      return {
+        query,
+        results: [],
+        count: 0,
+      };
+    }
+
+    const results = await this.vectorStore.search(query, topK, threshold);
+
+    const formattedResults = results.map(doc => ({
+      id: doc.id,
+      text: doc.text,
+      source: doc.source,
+      score: doc.score,
+      metadata: includeMetadata ? doc.metadata : undefined,
+    }));
+
+    return {
+      query,
+      results: formattedResults,
+      count: formattedResults.length,
+    };
+  }
+
+  /**
+   * Format retrieval results as context string
+   * @param {object} retrievalResult - Result from retrieve()
+   * @param {object} options - Formatting options
+   * @returns {string} Formatted context
+   */
+  formatContext(retrievalResult, options = {}) {
+    const { maxChars = 4000, showScores = true } = options;
+    
+    if (retrievalResult.count === 0) {
+      return '';
+    }
+
+    let context = '## Relevant Context\n\n';
+    
+    for (const doc of retrievalResult.results) {
+      const scoreStr = showScores ? ` [score: ${doc.score.toFixed(3)}]` : '';
+      const sourceStr = doc.source ? ` (${doc.source})` : '';
+      
+      context += `---${sourceStr}${scoreStr}---\n`;
+      context += doc.text + '\n\n';
+      
+      // Truncate if too long
+      if (context.length > maxChars) {
+        context = context.slice(0, maxChars) + '\n... (truncated)';
+        break;
+      }
+    }
+
+    return context;
+  }
+
+  /**
+   * Augment prompt with retrieved context
+   * @param {string} originalPrompt - Original user prompt
+   * @param {object} options - Retrieval and formatting options
+   * @returns {string} Augmented prompt
+   */
+  async augmentPrompt(originalPrompt, options = {}) {
+    const retrievalResult = await this.retrieve(originalPrompt, {
+      topK: options.topK || 5,
+      threshold: options.threshold || 0.5,
+    });
+
+    if (retrievalResult.count === 0) {
+      return originalPrompt;
+    }
+
+    const context = this.formatContext(retrievalResult, {
+      maxChars: options.maxChars || 4000,
+      showScores: options.showScores || false,
+    });
+
+    return `${context}\n\n## User Question\n${originalPrompt}`;
+  }
+}
+
+export default Retriever;

package/src/rag/vector-store.js

@@ -0,0 +1,225 @@
+/**
+ * ❄ VECTOR STORE ❄
+ * File-based vector storage with cosine similarity search
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getEmbeddingConfig, createEmbeddingRequest, parseEmbeddingResponse, getEmbeddingBaseURL, getEmbeddingHeaders } from './embeddings.js';
+
+const DEFAULT_VECTOR_STORE_FILE = path.join('.winter', 'rag', 'vector-store.json');
+
+/**
+ * Vector Store class
+ */
+export class VectorStore {
+  constructor(config) {
+    this.config = config;
+    this.projectPath = path.resolve(config.projectPath || config.project?.current || process.cwd());
+    this.storeFile = path.resolve(this.projectPath, config.rag?.storeFile || DEFAULT_VECTOR_STORE_FILE);
+    this.embeddings = [];
+    this.meta = {
+      provider: config.rag?.provider || 'qwen',
+      dimension: 0,
+      createdAt: null,
+      updatedAt: null,
+    };
+  }
+
+  /**
+   * Initialize vector store (load from disk)
+   */
+  async init() {
+    try {
+      const data = await fs.readFile(this.storeFile, 'utf-8');
+      const parsed = JSON.parse(data);
+      this.embeddings = parsed.embeddings || [];
+      this.meta = parsed.meta || this.meta;
+    } catch {
+      // No existing store, start fresh
+      this.embeddings = [];
+    }
+  }
+
+  /**
+   * Save vector store to disk
+   */
+  async save() {
+    const dir = path.dirname(this.storeFile);
+    await fs.mkdir(dir, { recursive: true });
+    
+    this.meta.updatedAt = new Date().toISOString();
+    
+    await fs.writeFile(this.storeFile, JSON.stringify({
+      embeddings: this.embeddings,
+      meta: this.meta,
+    }, null, 2));
+  }
+
+  /**
+   * Embed text using configured provider
+   * @param {string} text - Text to embed
+   * @returns {number[]} Embedding vector
+   */
+  async embedText(text) {
+    const providerName = this.meta.provider;
+    const cfg = getEmbeddingConfig(providerName, this.config);
+    
+    const baseURL = getEmbeddingBaseURL(providerName, cfg);
+    const headers = getEmbeddingHeaders(providerName, cfg);
+    const body = createEmbeddingRequest(providerName, text, cfg);
+    
+    const response = await fetch(baseURL, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+    
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Embedding request failed: ${response.status} ${errorText}`);
+    }
+    
+    const data = await response.json();
+    const embedding = parseEmbeddingResponse(providerName, data);
+    
+    if (!embedding || embedding.length === 0) {
+      throw new Error('Failed to generate embedding');
+    }
+    
+    return embedding;
+  }
+
+  /**
+   * Add document to vector store
+   * @param {object} doc - Document { id, text, source, metadata }
+   */
+  async addDocument(doc) {
+    const embedding = await this.embedText(doc.text);
+    
+    const vectorDoc = {
+      id: doc.id || `doc_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+      text: doc.text,
+      source: doc.source || 'unknown',
+      metadata: doc.metadata || {},
+      embedding,
+      createdAt: new Date().toISOString(),
+    };
+    
+    this.embeddings.push(vectorDoc);
+    
+    if (this.meta.dimension === 0) {
+      this.meta.dimension = embedding.length;
+    }
+    
+    await this.save();
+    
+    return vectorDoc.id;
+  }
+
+  /**
+   * Add multiple documents
+   * @param {object[]} docs - Array of documents
+   */
+  async addDocuments(docs) {
+    const ids = [];
+    
+    for (const doc of docs) {
+      const id = await this.addDocument(doc);
+      ids.push(id);
+    }
+    
+    return ids;
+  }
+
+  /**
+   * Cosine similarity between two vectors
+   * @param {number[]} a - Vector A
+   * @param {number[]} b - Vector B
+   * @returns {number} Similarity score (0-1)
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) return 0;
+    
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    
+    if (normA === 0 || normB === 0) return 0;
+    
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+
+  /**
+   * Search for similar documents
+   * @param {string} query - Query text
+   * @param {number} topK - Number of results (default: 5)
+   * @param {number} threshold - Similarity threshold (default: 0.5)
+   * @returns {object[]} Similar documents
+   */
+  async search(query, topK = 5, threshold = 0.5) {
+    if (this.embeddings.length === 0) {
+      return [];
+    }
+    
+    const queryEmbedding = await this.embedText(query);
+    
+    const results = this.embeddings
+      .map(doc => ({
+        ...doc,
+        score: this.cosineSimilarity(queryEmbedding, doc.embedding),
+      }))
+      .filter(doc => doc.score >= threshold)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, topK);
+    
+    return results;
+  }
+
+  /**
+   * Get all documents
+   * @returns {object[]} All documents
+   */
+  getAll() {
+    return this.embeddings.map(doc => ({
+      id: doc.id,
+      text: doc.text,
+      source: doc.source,
+      metadata: doc.metadata,
+      createdAt: doc.createdAt,
+    }));
+  }
+
+  /**
+   * Clear all documents
+   */
+  async clear() {
+    this.embeddings = [];
+    this.meta.dimension = 0;
+    this.meta.createdAt = null;
+    this.meta.updatedAt = null;
+    await this.save();
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      totalDocuments: this.embeddings.length,
+      dimension: this.meta.dimension,
+      provider: this.meta.provider,
+      createdAt: this.meta.createdAt,
+      updatedAt: this.meta.updatedAt,
+      storeFile: this.storeFile,
+    };
+  }
+}
+
+export default VectorStore;

package/src/tools/executor.js

@@ -5,7 +5,7 @@
 
 import { promises as fs } from 'fs';
 import path from 'path';
-import { exec, execFile } from 'child_process';
+import { exec, execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { diffLines } from 'diff';
 import { withRetry } from './retry.js';
@@ -207,11 +207,11 @@ export class ToolExecutor {
       {
         type: 'function',
         name: 'MCP',
-        description: 'Call a configured MCP server tool by name. Use for external integrations and IDE-like tools. Discover available MCP tools via the MCP tool with server name and tool=list. Also, tools from MCP servers are exposed with mcp__<server>__<tool> naming for direct IDE integration (e.g. mcp__vscode__open_file).',
+        description: 'Call a configured MCP server tool by name. Use for external integrations and IDE-like tools. Discover available MCP tools via the MCP tool with server name and tool=list. For live Chrome debugging, use server chrome-devtools with tools such as new_page, navigate_page, take_snapshot, take_screenshot, evaluate_script, list_console_messages, list_network_requests, and performance trace tools. Also, tools from MCP servers are exposed with mcp__<server>__<tool> naming for direct IDE integration (e.g. mcp__vscode__open_file).',
         parameters: {
           type: 'object',
           properties: {
-            server: { type: 'string', description: 'Configured MCP server name (e.g. vscode)' },
+            server: { type: 'string', description: 'Configured MCP server name (e.g. vscode, chrome-devtools)' },
             tool: { type: 'string', description: 'MCP tool name, or set to "list" to discover all tools from a server' },
             arguments: { type: 'object', description: 'Tool arguments' },
           },
@@ -388,6 +388,18 @@ export class ToolExecutor {
           required: ['url']
         }
       },
+      {
+        type: 'function',
+        name: 'OpenBrowser',
+        description: 'Open Chrome or the default browser visibly for the user. Use this for requests like "mở chrome", "open Chrome", or "open this URL in browser". Do not use Bash/Start-Process for this.',
+        parameters: {
+          type: 'object',
+          properties: {
+            url: { type: 'string', description: 'URL to open. Defaults to about:blank.' },
+            browser: { type: 'string', description: 'chrome or default. Defaults to chrome.' },
+          }
+        }
+      },
       {
         type: 'function',
         name: 'WebFetch',
@@ -532,6 +544,8 @@ export class ToolExecutor {
         return await this.parallelExecute(input.tools ?? input.calls ?? [], { cwd });
       case 'BrowserDebug':
         return await this.browserDebug(input.url ?? input.uri, input.action);
+      case 'OpenBrowser':
+        return await this.openBrowser(input.url ?? input.uri ?? input.href, input.browser);
       case 'WebFetch':
         return await this.webFetch(input.url ?? input.uri ?? input.href, input.prompt ?? input.query ?? input.extract);
       case 'WebSearch':
@@ -572,7 +586,7 @@ export class ToolExecutor {
         return {
           success: false,
           error: `Unknown tool: ${toolName}`,
-          availableTools: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'TaskCreate', 'TaskUpdate', 'TaskList', 'MCP', 'Parallel', 'BrowserDebug', 'WebFetch', 'WebSearch', 'WebArchive', 'HtmlEffectiveness', 'NotebookRead', 'NotebookEdit', 'TodoWrite', 'TodoList', 'ScheduleWakeup', 'AskUserQuestion', 'Agent', 'InsertText', 'StrReplaceAll'],
+          availableTools: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'TaskCreate', 'TaskUpdate', 'TaskList', 'MCP', 'Parallel', 'OpenBrowser', 'BrowserDebug', 'WebFetch', 'WebSearch', 'WebArchive', 'HtmlEffectiveness', 'NotebookRead', 'NotebookEdit', 'TodoWrite', 'TodoList', 'ScheduleWakeup', 'AskUserQuestion', 'Agent', 'InsertText', 'StrReplaceAll'],
           recovery: 'Call one of the available tools. For file writes use Write with { "file_path": "...", "content": "..." }. For shell commands use Bash with { "command": "..." }.',
         };
     }
@@ -725,6 +739,12 @@ export class ToolExecutor {
       return { success: true, coerced: true, args: next };
     }
 
+    if (toolName === 'OpenBrowser') {
+      const url = pick('url', 'uri', 'href') || 'about:blank';
+      const browser = pick('browser', 'app') || 'chrome';
+      return { success: true, coerced: true, args: { ...args, url, browser } };
+    }
+
     if (toolName === 'WebSearch') {
       const query = pick('query', 'q', 'search', 'search_query', 'searchQuery');
       if (!query) {
@@ -752,6 +772,14 @@ export class ToolExecutor {
     const baseCommand = this.getBaseCommand(text);
     if (!baseCommand) return { success: true };
 
+    if (/^(?:get-command|start-process|start|open|xdg-open)$/i.test(baseCommand) && /\b(chrome|browser|google chrome)\b/i.test(text)) {
+      return {
+        success: false,
+        error: `Use OpenBrowser instead of shell command for browser launch: ${baseCommand}`,
+        recovery: 'Call OpenBrowser {"browser":"chrome","url":"about:blank"} for "mở chrome", or OpenBrowser {"browser":"chrome","url":"https://example.com"} for a specific URL.',
+      };
+    }
+
     const cfg = await this.getRuntimeConfig();
     const permissionCommands = cfg.permissions?.allowlist?.commands || [];
     const sandbox = cfg.sandbox || {};
@@ -974,6 +1002,11 @@ export class ToolExecutor {
       searchweb: 'WebSearch',
       internetsearch: 'WebSearch',
       googlesearch: 'WebSearch',
+      openbrowser: 'OpenBrowser',
+      open_browser: 'OpenBrowser',
+      browseropen: 'OpenBrowser',
+      openchrome: 'OpenBrowser',
+      launchchrome: 'OpenBrowser',
       browserdebug: 'BrowserDebug',
       browser: 'BrowserDebug',
       browserinspect: 'BrowserDebug',
@@ -2076,6 +2109,72 @@ export class ToolExecutor {
     }
   }
 
+  buildBrowserLaunchCommand(url = 'about:blank', browser = 'chrome', platform = process.platform) {
+    const targetUrl = String(url || 'about:blank');
+    const targetBrowser = String(browser || 'chrome').toLowerCase();
+
+    if (platform === 'win32') {
+      if (targetBrowser === 'default') {
+        return { command: 'cmd', args: ['/c', 'start', '', targetUrl] };
+      }
+      return { command: 'cmd', args: ['/c', 'start', '', 'chrome', targetUrl] };
+    }
+
+    if (platform === 'darwin') {
+      if (targetBrowser === 'default') {
+        return { command: 'open', args: [targetUrl] };
+      }
+      return { command: 'open', args: ['-a', 'Google Chrome', targetUrl] };
+    }
+
+    if (targetBrowser === 'default') {
+      return { command: 'xdg-open', args: [targetUrl] };
+    }
+    return { command: 'google-chrome', args: [targetUrl] };
+  }
+
+  async openBrowser(url = 'about:blank', browser = 'chrome') {
+    const targetUrl = String(url || 'about:blank');
+    const targetBrowser = String(browser || 'chrome').toLowerCase();
+    const launch = this.buildBrowserLaunchCommand(targetUrl, targetBrowser);
+
+    return await new Promise(resolve => {
+      let child;
+      try {
+        child = spawn(launch.command, launch.args, {
+          detached: true,
+          stdio: 'ignore',
+          windowsHide: false,
+        });
+      } catch (error) {
+        resolve({
+          success: false,
+          error: error.message,
+          recovery: 'Install Chrome or retry with OpenBrowser {"browser":"default","url":"about:blank"}.',
+        });
+        return;
+      }
+
+      child.once('error', error => {
+        resolve({
+          success: false,
+          error: error.message,
+          recovery: 'Install Chrome or retry with OpenBrowser {"browser":"default","url":"about:blank"}.',
+        });
+      });
+      child.once('spawn', () => {
+        child.unref();
+        resolve({
+          success: true,
+          browser: targetBrowser,
+          url: targetUrl,
+          command: launch.command,
+          args: launch.args,
+        });
+      });
+    });
+  }
+
   async htmlEffectivenessCompile(input, cwd) {
     const inputPath = this.resolveInputPath(input.input_path ?? input.inputPath ?? input.input, cwd);
     const outputPath = this.resolveInputPath(input.output_path ?? input.outputPath ?? input.output, cwd);