autoai 1.0.0

package/index.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const args = process.argv.slice(2);
+const input = args[0];
+
+const memoryDir = path.join(os.homedir(), '.ai_cli');
+const memoryFile = path.join(memoryDir, 'memory.json');
+
+function getAdvancedSystemInfo() {
+  let info = `[CURRENT DIRECTORY]: ${process.cwd()}\n`;
+  try {
+    const kernel = execSync('uname -sr', { encoding: 'utf8', stdio: 'pipe' }).trim();
+    let distro = "Linux Generic";
+    try {
+      distro = execSync('grep PRETTY_NAME /etc/os-release | cut -d= -f2', { encoding: 'utf8', stdio: 'pipe' }).replace(/"/g, '').trim();
+    } catch (e) {}
+    info += `[SYSTEM]: ${distro} | Kernel: ${kernel}\n`;
+  } catch (e) {
+    info += `[SYSTEM]: ${os.type()} ${os.release()}\n`;
+  }
+  try {
+    const freeMem = execSync('free -h | grep Mem | awk \'{print "Total: "$2 " | Used: "$3 " | Free: "$4}\'', { encoding: 'utf8', stdio: 'pipe' }).trim();
+    info += `[RAM]: ${freeMem}\n`;
+  } catch (e) {
+    const total = (os.totalmem() / 1024 / 1024 / 1024).toFixed(2);
+    const free = (os.freemem() / 1024 / 1024 / 1024).toFixed(2);
+    info += `[RAM]: Total ${total}GB | Free ${free}GB\n`;
+  }
+  try {
+    const files = fs.readdirSync(process.cwd());
+    const fileList = files.slice(0, 20).map(f => {
+      try { return fs.statSync(f).isDirectory() ? `${f}/` : f; } catch { return f; }
+    }).join(', ');
+    info += `[FILES (Top 20)]: ${fileList}${files.length > 20 ? ' ...' : ''}\n`;
+  } catch (e) { info += `[FILES]: Error reading directory\n`; }
+  try {
+    const ps = execSync('ps -eo comm,%mem,%cpu --sort=-%mem | head -n 6', { encoding: 'utf8', stdio: 'pipe' }).trim();
+    info += `[TOP PROCESSES (Mem/CPU)]:\n${ps}`;
+  } catch (e) { info += `[PROCESSES]: Cannot read process list`; }
+  return info;
+}
+
+function loadMemory() {
+  try {
+    if (!fs.existsSync(memoryDir)) fs.mkdirSync(memoryDir, { recursive: true });
+    if (fs.existsSync(memoryFile)) return JSON.parse(fs.readFileSync(memoryFile, 'utf8'));
+  } catch (e) {}
+  return { conversations: [] };
+}
+
+function saveMemory(memory) {
+  try { fs.writeFileSync(memoryFile, JSON.stringify(memory, null, 2)); } catch (e) {}
+}
+
+function resetMemory() {
+  if (fs.existsSync(memoryFile)) {
+    fs.unlinkSync(memoryFile);
+    console.log("\x1b[32mMemory berhasil direset\x1b[0m");
+  } else { console.log("\x1b[33mTidak ada memory\x1b[0m"); }
+}
+
+function showMemoryLog() {
+  const memory = loadMemory();
+  if (memory.conversations.length === 0) return console.log("\x1b[33mKosong.\x1b[0m");
+  console.log("\x1b[36m=== LOG ===\x1b[0m");
+  memory.conversations.forEach((c, i) => {
+    console.log(`\x1b[33m[${i+1}]\x1b[0m Q: ${c.prompt} | A: ${c.response.substring(0, 50)}...`);
+  });
+}
+
+function detectIntent(text) {
+  text = text.toLowerCase();
+  if (text.includes('how to') || text.includes('install') || text.includes('setup')) return 'tutorial';
+  if (text.includes('error') || text.includes('fix') || text.includes('problem')) return 'troubleshoot';
+  if (text.includes('command') || text.includes('terminal') || text.includes('bash')) return 'command';
+  if (text.includes('what is') || text.includes('explain')) return 'explanation';
+  if (text.includes('best') || text.includes('recommend')) return 'recommendation';
+  if (text.includes('compare') || text.includes('vs')) return 'comparison';
+  return 'general';
+}
+
+function extractTags(prompt, response) {
+  const tags = [];
+  const text = (prompt + ' ' + response).toLowerCase();
+  if (text.includes('ubuntu') || text.includes('debian') || text.includes('linux')) tags.push('linux');
+  if (text.includes('docker') || text.includes('container')) tags.push('docker');
+  if (text.includes('node') || text.includes('npm') || text.includes('javascript')) tags.push('nodejs');
+  if (text.includes('python') || text.includes('pip')) tags.push('python');
+  if (text.includes('git') || text.includes('github')) tags.push('git');
+  if (text.includes('database') || text.includes('mysql') || text.includes('postgres')) tags.push('database');
+  if (text.includes('network') || text.includes('port') || text.includes('ip')) tags.push('network');
+  if (text.includes('security') || text.includes('firewall') || text.includes('ssl')) tags.push('security');
+  return tags;
+}
+
+function generateFollowUpSuggestions(prompt, response) {
+  const suggestions = [];
+  const lowerPrompt = prompt.toLowerCase();
+  const lowerResponse = response.toLowerCase();
+  if (lowerPrompt.includes('install') && !lowerResponse.includes('uninstall')) suggestions.push('Need to uninstall? Ask: "How to uninstall [package]"');
+  if (lowerPrompt.includes('file') || lowerResponse.includes('directory')) suggestions.push('Want to manage permissions? Try: "chmod commands for files"');
+  if (lowerResponse.includes('sudo') || lowerResponse.includes('root')) suggestions.push('Safety tip: Always review commands before sudo');
+  if (lowerResponse.includes('service') || lowerResponse.includes('systemctl')) suggestions.push('Related: "How to monitor running services"');
+  return suggestions.length > 0 ? suggestions[Math.floor(Math.random() * suggestions.length)] : null;
+}
+
+switch (input) {
+case "help":
+case "--help":
+  console.log("\x1b[36m" + `
+╔════════════════════════════════════════════╗
+║           🤖 AI CLI ASSISTANT              ║
+╚════════════════════════════════════════════╝
+
+\x1b[33m📦 USAGE:\x1b[0m
+  ai <text>              - Chat with AI assistant
+  ai log                 - Show conversation history
+  ai reset               - Reset memory data
+  ai service <message>   - Send report to developer
+
+\x1b[32m✨ FEATURES:\x1b[0m
+  • Intelligent memory system
+  • Real-time system awareness
+  • No markdown responses
+  • Predictive suggestions
+  • Error reporting system
+
+\x1b[36m👤 ABOUT OWNER:\x1b[0m
+  • Created by: \x1b[33mJunn\e[0m
+  • Focus: CLI tools & automation
+  • Passion: Building smart assistants
+
+\x1b[35m🌐 CONNECT:\x1b[0m
+  • Telegram: \x1b[36m@JunOfficial354ch2\e[0m (Official Channel)
+  • GitHub: \x1b[36mgithub.com/JunHosting
+  • Website: \x1b[36junofficial354.blogspot.com
+  • WhatsApp: \x1b[36m+6281556460844
+
+\x1b[32m💡 TIPS:\x1b[0m
+  • Use descriptive prompts for better answers
+  • Check 'ai log' for conversation history
+  • Report bugs with 'ai service <issue>'
+
+\x1b[33m🚀 Version: 1.0.0 |  My Tools\e[0m
+` + "\x1b[0m");
+  break;
+  case "log":
+    showMemoryLog();
+    break;
+
+  case "reset":
+    resetMemory();
+    break;
+  case "service":
+    if (args.length < 2) {
+        console.log("\x1b[31mUsage: ai service <your_message>\x1b[0m");
+        console.log("Example: ai service ada bug di fitur login");
+        process.exit(1);
+    }
+    
+    const message = args.slice(1).join(" ");
+    const botToken = "8296721565:AAH88lnLmWmoruDieWxszys0B-ffuVvO2bE"; 
+    const chatId = "-1003058450217"; 
+    
+    
+    const sysInfo = getAdvancedSystemInfo().split('\n')[0]; 
+    const fullMessage = `🚨 USER REPORT:\n${message}\n\n📱 FROM SYSTEM: ${sysInfo}\n⏰ TIME: ${new Date().toLocaleString()}`;
+    
+   
+    const encodedMessage = encodeURIComponent(fullMessage);
+    const telegramUrl = `https://api.telegram.org/bot${botToken}/sendMessage?chat_id=${chatId}&text=${encodedMessage}`;
+    
+    console.log("\x1b[33m📤 Sending report to developer...\x1b[0m");
+    
+    https.get(telegramUrl, (res) => {
+        let data = '';
+        res.on('data', (chunk) => data += chunk);
+        res.on('end', () => {
+            try {
+                const response = JSON.parse(data);
+                if (response.ok) {
+                    console.log("\x1b[32m✅ Report sent successfully!\x1b[0m");
+                    console.log("\x1b[36mMessage ID:", response.result.message_id, "\x1b[0m");
+                } else {
+                    console.log("\x1b[31m❌ Failed to send:", response.description, "\x1b[0m");
+                }
+            } catch (e) {
+                console.log("\x1b[31m❌ Error parsing response\x1b[0m");
+            }
+        });
+    }).on('error', (err) => {
+        console.log("\x1b[31m❌ Connection error:", err.message, "\x1b[0m");
+    });
+    break;
+
+  default:
+    const prompt = args.join(" ");
+    if (!prompt) {
+      console.log("\x1b[31mUsage: ai <text>\x1b[0m");
+      process.exit(1);
+    }
+    const memory = loadMemory();
+    
+    
+    let contextAnalysis = "";
+    if (memory.conversations.length > 0) {
+      const currentTopic = prompt.toLowerCase();
+      const isCommandTopic = /(ls|cd|grep|find|apt|install|config|sudo)/.test(currentTopic);
+      const isCodeTopic = /(function|loop|array|variable|script|bash)/.test(currentTopic);
+      const isSystemTopic = /(memory|cpu|disk|process|service|daemon)/.test(currentTopic);
+      let weightedHistory = "";
+      memory.conversations.forEach((conv, idx) => {
+        const ageWeight = (idx + 1) / memory.conversations.length;
+        const convText = conv.response.toLowerCase();
+        let relevanceScore = 0.5 * ageWeight;
+        if (isCommandTopic && convText.includes('command')) relevanceScore += 0.3;
+        if (isCodeTopic && (convText.includes('code') || convText.includes('script'))) relevanceScore += 0.3;
+        if (isSystemTopic && convText.includes('system')) relevanceScore += 0.3;
+        const promptWords = new Set(prompt.toLowerCase().split(/\W+/));
+        const convWords = new Set(conv.prompt.toLowerCase().split(/\W+/));
+        const overlap = [...promptWords].filter(w => convWords.has(w)).length;
+        relevanceScore += overlap * 0.1;
+        if (relevanceScore > 0.7) weightedHistory += `[MEMORY-RELEVANT:${relevanceScore.toFixed(2)}]\nQ: ${conv.prompt}\nA: ${conv.response}\n\n`;
+      });
+      if (weightedHistory) contextAnalysis = `\n\n=== RELEVANT MEMORY CONTEXT ===\n${weightedHistory}==============================`;
+    }
+
+    let predictiveContext = "";
+    try {
+      const files = fs.readdirSync(process.cwd());
+      const fileList = files.map(f => {
+        try {
+          const stat = fs.statSync(path.join(process.cwd(), f));
+          return stat.isDirectory() ? `📁 ${f}/` : `📄 ${f}`;
+        } catch { return `❓ ${f}`; }
+      }).join('  ');
+      predictiveContext = `\n\n[REAL-TIME DIRECTORY SCAN]:\n${fileList}\n[ITEMS: ${files.length}]`;
+      if (memory.conversations.length > 0) {
+        const lastCommands = memory.conversations
+          .filter(c => c.prompt.includes('how') || c.prompt.includes('command') || c.response.includes('sudo'))
+          .slice(-3)
+          .map(c => `  • ${c.prompt.substring(0, 50)}...`)
+          .join('\n');
+        if (lastCommands) predictiveContext += `\n\n[RECENT COMMAND PATTERNS]:\n${lastCommands}`;
+      }
+    } catch (e) {}
+
+    const systemPrompt = `🔥 [INTELLIGENT CLI ASSISTANT - NEURAL MODE ACTIVATED] 🔥
+
+📊 SYSTEM INTELLIGENCE REPORT:
+${sysInfo}
+${predictiveContext}
+${contextAnalysis}
+
+🧠 CONTEXT AWARENESS LEVEL: ${memory.conversations.length > 10 ? "HIGH (Patterns Detected)" : "MEDIUM"}
+
+⚡ SMART RESPONSE PROTOCOLS:
+1. 🔴 ABSOLUTELY NO MARKDOWN - Pure plain text only
+2. 🎯 Answer with precision - Technical depth based on context
+3. 📁 If suggesting commands, provide EXACT syntax for ${sysInfo.includes('Ubuntu') ? 'Ubuntu' : 'Linux'}
+4. 💡 Include pro-tips when relevant to memory patterns
+5. 🚀 Optimize for speed - Pre-cached solutions from similar queries
+6. ⚠️ Highlight DANGER ZONES for sudo/rm commands
+7. 📊 Provide metrics when applicable (time/complexity/memory)
+8. 🎨 Use simple ASCII indicators: → for steps, ⚡ for tips, ⚠️ for warnings
+9. 🔄 Reference past solutions when better optimized
+10. 🎯 End with actionable next-step suggestions
+
+🧩 USER'S QUERY ANALYSIS:
+• Intent: ${detectIntent(prompt)}
+• Complexity: ${prompt.split(' ').length > 10 ? 'High' : 'Medium'}
+• Memory Relevance: ${contextAnalysis ? 'Connected to past solutions' : 'New topic'}
+
+🎯 QUERY: ${prompt}
+
+📌 RESPONSE MUST BE:
+• Direct execution-ready for terminal
+• Zero markdown symbols
+• Context-aware optimization
+• Pattern-optimized from memory
+• Safety-validated for current system`;
+
+    const startTime = Date.now();
+    const url = "https://junn-endpoint-api.vercel.app/api/ai?apikey=jun-v1key&text=" + encodeURIComponent(systemPrompt);
+
+    https.get(url, (res) => {
+      let data = '';
+      res.on('data', (c) => data += c);
+      res.on('end', () => {
+        const responseTime = Date.now() - startTime;
+        try {
+          const json = JSON.parse(data);
+          let reply = json.result || json.response || data;
+          if (!reply.includes('⚡') && responseTime < 2000) reply += `\n\n⚡ Response generated in ${responseTime}ms`;
+          if (memory.conversations.length > 0) {
+            const lastTopic = memory.conversations[memory.conversations.length - 1].prompt;
+            if (prompt.toLowerCase().includes(lastTopic.split(' ')[0])) reply += `\n\n💡 Related to your previous query about "${lastTopic.substring(0, 30)}..."`;
+          }
+          reply = reply.replace(/[`*_#\[\]()><~|]/g, '');
+          reply = reply.replace(/\*\*(.*?)\*\*/g, '$1');
+          reply = reply.replace(/`(.*?)`/g, '$1');
+          console.log("\n\x1b[32m%s\x1b[0m", reply);
+          const memoryEntry = {
+            timestamp: Date.now(),
+            prompt: prompt,
+            response: reply,
+            systemInfo: sysInfo.split('\n')[0],
+            responseTime: responseTime,
+            intent: detectIntent(prompt),
+            contextScore: contextAnalysis ? 0.8 : 0.2,
+            tags: extractTags(prompt, reply)
+          };
+          memory.conversations.push(memoryEntry);
+          if (memory.conversations.length > 30) {
+            memory.conversations.sort((a, b) => (b.contextScore || 0) - (a.contextScore || 0));
+            memory.conversations = memory.conversations.slice(0, 25);
+          }
+          saveMemory(memory);
+          if (responseTime < 1500 && reply.length > 100) {
+            setTimeout(() => {
+              const suggestions = generateFollowUpSuggestions(prompt, reply);
+              if (suggestions) console.log("\n\x1b[36m💡 Predictive Assistant: %s\x1b[0m", suggestions);
+            }, 500);
+          }
+        } catch (e) { console.log("\x1b[32m%s\x1b[0m", data); }
+      });
+    }).on("error", (err) => {
+      console.log("\x1b[31m🚨 Connection Error - Using cached intelligence...\x1b[0m");
+      const cached = memory.conversations
+        .filter(c => c.prompt.toLowerCase().includes(prompt.split(' ')[0]))
+        .slice(-1);
+      if (cached.length > 0) console.log("\x1b[33m📦 Cached Solution:\n%s\x1b[0m", cached[0].response);
+      else console.log("\x1b[31mUnable to connect to AI. Please check your connection.\x1b[0m");
+    });
+    break;
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "autoai",
+  "version": "1.0.0",
+  "description": "Simple Auto AI CLI",
+  "bin": {
+    "ai": "index.js"
+  },
+  "author": "YourName",
+  "license": "MIT",
+  "dependencies": {
+    "https": "^1.0.0"
+  }
+}