trace.ai-cli 1.2.0 → 1.2.1

package/cli/traceAI.js

@@ -26,16 +26,16 @@ class TraceAI {
     async start() {
         // Clear screen for clean start
         console.clear();
-        
+
         // Animated startup sequence
         await this.showLoadingAnimation();
-        
+
         // Main header with enhanced ASCII art
         await this.displayHeader();
-        
+
         // Show welcome message and commands
         this.displayWelcomeMessage();
-        
+
         // Start the interactive session
         this.promptUser();
     }
@@ -48,7 +48,7 @@ class TraceAI {
             'Preparing analysis engines...',
             'Ready to trace!'
         ];
-        
+
         for (let i = 0; i < messages.length; i++) {
             for (let j = 0; j < 10; j++) {
                 process.stdout.write(`\r${chalk.blueBright(frames[j % frames.length])} ${chalk.white(messages[i])}`);
@@ -66,14 +66,14 @@ class TraceAI {
             horizontalLayout: 'fitted',
             verticalLayout: 'default'
         });
-        
+
         // Enhanced header with gradient effect
         console.log(chalk.bold.blueBright(asciiArt));
-        
+
         // Subtitle and version info
         console.log(chalk.gray.bold('          ') + chalk.white.bold('AI powered CLI Platform'));
         console.log(chalk.gray('          ') + chalk.gray('v1.2.0 | Powered by Mixkey'));
-        
+
         // Dynamic separator
         const width = process.stdout.columns || 80;
         console.log(chalk.blueBright('═'.repeat(Math.min(width, 80))));
@@ -82,11 +82,11 @@ class TraceAI {
     displayWelcomeMessage() {
         // Welcome section with better formatting
         console.log(chalk.bold.green('\nWelcome to Trace.AI CLI'));
-        console.log();        
+        console.log();
         // Enhanced command documentation
         console.log(chalk.bold.cyan('📋 AVAILABLE COMMANDS'));
         console.log(chalk.gray('━'.repeat(50)));
-        
+
         const commands = [
             {
                 cmd: '/file <path> [question]',
@@ -174,10 +174,10 @@ class TraceAI {
         console.log(chalk.white('• Use ') + chalk.cyan('Tab') + chalk.white(' for auto-completion (when available)'));
         console.log(chalk.white('• Start with ') + chalk.cyan('/file "your-file.js"') + chalk.white(' to analyze code'));
         console.log(chalk.white('• Or just ask any question directly!'));
-        
+
         // Status bar
         this.displayStatusBar();
-        
+
         console.log(chalk.gray('\n' + '─'.repeat(60)));
 
     }
@@ -186,12 +186,12 @@ class TraceAI {
         const uptime = Math.floor((new Date() - this.sessionStartTime) / 1000);
         const contextCount = this.contexts.length;
         const modeLabel = this.mode === 1 ? 'Fast' : this.mode === 2 ? 'Balanced' : 'Think';
-        
+
         console.log(chalk.gray('\n┌─ SESSION INFO ') + chalk.gray('─'.repeat(34)));
-        console.log(chalk.gray('│ ') + chalk.white('Uptime: ') + chalk.green(`${uptime}s`) + 
-                   chalk.gray(' │ ') + chalk.white('Contexts: ') + chalk.cyan(contextCount) + 
-                   chalk.gray(' │ ') + chalk.white('Queries: ') + chalk.blueBright(this.queryCount) +
-                   chalk.gray(' │ ') + chalk.white('Mode: ') + chalk.magenta(modeLabel));
+        console.log(chalk.gray('│ ') + chalk.white('Uptime: ') + chalk.green(`${uptime}s`) +
+            chalk.gray(' │ ') + chalk.white('Contexts: ') + chalk.cyan(contextCount) +
+            chalk.gray(' │ ') + chalk.white('Queries: ') + chalk.blueBright(this.queryCount) +
+            chalk.gray(' │ ') + chalk.white('Mode: ') + chalk.magenta(modeLabel));
         console.log(chalk.gray('└─') + chalk.gray('─'.repeat(48)));
     }
 
@@ -199,7 +199,7 @@ class TraceAI {
         // Enhanced prompt with status indicators
         const contextIndicator = this.contexts.length > 0 ? chalk.cyan(`[${this.contexts.length}]`) : '';
         const prompt = `${chalk.bold.blueBright('Trace.Ai')} ${contextIndicator}${chalk.gray('>')} `;
-        
+
         this.rl.question(prompt, async (input) => {
             try {
                 if (input.trim()) {
@@ -215,7 +215,7 @@ class TraceAI {
 
     async handleInput(input) {
         const trimmedInput = input.trim();
-        
+
         if (!trimmedInput) return;
 
         // Command routing with enhanced feedback
@@ -236,7 +236,7 @@ class TraceAI {
 
         // Find and execute command
         const commandKey = Object.keys(commands).find(cmd => trimmedInput.startsWith(cmd));
-        
+
         if (commandKey) {
             await commands[commandKey]();
         } else {
@@ -336,12 +336,12 @@ class TraceAI {
 
         console.log(chalk.bold.green('\n📋 ACTIVE CONTEXTS'));
         console.log(chalk.gray('━'.repeat(50)));
-        
+
         this.contexts.forEach((ctx, index) => {
             const icon = ctx.type === 'file' ? '📄' : '💭';
             const preview = ctx.content.substring(0, 80).replace(/\n/g, ' ');
             const truncated = ctx.content.length > 80 ? '...' : '';
-            
+
             console.log(`${chalk.blueBright(icon)} ${chalk.bold(`[${index + 1}]`)} ${chalk.gray(ctx.timestamp)}`);
             console.log(`   ${chalk.white(preview)}${chalk.gray(truncated)}`);
             if (index < this.contexts.length - 1) console.log();
@@ -365,26 +365,26 @@ class TraceAI {
     }
 
     displayHelp() {
-        
+
         console.log(chalk.bold.green('\n📖 DETAILED HELP GUIDE'));
         console.log(chalk.gray('━'.repeat(60)));
-        
+
         console.log(chalk.bold.cyan('\n🎯 GETTING STARTED'));
         console.log('Trace.AI is an intelligent CLI tool that helps you understand and analyze files,');
         console.log('folder structures, and images using advanced AI capabilities.\n');
-        
+
         console.log(chalk.bold.cyan('💡 TIPS FOR BETTER RESULTS'));
         console.log('• Be specific in your questions');
         console.log('• Use context to provide background information');
         console.log('• Combine multiple commands for comprehensive analysis');
         console.log('• File paths with spaces should be quoted\n');
-        
+
         console.log(chalk.bold.cyan('🔧 TROUBLESHOOTING'));
         console.log('• Ensure file paths are correct and accessible');
         console.log('• Check file permissions for read access');
         console.log('• Use /stats to monitor your session');
         console.log('• Use /clear screen to refresh the interface\n');
-        
+
         console.log(chalk.gray('Press any key to continue...'));
 
     }
@@ -393,7 +393,7 @@ class TraceAI {
         const uptime = Math.floor((new Date() - this.sessionStartTime) / 1000);
         const minutes = Math.floor(uptime / 60);
         const seconds = uptime % 60;
-        
+
         console.log(chalk.bold.green('\n📊 SESSION STATISTICS'));
         console.log(chalk.gray('━'.repeat(40)));
         console.log(`${chalk.blueBright('🕐')} Session Duration: ${chalk.white(`${minutes}m ${seconds}s`)}`);
@@ -403,10 +403,10 @@ class TraceAI {
         console.log(`${chalk.blueBright('📅')} Started: ${chalk.white(this.sessionStartTime.toLocaleString())}`);
         console.log(chalk.gray('━'.repeat(40)));
     }
-    
+
     async handleSystemCommand(input) {
         const query = input.substring('/system'.length).trim();
-        
+
         await this.executeWithSpinner(
             'Retrieving system information',
             async () => {
@@ -464,12 +464,12 @@ class TraceAI {
     async executeWithSpinner(message, task) {
         const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
         let frameIndex = 0;
-        
+
         const spinner = setInterval(() => {
             process.stdout.write(`\r${chalk.blueBright(frames[frameIndex])} ${chalk.white(message)}`);
             frameIndex = (frameIndex + 1) % frames.length;
         }, 100);
-        
+
         try {
             await task();
             clearInterval(spinner);
@@ -498,30 +498,30 @@ class TraceAI {
     }
 
     close() {
-        
+
         // Farewell message
         const farewell = figlet.textSync('Goodbye!', {
             font: 'Small',
             horizontalLayout: 'fitted'
         });
-        
+
         console.log(chalk.blueBright(farewell));
         console.log(chalk.gray('━'.repeat(50)));
         console.log(chalk.bold.green('Thank you for using Trace.AI!'));
-        
+
         // Session summary
         const uptime = Math.floor((new Date() - this.sessionStartTime) / 1000);
         const minutes = Math.floor(uptime / 60);
         const seconds = uptime % 60;
-        
+
         console.log(chalk.gray(`Session Duration: ${minutes}m ${seconds}s`));
         console.log(chalk.gray(`Total Queries: ${this.queryCount}`));
         console.log(chalk.gray(`Contexts Used: ${this.contexts.length}`));
-        
+
         console.log(chalk.gray('━'.repeat(50)));
         console.log(chalk.cyan('Visit us at: https://traceai.netlify.app'));
         console.log(chalk.gray('Have a great day! 👋\n'));
-        
+
         this.rl.close();
         process.exit(0);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "trace.ai-cli",
-    "version": "1.2.0",
+    "version": "1.2.1",
     "description": "A powerful AI-powered CLI tool",
     "main": "index.js",
     "bin": {
@@ -37,10 +37,9 @@
         "ora": "^5.4.1",
         "os-utils": "^0.0.14",
         "pdf-parse": "^1.1.1",
-        "systeminformation": "^5.27.1",
-        "trace.ai-cli": "^1.1.8"
+        "systeminformation": "^5.27.1"
     },
     "engines": {
         "node": ">=14.0.0"
     }
-}
+}

package/services/aiService.js

@@ -2,17 +2,17 @@ const fetch = require('node-fetch');
 const { encryptData, decryptData } = require('../utils/encryption');
 const { getSystemInfo, formatBytes } = require('./systemInfoService');
 
-// Model selection helpers
-function getTextModels(mode) {
+// Mode selection helpers
+function getMode(mode) {
     switch (Number(mode)) {
         case 1: // Fast
-            return ['g1'];
+            return 'fast';
         case 2: // Balanced
-            return ['sct', 'g1', 'gptoss20'];
+            return 'balance';
         case 3: // Think
-            return ['kimi', 'mvrk', 'gma3', 'dsv3', 'sct', 'gptoss120', 'gptoss20', 'll70b', 'qw3', 'nlm3'];
+            return 'think';
         default:
-            return ['sct', 'g1', 'gptoss20'];
+            return 'balance';
     }
 }
 
@@ -52,88 +52,82 @@ Examples:
 "Network and disk status" -> network disk
 
 Only respond with the category names, nothing else. Be precise and focus on what the user actually needs.`;
-        
-        // Use multiple AI models to analyze the query
-        const models = getTextModels(2); // Balanced by default
-        
-        const modelRequests = models.map(async (model) => {
-            try {
-                const response = await fetch('https://traceai.dukeindustries7.workers.dev/', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: encryptData({
-                        a: model,
-                        q: analysisPrompt,
-                        r: [],
-                        i: [],
-                        c: JSON.stringify({
-                            basicInfo,
-                            timestamp: currentTimestamp,
-                            user: basicInfo.user
-                        })
+
+        // Use AI to analyze the query with balanced mode
+        const mode = getMode(2); // Balanced by default
+
+        try {
+            const response = await fetch('https://traceai.dukeindustries7.workers.dev/', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: encryptData({
+                    a: mode,
+                    q: analysisPrompt,
+                    i: [],
+                    c: JSON.stringify({
+                        basicInfo,
+                        timestamp: currentTimestamp,
+                        user: basicInfo.user
                     })
-                });
-                
-                const text = await response.text();
-                const decrypted = decryptData(text);
-                return decrypted;
-            } catch (e) {
-        
-                return null;
-            }
-        });
-
-        const responses = await Promise.all(modelRequests);
-        
-        // Filter out null responses and extract valid text
-        const validResponses = responses
-            .filter(r => r && r.text && typeof r.text === 'string')
-            .map(r => r.text.toLowerCase().trim());
-        
-
-        
-        // Analyze responses to determine categories
-        let categories = new Set();
-        const validCategories = ['basic', 'cpu', 'memory', 'disk', 'network', 'process', 'environment', 'all'];
-        
-        if (validResponses.length > 0) {
-            // Process each response and count category occurrences
-            const categoryCount = {};
-            
-            for (const response of validResponses) {
-                const words = response.split(/\s+/);
-                for (const word of words) {
-                    if (validCategories.includes(word)) {
-                        categoryCount[word] = (categoryCount[word] || 0) + 1;
-                        categories.add(word);
+                })
+            });
+
+            const text = await response.text();
+            const decrypted = decryptData(text);
+            const responses = [decrypted];
+
+            // Filter out null responses and extract valid text
+            const validResponses = responses
+                .filter(r => r && r.text && typeof r.text === 'string')
+                .map(r => r.text.toLowerCase().trim());
+
+
+
+            // Analyze responses to determine categories
+            let categories = new Set();
+            const validCategories = ['basic', 'cpu', 'memory', 'disk', 'network', 'process', 'environment', 'all'];
+
+            if (validResponses.length > 0) {
+                // Process each response and count category occurrences
+                const categoryCount = {};
+
+                for (const response of validResponses) {
+                    const words = response.split(/\s+/);
+                    for (const word of words) {
+                        if (validCategories.includes(word)) {
+                            categoryCount[word] = (categoryCount[word] || 0) + 1;
+                            categories.add(word);
+                        }
                     }
                 }
+
+                // If we found 'all', that takes precedence
+                if (categories.has('all')) {
+                    return { query: 'all' };
+                }
+
+                // If we have valid categories, use the most commonly mentioned ones
+                if (categories.size > 0) {
+                    // Sort categories by frequency and take top ones
+                    const sortedCategories = Object.entries(categoryCount)
+                        .sort(([, a], [, b]) => b - a)
+                        .map(([category]) => category);
+
+                    const query = sortedCategories.join(' ');
+                    return { query };
+                }
             }
-            
-            // If we found 'all', that takes precedence
-            if (categories.has('all')) {
-                return { query: 'all' };
-            }
-            
-            // If we have valid categories, use the most commonly mentioned ones
-            if (categories.size > 0) {
-                // Sort categories by frequency and take top ones
-                const sortedCategories = Object.entries(categoryCount)
-                    .sort(([,a], [,b]) => b - a)
-                    .map(([category]) => category);
-                
-                const query = sortedCategories.join(' ');
-                return { query };
-            }
+        } catch (e) {
+            // If API call fails, fall through to keyword matching
         }
-        
+
         // Fallback: use keyword matching if AI didn't provide valid responses
 
         const fallbackCategories = determineCategoriesByKeywords(prompt);
         return { query: fallbackCategories };
-        
+
     } catch (error) {
-    
+
         // Final fallback to basic info
         return { query: 'basic' };
     }
@@ -147,11 +141,11 @@ Only respond with the category names, nothing else. Be precise and focus on what
 function determineCategoriesByKeywords(prompt) {
     const lowerPrompt = prompt.toLowerCase();
     const categories = new Set();
-    
+
     // Define comprehensive keyword patterns for each category
     const patterns = {
         cpu: [
-            'cpu', 'processor', 'core', 'thread', 'clock', 'speed', 'ghz', 'mhz', 
+            'cpu', 'processor', 'core', 'thread', 'clock', 'speed', 'ghz', 'mhz',
             'load', 'usage', 'temperature', 'intel', 'amd', 'arm', 'performance',
             'benchmark', 'processing', 'compute', 'cores', 'threads', 'frequency'
         ],
@@ -161,12 +155,12 @@ function determineCategoriesByKeywords(prompt) {
             'virtual memory', 'physical memory', 'memory usage'
         ],
         disk: [
-            'disk', 'drive', 'storage', 'space', 'filesystem', 'mount', 'partition', 
+            'disk', 'drive', 'storage', 'space', 'filesystem', 'mount', 'partition',
             'volume', 'hdd', 'ssd', 'nvme', 'capacity', 'free space', 'used space',
             'hard drive', 'solid state', 'storage device', 'file system'
         ],
         network: [
-            'network', 'internet', 'wifi', 'ip', 'address', 'connection', 'interface', 
+            'network', 'internet', 'wifi', 'ip', 'address', 'connection', 'interface',
             'ethernet', 'wireless', 'lan', 'wan', 'dns', 'gateway', 'router', 'subnet',
             'bandwidth', 'latency', 'ping', 'download', 'upload', 'mac address'
         ],
@@ -186,13 +180,13 @@ function determineCategoriesByKeywords(prompt) {
             'operating system', 'computer', 'device', 'hardware'
         ]
     };
-    
+
     // Check for 'all' keywords first
     const allKeywords = ['all', 'everything', 'complete', 'full', 'entire', 'comprehensive'];
     if (allKeywords.some(keyword => lowerPrompt.includes(keyword))) {
         return 'all';
     }
-    
+
     // Check each category and count matches
     const categoryMatches = {};
     for (const [category, keywords] of Object.entries(patterns)) {
@@ -202,12 +196,12 @@ function determineCategoriesByKeywords(prompt) {
             categoryMatches[category] = matches;
         }
     }
-    
+
     // If no categories matched, default to basic
     if (categories.size === 0) {
         categories.add('basic');
     }
-    
+
     const result = Array.from(categories).join(' ');
 
     return result;
@@ -223,11 +217,11 @@ async function formatSystemInfoResponse(sysInfo, prompt) {
     try {
         // Check if we have any system information
         const hasInfo = Object.keys(sysInfo).length > 0;
-        
+
         if (!hasInfo) {
             return getHelpMessage(prompt);
         }
-        
+
         // Use AI to format the response based on the user's specific question
         const formattingPrompt = `Current Date/Time: 2025-07-09 10:45:40 UTC
 User: m0v0dga_walmart
@@ -264,9 +258,8 @@ Make the response helpful and easy to understand for the user.`;
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: encryptData({
-                    a: getTextModels(2)[0], // Use the first Balanced text model for formatting
+                    a: getMode(2), // Use balanced mode for formatting
                     q: formattingPrompt,
-                    r: [],
                     i: [],
                     c: JSON.stringify({
                         timestamp: '2025-07-09 10:45:40',
@@ -278,18 +271,18 @@ Make the response helpful and easy to understand for the user.`;
 
             const encryptedResult = await response.text();
             const decryptedResult = decryptData(encryptedResult);
-            
+
             if (decryptedResult.text && typeof decryptedResult.text === 'string') {
-    
+
                 return decryptedResult.text;
             }
         } catch (aiError) {
         }
-        
+
         // Fallback to manual formatting if AI fails
 
         return formatSystemInfoManually(sysInfo, prompt);
-        
+
     } catch (error) {
         // Fallback to manual formatting
         return formatSystemInfoManually(sysInfo, prompt);
@@ -305,7 +298,7 @@ Make the response helpful and easy to understand for the user.`;
 function formatSystemInfoManually(sysInfo, prompt) {
     let response = `Here's the system information you requested:\n\n`;
     response += `*System information as of 2025-07-09 10:45:40 UTC*\n\n`;
-    
+
     if (sysInfo.basic) {
         const basic = sysInfo.basic;
         response += `📱 **System Overview**\n`;
@@ -316,17 +309,17 @@ function formatSystemInfoManually(sysInfo, prompt) {
         if (basic.model) response += `- Model: ${basic.model}\n`;
         if (basic.distro) response += `- Distribution: ${basic.distro}\n`;
         if (basic.kernel) response += `- Kernel: ${basic.kernel}\n`;
-        
+
         const uptimeHours = Math.floor((basic.uptime || 0) / 3600);
         const uptimeMinutes = Math.floor(((basic.uptime || 0) % 3600) / 60);
         response += `- Uptime: ${uptimeHours} hours ${uptimeMinutes} minutes\n`;
-        
+
         if (basic.loadAvg && Array.isArray(basic.loadAvg)) {
             response += `- Load Average: ${basic.loadAvg.map(load => load.toFixed(2)).join(', ')}\n`;
         }
         response += `\n`;
     }
-    
+
     if (sysInfo.cpu) {
         const cpu = sysInfo.cpu;
         response += `💻 **CPU Information**\n`;
@@ -336,23 +329,23 @@ function formatSystemInfoManually(sysInfo, prompt) {
         if (cpu.physicalCores) response += `- Physical Cores: ${cpu.physicalCores}\n`;
         if (cpu.speed) response += `- Base Speed: ${cpu.speed} MHz\n`;
         if (cpu.speedMax) response += `- Max Speed: ${cpu.speedMax} MHz\n`;
-        
+
         if (cpu.load) {
             if (cpu.load.currentLoad !== undefined) response += `- Current Load: ${cpu.load.currentLoad.toFixed(2)}%\n`;
             if (cpu.load.currentLoadUser !== undefined) response += `- User Load: ${cpu.load.currentLoadUser.toFixed(2)}%\n`;
             if (cpu.load.currentLoadSystem !== undefined) response += `- System Load: ${cpu.load.currentLoadSystem.toFixed(2)}%\n`;
         }
-        
+
         if (cpu.temperature && cpu.temperature.main) {
             response += `- Temperature: ${cpu.temperature.main}°C\n`;
         }
-        
+
         if (cpu.loadAvg && Array.isArray(cpu.loadAvg)) {
             response += `- Load Average: ${cpu.loadAvg.map(load => load.toFixed(2)).join(', ')}\n`;
         }
         response += `\n`;
     }
-    
+
     if (sysInfo.memory) {
         const memory = sysInfo.memory;
         response += `🧠 **Memory Information**\n`;
@@ -361,13 +354,13 @@ function formatSystemInfoManually(sysInfo, prompt) {
         response += `- Free: ${memory.free || 'Unknown'}\n`;
         if (memory.available) response += `- Available: ${memory.available}\n`;
         if (memory.active) response += `- Active: ${memory.active}\n`;
-        
+
         if (memory.swap) {
             response += `- Swap Total: ${memory.swap.total || 'Unknown'}\n`;
             response += `- Swap Used: ${memory.swap.used || 'Unknown'} (${memory.swap.usagePercent || 'Unknown'})\n`;
             response += `- Swap Free: ${memory.swap.free || 'Unknown'}\n`;
         }
-        
+
         if (memory.layout && Array.isArray(memory.layout) && memory.layout.length > 0) {
             response += `- Memory Modules: ${memory.layout.length} installed\n`;
             memory.layout.forEach((module, index) => {
@@ -381,10 +374,10 @@ function formatSystemInfoManually(sysInfo, prompt) {
         }
         response += `\n`;
     }
-    
+
     if (sysInfo.disk) {
         response += `💾 **Disk Information**\n`;
-        
+
         if (sysInfo.disk.fsSize && Array.isArray(sysInfo.disk.fsSize)) {
             response += `- File Systems:\n`;
             sysInfo.disk.fsSize.forEach(fs => {
@@ -412,7 +405,7 @@ function formatSystemInfoManually(sysInfo, prompt) {
         } else if (sysInfo.disk.error) {
             response += `- Error retrieving disk information: ${sysInfo.disk.error}\n`;
         }
-        
+
         if (sysInfo.disk.diskLayout && Array.isArray(sysInfo.disk.diskLayout)) {
             response += `- Physical Disks: ${sysInfo.disk.diskLayout.length} detected\n`;
             sysInfo.disk.diskLayout.forEach((disk, index) => {
@@ -424,14 +417,14 @@ function formatSystemInfoManually(sysInfo, prompt) {
         }
         response += `\n`;
     }
-    
+
     if (sysInfo.network) {
         response += `🌐 **Network Information**\n`;
-        
+
         if (sysInfo.network.publicIp && sysInfo.network.publicIp !== 'Not available') {
             response += `- Public IP: ${sysInfo.network.publicIp}\n`;
         }
-        
+
         if (sysInfo.network.interfaces && Array.isArray(sysInfo.network.interfaces)) {
             const activeInterfaces = sysInfo.network.interfaces.filter(iface => !iface.internal);
             if (activeInterfaces.length > 0) {
@@ -457,20 +450,20 @@ function formatSystemInfoManually(sysInfo, prompt) {
                 });
             }
         }
-        
+
         if (sysInfo.network.internetLatency && sysInfo.network.internetLatency !== 'N/A ms') {
             response += `- Internet Connectivity: ${sysInfo.network.internetLatency}\n`;
         }
-        
+
         if (sysInfo.network.connections && typeof sysInfo.network.connections === 'number') {
             response += `- Active Connections: ${sysInfo.network.connections}\n`;
         }
         response += `\n`;
     }
-    
+
     if (sysInfo.process) {
         response += `⚙️ **Process Information**\n`;
-        
+
         if (sysInfo.process.currentProcess) {
             const current = sysInfo.process.currentProcess;
             response += `- Current Process:\n`;
@@ -488,7 +481,7 @@ function formatSystemInfoManually(sysInfo, prompt) {
                 response += `- Memory Usage: ${Math.round(sysInfo.process.memoryUsage.rss / (1024 * 1024))} MB\n`;
             }
         }
-        
+
         if (sysInfo.process.summary) {
             const summary = sysInfo.process.summary;
             response += `- Process Summary:\n`;
@@ -497,7 +490,7 @@ function formatSystemInfoManually(sysInfo, prompt) {
             if (summary.sleeping) response += `  - Sleeping: ${summary.sleeping}\n`;
             if (summary.blocked) response += `  - Blocked: ${summary.blocked}\n`;
         }
-        
+
         if (sysInfo.process.topProcesses && Array.isArray(sysInfo.process.topProcesses) && sysInfo.process.topProcesses.length > 0) {
             response += `- Top Processes (by CPU):\n`;
             sysInfo.process.topProcesses.slice(0, 5).forEach((proc, index) => {
@@ -506,10 +499,10 @@ function formatSystemInfoManually(sysInfo, prompt) {
         }
         response += `\n`;
     }
-    
+
     if (sysInfo.environment) {
         response += `🔧 **Environment Information**\n`;
-        
+
         if (sysInfo.environment.variables) {
             const envVars = sysInfo.environment.variables;
             response += `- Key Environment Variables:\n`;
@@ -519,20 +512,20 @@ function formatSystemInfoManually(sysInfo, prompt) {
                     response += `  - ${varName}: ${envVars[varName]}\n`;
                 }
             });
-            
+
             const otherVars = Object.keys(envVars).filter(key => !importantVars.includes(key));
             if (otherVars.length > 0) {
                 response += `  - Other variables: ${otherVars.length} additional environment variables\n`;
             }
         }
-        
+
         if (sysInfo.environment.users && Array.isArray(sysInfo.environment.users) && sysInfo.environment.users.length > 0) {
             response += `- Active Users: ${sysInfo.environment.users.length}\n`;
         }
         response += `\n`;
     }
-    
-    response ;
+
+    response;
     return response;
 }
 
@@ -543,73 +536,73 @@ function formatSystemInfoManually(sysInfo, prompt) {
  */
 function getHelpMessage(prompt) {
     return `I couldn't find specific system information for your query: "${prompt}"\n\n` +
-           `*Available system information queries:*\n\n` +
-           `📱 **Basic System Info:**\n` +
-           `- "What's my system info?" - Platform, OS, architecture\n` +
-           `- "System overview" - Complete basic information\n\n` +
-           `💻 **CPU Information:**\n` +
-           `- "What's my CPU usage?" - Processor load and performance\n` +
-           `- "Show me processor info" - CPU specifications\n\n` +
-           `🧠 **Memory Information:**\n` +
-           `- "How much RAM do I have?" - Memory specifications\n` +
-           `- "Memory usage" - Current memory utilization\n\n` +
-           `💾 **Disk Information:**\n` +
-           `- "How much disk space?" - Storage capacity and usage\n` +
-           `- "Storage info" - Disk and filesystem details\n\n` +
-           `🌐 **Network Information:**\n` +
-           `- "What's my IP address?" - Network interface details\n` +
-           `- "Network status" - Connection and interface info\n\n` +
-           `⚙️ **Process Information:**\n` +
-           `- "What processes are running?" - Active processes and services\n` +
-           `- "Process info" - System process details\n\n` +
-           `🔧 **Environment Variables:**\n` +
-           `- "Show environment variables" - System configuration\n` +
-           `- "User info" - User and shell information\n\n` +
-           `📊 **Complete Information:**\n` +
-           `- "Show me all system information" - Everything available\n` +
-           `- "Complete system report" - Comprehensive overview\n\n` +
-           `*System information as of 2025-07-09 10:45:40 UTC*\n` +
-           `*User: m0v0dga_walmart*`;
+        `*Available system information queries:*\n\n` +
+        `📱 **Basic System Info:**\n` +
+        `- "What's my system info?" - Platform, OS, architecture\n` +
+        `- "System overview" - Complete basic information\n\n` +
+        `💻 **CPU Information:**\n` +
+        `- "What's my CPU usage?" - Processor load and performance\n` +
+        `- "Show me processor info" - CPU specifications\n\n` +
+        `🧠 **Memory Information:**\n` +
+        `- "How much RAM do I have?" - Memory specifications\n` +
+        `- "Memory usage" - Current memory utilization\n\n` +
+        `💾 **Disk Information:**\n` +
+        `- "How much disk space?" - Storage capacity and usage\n` +
+        `- "Storage info" - Disk and filesystem details\n\n` +
+        `🌐 **Network Information:**\n` +
+        `- "What's my IP address?" - Network interface details\n` +
+        `- "Network status" - Connection and interface info\n\n` +
+        `⚙️ **Process Information:**\n` +
+        `- "What processes are running?" - Active processes and services\n` +
+        `- "Process info" - System process details\n\n` +
+        `🔧 **Environment Variables:**\n` +
+        `- "Show environment variables" - System configuration\n` +
+        `- "User info" - User and shell information\n\n` +
+        `📊 **Complete Information:**\n` +
+        `- "Show me all system information" - Everything available\n` +
+        `- "Complete system report" - Comprehensive overview\n\n` +
+        `*System information as of 2025-07-09 10:45:40 UTC*\n` +
+        `*User: m0v0dga_walmart*`;
 }
 
 async function processWithAI(prompt, context = '', mode = 2) {
     try {
-        
+
         // Enhanced system query detection - but EXCLUDE file/folder analysis prompts
         const systemKeywords = [
-            'system', 'cpu', 'memory', 'ram', 'disk', 'network', 'ip', 'process', 
+            'system', 'cpu', 'memory', 'ram', 'disk', 'network', 'ip', 'process',
             'environment', 'hardware', 'computer', 'machine', 'specs', 'info',
             'information', 'status', 'usage', 'performance', 'storage', 'processor'
         ];
-        
+
         // Check if this is a file/folder analysis (these should NOT trigger system info)
-        const isFileAnalysis = prompt.includes('File:') || 
-                               prompt.includes('Analyze this') || 
-                               prompt.includes('code file') ||
-                               prompt.includes('Content:') ||
-                               prompt.includes('User Question:');
-        
+        const isFileAnalysis = prompt.includes('File:') ||
+            prompt.includes('Analyze this') ||
+            prompt.includes('code file') ||
+            prompt.includes('Content:') ||
+            prompt.includes('User Question:');
+
         const isSystemQuery = !isFileAnalysis && (
-            systemKeywords.some(keyword => prompt.toLowerCase().includes(keyword)) || 
+            systemKeywords.some(keyword => prompt.toLowerCase().includes(keyword)) ||
             prompt.toLowerCase().startsWith('get system information') ||
             prompt.toLowerCase().includes('/system')
         );
-        
+
         if (isSystemQuery) {
             try {
-                
+
                 // First get basic system info to provide context
                 const basicInfo = await getSystemInfo('basic');
-                
+
                 // Use AI to determine what system information is being requested
                 const aiResponse = await determineSystemInfoQuery(prompt, basicInfo);
-                
+
                 // Get the specific system information based on AI's determination
                 const systemInfo = await getSystemInfo(aiResponse.query);
-                
+
                 // Format the response using AI
                 const formattedResponse = await formatSystemInfoResponse(systemInfo, prompt);
-                
+
                 return formattedResponse;
             } catch (sysError) {
                 console.error(`[${new Date().toISOString()}] ❌ System info error:`, sysError.message);
@@ -617,61 +610,35 @@ async function processWithAI(prompt, context = '', mode = 2) {
                 return `I encountered an error retrieving system information: ${sysError.message}\n\nPlease try a more specific query or check the system status.`;
             }
         }
-        
+
         // Regular AI processing for non-system queries
-        const models = getTextModels(mode); // Use selected mode
-        
-        const modelRequests = models.map(async (model) => {
-            try {
-                const response = await fetch('https://traceai.dukeindustries7.workers.dev/', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: encryptData({
-                        a: model,
-                        q: prompt,
-                        r: [],
-                        i: [],
-                        c: context
-                    })
-                });
-                
-                const text = await response.text();
-                return decryptData(text);
-            } catch (error) {
-                return { text: null };
-            }
-        });
+        const selectedMode = getMode(mode); // Use selected mode
+
+        try {
+            const response = await fetch('https://traceai.dukeindustries7.workers.dev/', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: encryptData({
+                    a: selectedMode,
+                    q: prompt,
+                    i: [],
+                    c: context
+                })
+            });
 
-        const responses = await Promise.all(modelRequests);
-        const responseTexts = responses
-            .filter(r => r && r.text && typeof r.text === 'string')
-            .map(r => r.text);
+            const text = await response.text();
+            const result = decryptData(text);
 
-        if (responseTexts.length === 0) {
+            // The worker now handles orchestration internally
+            // It runs multiple models and synthesizes the response
+            if (result && result.text && typeof result.text === 'string') {
+                return result.text;
+            } else {
+                return 'I apologize, but I was unable to process your request at this time. Please try again.';
+            }
+        } catch (error) {
             return 'I apologize, but I was unable to process your request at this time. Please try again.';
         }
-
-        // Fast mode: return the first model response without aggregation
-        if (Number(mode) === 1) {
-            return responseTexts[0];
-        }
-
-        const finalResponse = await fetch('https://traceai.dukeindustries7.workers.dev/', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: encryptData({
-                a: 'gfinal',
-                q: prompt,
-                r: responseTexts,
-                i: [],
-                c: context
-            })
-        });
-
-        const encryptedResult = await finalResponse.text();
-        const decryptedResult = decryptData(encryptedResult);
-        
-        return decryptedResult.text || 'No response generated';
     } catch (error) {
         console.error(`[${new Date().toISOString()}] ❌ Processing error:`, error.message);
         throw error;