Merge branch 'master' into vsIcons

Author: Aniket-Engg

.gitignore

@@ -79,12 +79,8 @@ apps/remixdesktop/log_input_signals_new.txt
 logs
 apps/remix-ide-e2e/src/extensions/chrome/metamask
 apps/remix-ide-e2e/tmp/
-apps/remix-ide-e2e/tmp/
 
 # IDE - Cursor
-<<<<<<< HEAD
-.cursor/
-=======
 .cursor/
 PR_MESSAGE.md
->>>>>>> master
+apps/remix-ide-e2e/tmp/

apps/remix-ide-e2e/src/cleanupGroupTests.js

@@ -0,0 +1,107 @@
+const testFolder = './apps/remix-ide-e2e/src/tests/'
+const fs = require('fs')
+const path = require('path')
+
+/**
+ * This script cleans up orphaned group test files.
+ * 
+ * Group test files (e.g., editor_group1.test.ts) are automatically generated 
+ * from base test files (e.g., editor.test.ts) by buildGroupTests.js.
+ * 
+ * When a base test file is deleted or renamed, its corresponding group test 
+ * files become orphaned and need to be removed. This script:
+ * 
+ * 1. Scans all test files in the tests/ directory
+ * 2. Identifies group test files by the pattern: *_group<N>.(test.ts|flaky.ts|pr.ts)
+ * 3. Checks if the parent base test file exists
+ * 4. Removes any orphaned group test files
+ * 
+ * This script runs automatically as part of the build:e2e process to ensure
+ * the test directory stays clean.
+ * 
+ * Examples of group test files and their parents:
+ *   - editor_group1.test.ts → editor.test.ts
+ *   - terminal_group11.flaky.ts → terminal.test.ts
+ *   - matomo-consent_group2.pr.ts → matomo-consent.test.ts
+ */
+
+let orphanedCount = 0
+let deletedCount = 0
+
+console.log('🔍 Scanning for orphaned group test files...\n')
+
+// Get all files in the test folder
+const allFiles = fs.readdirSync(testFolder)
+
+// Separate base tests and group tests
+// Group tests can have patterns like:
+//   - editor_group1.test.ts (standard)
+//   - terminal_group11.flaky.ts (flaky tagged)
+//   - matomo-consent_group2.pr.ts (PR tagged)
+const groupTestPattern = /_group\d+\.(test\.ts|flaky\.ts|pr\.ts)$/
+
+const groupTests = allFiles.filter(file => groupTestPattern.test(file))
+const baseTests = allFiles.filter(file => file.endsWith('.test.ts') && !groupTestPattern.test(file))
+
+console.log(`📊 Found ${baseTests.length} base test files`)
+console.log(`📊 Found ${groupTests.length} group test files\n`)
+
+// Check each group test to see if its parent exists
+groupTests.forEach(groupFile => {
+  // Extract the base filename from the group test
+  // Examples:
+  //   editor_group1.test.ts -> editor.test.ts
+  //   dgit_local_group4.test.ts -> dgit_local.test.ts
+  //   terminal_group11.flaky.ts -> terminal.test.ts
+  
+  let baseFileName = groupFile
+    .replace(/_group\d+/, '') // Remove _groupN
+    .replace(/\.(flaky|pr)/, '') // Remove .flaky or .pr tag
+  
+  // Ensure it ends with .test.ts (but don't double up)
+  if (!baseFileName.endsWith('.test.ts')) {
+    baseFileName = baseFileName.replace(/\.ts$/, '.test.ts')
+  }
+  
+  // Check if the base test file exists
+  if (!baseTests.includes(baseFileName)) {
+    orphanedCount++
+    const groupFilePath = path.join(testFolder, groupFile)
+    
+    console.log(`❌ Orphaned: ${groupFile}`)
+    console.log(`   Missing parent: ${baseFileName}`)
+    
+    try {
+      // Read the file to verify it's a group test before deleting
+      const content = fs.readFileSync(groupFilePath, 'utf8')
+      const isGroupTest = content.includes('buildGroupTest') || 
+                          content.includes('import * as test from')
+      
+      if (isGroupTest) {
+        fs.unlinkSync(groupFilePath)
+        deletedCount++
+        console.log(`   ✅ Deleted\n`)
+      } else {
+        console.log(`   ⚠️  Skipped (not a generated group test)\n`)
+      }
+    } catch (error) {
+      console.log(`   ⚠️  Error: ${error.message}\n`)
+    }
+  }
+})
+
+// Summary
+console.log('─'.repeat(50))
+console.log(`\n📋 Summary:`)
+console.log(`   Orphaned group tests found: ${orphanedCount}`)
+console.log(`   Files deleted: ${deletedCount}`)
+
+if (deletedCount > 0) {
+  console.log(`\n✨ Cleanup completed successfully!`)
+} else if (orphanedCount === 0) {
+  console.log(`\n✅ No orphaned group tests found. Everything is clean!`)
+} else {
+  console.log(`\n⚠️  Some orphaned files were not deleted (see warnings above)`)
+}
+
+process.exit(0)

apps/remix-ide/src/app/plugins/remixAIPlugin.tsx

@@ -1,8 +1,7 @@
 import * as packageJson from '../../../../../package.json'
 import { Plugin } from '@remixproject/engine';
 import { trackMatomoEvent } from '@remix-api'
-import { IModel, RemoteInferencer, IRemoteModel, IParams, GenerationParams, AssistantParams, CodeExplainAgent, SecurityAgent, CompletionParams, OllamaInferencer, isOllamaAvailable, getBestAvailableModel } from '@remix/remix-ai-core';
-//@ts-ignore
+import { IModel, RemoteInferencer, IRemoteModel, IParams, GenerationParams, AssistantParams, CodeExplainAgent, SecurityAgent, CompletionParams, OllamaInferencer, isOllamaAvailable, getBestAvailableModel, resetOllamaHostOnSettingsChange } from '@remix/remix-ai-core';
 import { CodeCompletionAgent, ContractAgent, workspaceAgent, IContextType, mcpDefaultServersConfig } from '@remix/remix-ai-core';
 import { MCPInferencer } from '@remix/remix-ai-core';
 import { IMCPServer, IMCPConnectionStatus } from '@remix/remix-ai-core';
@@ -64,6 +63,8 @@ export class RemixAIPlugin extends Plugin {
   }
 
   onActivation(): void {
+    // Expose Ollama reset function globally for settings integration
+    resetOllamaHostOnSettingsChange();
 
     if (this.isOnDesktop) {
       this.useRemoteInferencer = true

apps/remix-ide/src/app/tabs/locales/en/settings.json

@@ -69,5 +69,8 @@
   "settings.mcpServerConfigurationDescription": "Connect to Model Context Protocol servers for enhanced AI context",
   "settings.enableMCPEnhancement": "Enable MCP Integration",
   "settings.enableMCPEnhancementDescription": "Manage your MCP server connections",
-  "settings.aiPrivacyPolicyDescription": "Understand how RemixAI processes your data."
+  "settings.aiPrivacyPolicyDescription": "Understand how RemixAI processes your data.",
+  "settings.ollamaConfig": "Ollama URL Configuration",
+  "settings.ollamaConfigDescription": "Configure Ollama endpoint for local AI model integration",
+  "settings.ollama-endpoint": "ENDPOINT URL"
 }

libs/remix-ai-core/src/index.ts

@@ -9,7 +9,7 @@ import { RemoteInferencer } from './inferencers/remote/remoteInference'
 import { OllamaInferencer } from './inferencers/local/ollamaInferencer'
 import { MCPInferencer } from './inferencers/mcp/mcpInferencer'
 import { RemixMCPServer, createRemixMCPServer } from './remix-mcp-server'
-import { isOllamaAvailable, getBestAvailableModel, listModels, discoverOllamaHost } from './inferencers/local/ollama'
+import { isOllamaAvailable, getBestAvailableModel, listModels, discoverOllamaHost, resetOllamaHostOnSettingsChange } from './inferencers/local/ollama'
 import { FIMModelManager, FIMModelConfig, FIM_MODEL_CONFIGS } from './inferencers/local/fimModelConfig'
 import { ChatHistory } from './prompts/chat'
 import { downloadLatestReleaseExecutable } from './helpers/inferenceServerReleases'
@@ -18,7 +18,7 @@ import { mcpDefaultServersConfig } from './config/mcpDefaultServers'
 export {
   IModel, IModelResponse, ChatCommandParser,
   ModelType, DefaultModels, ICompletions, IParams, IRemoteModel, buildChatPrompt,
-  RemoteInferencer, OllamaInferencer, MCPInferencer, RemixMCPServer, isOllamaAvailable, getBestAvailableModel, listModels, discoverOllamaHost,
+  RemoteInferencer, OllamaInferencer, MCPInferencer, RemixMCPServer, isOllamaAvailable, getBestAvailableModel, listModels, discoverOllamaHost, resetOllamaHostOnSettingsChange,
   FIMModelManager, FIMModelConfig, FIM_MODEL_CONFIGS, createRemixMCPServer,
   InsertionParams, CompletionParams, GenerationParams, AssistantParams,
   ChatEntry, AIRequestType, ChatHistory, downloadLatestReleaseExecutable,

libs/remix-ai-core/src/inferencers/local/ollama.ts

@@ -1,60 +1,89 @@
 import axios from 'axios';
-
-// Helper function to track events using MatomoManager instance
-function trackMatomoEvent(category: string, action: string, name?: string) {
-  try {
-    if (typeof window !== 'undefined' && (window as any)._matomoManagerInstance) {
-      (window as any)._matomoManagerInstance.trackEvent(category, action, name)
-    }
-  } catch (error) {
-    // Silent fail for tracking
-  }
-}
+import { Registry } from '@remix-project/remix-lib';
+import { trackMatomoEvent } from '@remix-api'
 
 // default Ollama ports to check (11434 is the legacy/standard port)
 const OLLAMA_PORTS = [11434, 11435, 11436];
 const OLLAMA_BASE_HOST = 'http://localhost';
+const DEFAULT_OLLAMA_HOST = 'http://localhost:11434';
 
 let discoveredOllamaHost: string | null = null;
 
+function getConfiguredOllamaEndpoint(): string | null {
+  const filemanager = Registry.getInstance().get('filemanager').api;
+  try {
+    const config = Registry.getInstance().get('config').api
+    const configuredEndpoint = config.get('settings/ollama-endpoint');
+    if (configuredEndpoint && configuredEndpoint !== DEFAULT_OLLAMA_HOST) {
+      trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: 'ollama_using_configured_endpoint', value: configuredEndpoint });
+      return configuredEndpoint;
+    }
+  } catch (error) {
+    trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: 'ollama_config_access_failed', value: error.message || 'unknown' });
+  }
+  return null;
+}
+
 export async function discoverOllamaHost(): Promise<string | null> {
+  const filemanager = Registry.getInstance().get('filemanager').api;
   if (discoveredOllamaHost) {
-    trackMatomoEvent('ai', 'remixAI', `ollama_host_cache_hit:${discoveredOllamaHost}`);
+    trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: `ollama_host_cache_hit:${discoveredOllamaHost}` })
     return discoveredOllamaHost;
   }
 
+  // First, try to use the configured endpoint from settings
+  const configuredEndpoint = getConfiguredOllamaEndpoint();
+  if (configuredEndpoint) {
+    try {
+      const res = await axios.get(`${configuredEndpoint}/api/tags`, { timeout: 2000 });
+      if (res.status === 200) {
+        discoveredOllamaHost = configuredEndpoint;
+        trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: 'ollama_configured_endpoint_success', value: configuredEndpoint });
+        return configuredEndpoint;
+      }
+      return null;
+    } catch (error) {
+      trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: 'ollama_configured_endpoint_failed', value: `${configuredEndpoint}:${error.message || 'unknown'}` });
+      // Fall back to discovery if configured endpoint fails
+      return null;
+    }
+  }
+
+  // Fall back to port discovery if no configured endpoint
   for (const port of OLLAMA_PORTS) {
     const host = `${OLLAMA_BASE_HOST}:${port}`;
-    trackMatomoEvent('ai', 'remixAI', `ollama_port_check:${port}`);
+    trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: `ollama_port_check:${port}` });
     try {
       const res = await axios.get(`${host}/api/tags`, { timeout: 2000 });
       if (res.status === 200) {
         discoveredOllamaHost = host;
-        trackMatomoEvent('ai', 'remixAI', `ollama_host_discovered_success:${host}`);
+        trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: `ollama_host_discovered_success:${host}` });
         return host;
       }
     } catch (error) {
-      trackMatomoEvent('ai', 'remixAI', `ollama_port_connection_failed:${port}:${error.message || 'unknown'}`);
+      trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: `ollama_port_connection_failed:${port}:${error.message || 'unknown'}` });
       continue; // next port
     }
   }
-  trackMatomoEvent('ai', 'remixAI', 'ollama_host_discovery_failed:no_ports_available');
+  trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: 'ollama_host_discovery_failed:no_ports_available' });
   return null;
 }
 
 export async function isOllamaAvailable(): Promise<boolean> {
-  trackMatomoEvent('ai', 'remixAI', 'ollama_availability_check:checking');
+  const filemanager = Registry.getInstance().get('filemanager').api;
+  trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: 'ollama_availability_check:checking' });
   const host = await discoverOllamaHost();
   const isAvailable = host !== null;
-  trackMatomoEvent('ai', 'remixAI', `ollama_availability_result:available:${isAvailable}`);
+  trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: `ollama_availability_result:available:${isAvailable}` });
   return isAvailable;
 }
 
 export async function listModels(): Promise<string[]> {
-  trackMatomoEvent('ai', 'remixAI', 'ollama_list_models_start:fetching');
+  const filemanager = Registry.getInstance().get('filemanager').api;
+  trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: 'ollama_list_models_start:fetching' });
   const host = await discoverOllamaHost();
   if (!host) {
-    trackMatomoEvent('ai', 'remixAI', 'ollama_list_models_failed:no_host');
+    trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: 'ollama_list_models_failed:no_host' });
     throw new Error('Ollama is not available');
   }
 
@@ -71,26 +100,35 @@ export function getOllamaHost(): string | null {
 }
 
 export function resetOllamaHost(): void {
-  trackMatomoEvent('ai', 'remixAI', `ollama_reset_host:${discoveredOllamaHost || 'null'}`);
+  const fileManager = Registry.getInstance().get('filemanager').api;
+  trackMatomoEvent(fileManager, { category: 'ai', action: 'remixAI', name: `ollama_reset_host:${discoveredOllamaHost || 'null'}` });
   discoveredOllamaHost = null;
 }
 
+export function resetOllamaHostOnSettingsChange(): void {
+  const fileManager = Registry.getInstance().get('filemanager').api;
+  // This function should be called when Ollama settings are updated
+  resetOllamaHost();
+  trackMatomoEvent(fileManager, { category: 'ai', action: 'remixAI', name: 'ollama_reset_on_settings_change' });
+}
+
 export async function pullModel(modelName: string): Promise<void> {
+  const filemanager = Registry.getInstance().get('filemanager').api;
   // in case the user wants to pull a model from registry
-  trackMatomoEvent('ai', 'remixAI', `ollama_pull_model_start:${modelName}`);
+  trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: `ollama_pull_model_start:${modelName}` });
   const host = await discoverOllamaHost();
   if (!host) {
-    trackMatomoEvent('ai', 'remixAI', `ollama_pull_model_failed:${modelName}|no_host`);
+    trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: `ollama_pull_model_failed:${modelName}|no_host` });
     throw new Error('Ollama is not available');
   }
 
   try {
     const startTime = Date.now();
     await axios.post(`${host}/api/pull`, { name: modelName });
     const duration = Date.now() - startTime;
-    trackMatomoEvent('ai', 'remixAI', `ollama_pull_model_success:${modelName}|duration:${duration}ms`);
+    trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: `ollama_pull_model_success:${modelName}|duration:${duration}ms` });
   } catch (error) {
-    trackMatomoEvent('ai', 'remixAI', `ollama_pull_model_error:${modelName}|${error.message || 'unknown'}`);
+    trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: `ollama_pull_model_error:${modelName}|${error.message || 'unknown'}` });
     console.error('Error pulling model:', error);
     throw new Error(`Failed to pull model: ${modelName}`);
   }
@@ -106,7 +144,8 @@ export async function validateModel(modelName: string): Promise<boolean> {
 }
 
 export async function getBestAvailableModel(): Promise<string | null> {
-  trackMatomoEvent('ai', 'remixAI', 'ollama_get_best');
+  const filemanager = Registry.getInstance().get('filemanager').api;
+  trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: 'ollama_get_best' });
   try {
     const models = await listModels();
     if (models.length === 0) return null;
@@ -125,7 +164,7 @@ export async function getBestAvailableModel(): Promise<string | null> {
     // TODO get model stats and get best model
     return models[0];
   } catch (error) {
-    trackMatomoEvent('ai', 'remixAI', `ollama_get_best_model_error:${error.message || 'unknown'}`);
+    trackMatomoEvent(filemanager, { category: 'ai', action: 'remixAI', name: `ollama_get_best_model_error:${error.message || 'unknown'}` });
     console.error('Error getting best available model:', error);
     return null;
   }

libs/remix-ai-core/src/inferencers/mcp/toolApiGenerator.ts

@@ -25,12 +25,6 @@ const modified = fileContent.replace('old', 'new');
 const compiled = await callMCPTool('solidity_compile', { file: 'contract.sol' });
 const deployed = await callMCPTool('deploy_contract', { contractName: 'MyToken' });
 
-// Multiple tasks 2
-const fileContent = await callMCPTool('file_read', { path:'contract.sol' });
-const content = JSON.parse(fileContent.content[0].text).content
-const updatedContent = fileContent.replace('contract Subscription', 'contract MySubscriptionContract');
-await callMCPTool('file_write', { path: 'ccontract.sol', content: updatedContent });
-
 
 // With loops for batch operations
 const files = ['contracts/Token.sol', 'contracts/NFT.sol', 'contracts/DAO.sol'];

libs/remix-ai-core/src/inferencers/remote/remoteInference.ts

@@ -24,13 +24,13 @@ export class RemoteInferencer implements ICompletions, IGeneration {
   protected sanitizePromptByteSize(prompt: string, provider?: string): string {
     // Provider-specific max byte limits
     const providerLimits: Record<string, number> = {
-      'mistralai': 80000,
-      'anthropic': 80000,
-      'openai': 80000
+      'mistralai': 70000,
+      'anthropic': 70000,
+      'openai': 70000
     };
 
-    // Get max bytes based on provider, default to 80KB
-    const maxBytes = provider ? (providerLimits[provider.toLowerCase()] || 80000) : 80000;
+    // Get max bytes based on provider, default to 70KB
+    const maxBytes = provider ? (providerLimits[provider.toLowerCase()] || 70000) : 70000;
 
     const encoder = new TextEncoder();
     const promptBytes = encoder.encode(prompt); // rough estimation, real size might be 10% more