chrxmaticc-copilot 1.0.3

package/src/extensions/spotify.js

@@ -0,0 +1,357 @@
+var chalk = require('chalk');
+// Chrxmaticc Copilot — Spotify Integration v2.0
+// Also, all Spotify Logins and Credentials are private. Please know this.
+// Full account login, playlist control, music analysis
+// Author: Chrxmee-Midnightt
+
+var chat = require('../chat');
+var chalk = require('chalk');
+var https = require('https');
+
+// Spotify API credentials (registered app)
+var SPOTIFY_CLIENT_ID = process.env.SPOTIFY_CLIENT_ID || '';
+var SPOTIFY_CLIENT_SECRET = process.env.SPOTIFY_CLIENT_SECRET || '';
+var SPOTIFY_REDIRECT_URI = process.env.SPOTIFY_REDIRECT_URI || 'http://localhost:3000/spotify/callback';
+
+var userSessions = {};
+
+// ──────────────────────────────────────────────
+//  SECURITY DISCLAIMER
+// ──────────────────────────────────────────────
+
+var SECURITY_DISCLAIMER = [
+  '🔒 SECURITY NOTICE:',
+  '• Chrxmaticc Copilot does NOT store your password.',
+  '• Credentials are sent directly to Spotify via OAuth.',
+  '• Your data is private and never logged.',
+  '• 2FA codes are processed in real-time only.',
+  '• You can use public playlists without logging in.',
+  '• Account login enables: private playlists, liked songs, playback control.',
+  '• Log out anytime with /spotify logout.',
+  '• This is an open-source project. Verify the code yourself.',
+  '• By logging in, you agree to Spotify\'s Terms of Service.'
+].join('\n');
+
+function showDisclaimer() {
+  console.log('');
+  console.log('  ' + chalk.yellow(SECURITY_DISCLAIMER));
+  console.log('');
+}
+
+// ──────────────────────────────────────────────
+//  AUTHENTICATION
+// ──────────────────────────────────────────────
+
+function getAuthURL() {
+  var params = new URLSearchParams({
+    client_id: SPOTIFY_CLIENT_ID,
+    response_type: 'code',
+    redirect_uri: SPOTIFY_REDIRECT_URI,
+    scope: 'user-read-private user-read-email playlist-read-private playlist-modify-private playlist-modify-public user-library-read user-library-modify user-read-playback-state user-modify-playback-state',
+    state: Math.random().toString(36).substring(7)
+  });
+  
+  return 'https://accounts.spotify.com/authorize?' + params.toString();
+}
+
+function exchangeCodeForToken(code, userId) {
+  return new Promise(function(resolve, reject) {
+    var data = new URLSearchParams({
+      grant_type: 'authorization_code',
+      code: code,
+      redirect_uri: SPOTIFY_REDIRECT_URI,
+      client_id: SPOTIFY_CLIENT_ID,
+      client_secret: SPOTIFY_CLIENT_SECRET
+    }).toString();
+
+    var options = {
+      hostname: 'accounts.spotify.com',
+      path: '/api/token',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': data.length
+      }
+    };
+
+    var req = https.request(options, function(res) {
+      var body = '';
+      res.on('data', function(chunk) { body = body + chunk; });
+      res.on('end', function() {
+        try {
+          var json = JSON.parse(body);
+          if (json.access_token) {
+            userSessions[userId] = {
+              accessToken: json.access_token,
+              refreshToken: json.refresh_token,
+              expiresAt: Date.now() + (json.expires_in * 1000),
+              createdAt: Date.now()
+            };
+            resolve({ success: true });
+          } else {
+            resolve({ success: false, error: json.error_description || 'Auth failed' });
+          }
+        } catch (e) {
+          resolve({ success: false, error: e.message });
+        }
+      });
+    });
+
+    req.on('error', function(e) { reject(e); });
+    req.write(data);
+    req.end();
+  });
+}
+
+function refreshToken(userId) {
+  return new Promise(function(resolve) {
+    var session = userSessions[userId];
+    if (!session || !session.refreshToken) {
+      resolve({ success: false, error: 'No session' });
+      return;
+    }
+
+    var data = new URLSearchParams({
+      grant_type: 'refresh_token',
+      refresh_token: session.refreshToken,
+      client_id: SPOTIFY_CLIENT_ID,
+      client_secret: SPOTIFY_CLIENT_SECRET
+    }).toString();
+
+    var options = {
+      hostname: 'accounts.spotify.com',
+      path: '/api/token',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    };
+
+    var req = https.request(options, function(res) {
+      var body = '';
+      res.on('data', function(chunk) { body = body + chunk; });
+      res.on('end', function() {
+        try {
+          var json = JSON.parse(body);
+          if (json.access_token) {
+            userSessions[userId].accessToken = json.access_token;
+            userSessions[userId].expiresAt = Date.now() + (json.expires_in * 1000);
+            resolve({ success: true });
+          } else {
+            resolve({ success: false });
+          }
+        } catch (e) {
+          resolve({ success: false });
+        }
+      });
+    });
+
+    req.on('error', function() { resolve({ success: false }); });
+    req.write(data);
+    req.end();
+  });
+}
+
+function isAuthenticated(userId) {
+  var session = userSessions[userId];
+  if (!session) return false;
+  if (Date.now() > session.expiresAt) {
+    refreshToken(userId);
+    return false;
+  }
+  return true;
+}
+
+// ──────────────────────────────────────────────
+//  MUSIC CONTROLS
+// ──────────────────────────────────────────────
+
+function apiCall(endpoint, method, userId, body) {
+  return new Promise(function(resolve) {
+    var session = userSessions[userId];
+    if (!session) {
+      resolve({ success: false, error: 'Not authenticated' });
+      return;
+    }
+
+    var data = body ? JSON.stringify(body) : null;
+    var options = {
+      hostname: 'api.spotify.com',
+      path: '/v1' + endpoint,
+      method: method || 'GET',
+      headers: {
+        'Authorization': 'Bearer ' + session.accessToken,
+        'Content-Type': 'application/json'
+      }
+    };
+
+    var req = https.request(options, function(res) {
+      var responseBody = '';
+      res.on('data', function(chunk) { responseBody = responseBody + chunk; });
+      res.on('end', function() {
+        try {
+          resolve({ success: true, data: JSON.parse(responseBody) });
+        } catch (e) {
+          resolve({ success: false, error: 'Parse error' });
+        }
+      });
+    });
+
+    req.on('error', function(e) { resolve({ success: false, error: e.message }); });
+    if (data) req.write(data);
+    req.end();
+  });
+}
+
+// ──────────────────────────────────────────────
+//  PUBLIC API (no login needed)
+// ──────────────────────────────────────────────
+
+async function searchTrack(query) {
+  var prompt = 'Search Spotify for "' + query + '". What are the top 3 results? Give song name and artist.';
+  var response = await chat.getResponse(prompt);
+  return typeof response === 'string' ? response : response.text;
+}
+
+async function analyzeTrack(trackName, artist) {
+  var prompt = 'Analyze "' + trackName + '" by ' + artist + '. Genre, mood, what makes it unique.';
+  var response = await chat.getResponse(prompt);
+  return typeof response === 'string' ? response : response.text;
+}
+
+async function suggestSimilar(trackName, artist) {
+  var prompt = 'Suggest 5 songs similar to "' + trackName + '" by ' + artist + '.';
+  var response = await chat.getResponse(prompt);
+  return typeof response === 'string' ? response : response.text;
+}
+
+async function createPlaylistPrompt(mood, genre) {
+  var prompt = 'Create a 10-song playlist for a ' + mood + ' mood';
+  if (genre) prompt = prompt + ' in ' + genre;
+  prompt = prompt + '. Give song names and artists.';
+  var response = await chat.getResponse(prompt);
+  return typeof response === 'string' ? response : response.text;
+}
+
+// ──────────────────────────────────────────────
+//  PRIVATE API (login required)
+// ──────────────────────────────────────────────
+
+async function getMyPlaylists(userId) {
+  if (!isAuthenticated(userId)) return { success: false, error: 'Not logged in. Use /spotify login' };
+  return apiCall('/me/playlists', 'GET', userId);
+}
+
+async function getMyLikedSongs(userId) {
+  if (!isAuthenticated(userId)) return { success: false, error: 'Not logged in' };
+  return apiCall('/me/tracks?limit=20', 'GET', userId);
+}
+
+async function createPlaylist(userId, name, description) {
+  if (!isAuthenticated(userId)) return { success: false, error: 'Not logged in' };
+  
+  var userResult = await apiCall('/me', 'GET', userId);
+  if (!userResult.success) return userResult;
+  
+  return apiCall('/users/' + userResult.data.id + '/playlists', 'POST', userId, {
+    name: name,
+    description: description || 'Created by Chrxmaticc Copilot',
+    public: false
+  });
+}
+
+async function getCurrentPlaying(userId) {
+  if (!isAuthenticated(userId)) return { success: false, error: 'Not logged in' };
+  return apiCall('/me/player/currently-playing', 'GET', userId);
+}
+
+function logout(userId) {
+  delete userSessions[userId];
+  return { success: true, message: 'Logged out. Your data was never stored.' };
+}
+
+// ──────────────────────────────────────────────
+//  COMMAND HANDLER
+// ──────────────────────────────────────────────
+
+async function handleCommand(command, userId) {
+  var parts = command.split(' ');
+  var action = parts[1] || '';
+  var args = parts.slice(2).join(' ');
+
+  switch (action) {
+    case 'login':
+      showDisclaimer();
+      return {
+        text: '🔗 Open this URL to log in:\n' + getAuthURL() + '\n\nAfter logging in, copy the URL you were redirected to and run:\n/spotify callback <full-url>',
+        requiresCallback: true
+      };
+
+    case 'callback':
+      var url = args;
+      var codeMatch = url.match(/code=([^&]+)/);
+      if (codeMatch) {
+        var result = await exchangeCodeForToken(codeMatch[1], userId);
+        if (result.success) {
+          return { text: '✅ Logged in to Spotify! Your data is private.' };
+        }
+        return { text: '❌ Login failed: ' + (result.error || 'Unknown error') };
+      }
+      return { text: '❌ Could not find authorization code in URL.' };
+
+    case 'logout':
+      logout(userId);
+      return { text: '👋 Logged out. Your data was never stored.' };
+
+    case 'playing':
+      if (!isAuthenticated(userId)) return { text: '❌ Not logged in. Use /spotify login' };
+      var playing = await getCurrentPlaying(userId);
+      if (playing.success && playing.data && playing.data.item) {
+        var track = playing.data.item;
+        return { text: '🎵 Now playing: ' + track.name + ' by ' + track.artists.map(function(a) { return a.name; }).join(', ') };
+      }
+      return { text: '🎵 Nothing playing right now.' };
+
+    case 'playlists':
+      if (!isAuthenticated(userId)) return { text: '❌ Not logged in. Use /spotify login' };
+      var lists = await getMyPlaylists(userId);
+      if (lists.success && lists.data && lists.data.items) {
+        var listText = '📋 Your playlists:\n';
+        lists.data.items.slice(0, 10).forEach(function(p, i) {
+          listText = listText + '  ' + (i + 1) + '. ' + p.name + ' (' + p.tracks.total + ' tracks)\n';
+        });
+        return { text: listText };
+      }
+      return { text: '❌ Could not fetch playlists.' };
+
+    case 'create':
+      if (!isAuthenticated(userId)) return { text: '❌ Not logged in' };
+      var name = args || 'Chrxmaticc Playlist';
+      var created = await createPlaylist(userId, name, 'Created by Chrxmaticc Copilot');
+      if (created.success) {
+        return { text: '✅ Playlist "' + name + '" created!' };
+      }
+      return { text: '❌ Could not create playlist.' };
+
+    case 'search':
+      return { text: await searchTrack(args) };
+
+    case 'analyze':
+      return { text: await analyzeTrack(args, '') };
+
+    case 'similar':
+      return { text: await suggestSimilar(args, '') };
+
+    case 'playlist':
+      var moodArgs = args.split(' in ');
+      return { text: await createPlaylistPrompt(moodArgs[0], moodArgs[1] || '') };
+
+    default:
+      return { text: '🎵 Spotify commands:\n/spotify login — Log in with Spotify\n/spotify logout — Log out\n/spotify playing — Now playing\n/spotify playlists — Your playlists\n/spotify create <name> — Create playlist\n/spotify search <query> — Search music\n/spotify analyze <song> — Analyze a song\n/spotify similar <song> — Get similar songs\n/spotify playlist <mood> — Generate playlist\n\n🔒 Your data is never stored.' };
+  }
+}
+
+module.exports = {
+  handleCommand: handleCommand,
+  isAuthenticated: isAuthenticated,
+  getAuthURL: getAuthURL,
+  showDisclaimer: showDisclaimer
+};

package/src/extensions/terminal-hook.js

@@ -0,0 +1,56 @@
+var chalk = require('chalk');
+// Chrxmaticc Copilot — Terminal Hook
+// Auto-completes commands in your terminal
+// Author: Chrxmee-Midnightt
+
+var chat = require('../chat');
+var chalk = require('chalk');
+
+var commandHistory = [];
+var maxHistory = 50;
+
+function suggestCommand(partial) {
+  var prompt = 'Complete this terminal command. Give ONLY the command, no explanation:\n' + partial;
+  
+  return chat.getResponse(prompt).then(function(response) {
+    var text = typeof response === 'string' ? response : response.text;
+    return text.trim().split('\n')[0].replace(/`/g, '').trim();
+  });
+}
+
+function explainCommand(command) {
+  return chat.getResponse('Explain this terminal command in one sentence:\n' + command)
+    .then(function(response) {
+      return typeof response === 'string' ? response : response.text;
+    });
+}
+
+function getDangerousCommands() {
+  return [
+    'rm -rf /', 'sudo rm', ':(){ :|:& };:', 'mkfs',
+    'dd if=', '> /dev/sda', 'chmod 777 /',
+    'wget -O - | sh', 'curl | bash'
+  ];
+}
+
+function isDangerous(command) {
+  var dangerous = getDangerousCommands();
+  for (var i = 0; i < dangerous.length; i++) {
+    if (command.indexOf(dangerous[i]) !== -1) return true;
+  }
+  return false;
+}
+
+function hookShell() {
+  console.log('');
+  console.log('  ' + chalk.magenta('💻 Terminal Hook active'));
+  console.log('  ' + chalk.gray('Type "??" after any partial command for suggestions'));
+  console.log('');
+}
+
+module.exports = {
+  suggestCommand: suggestCommand,
+  explainCommand: explainCommand,
+  isDangerous: isDangerous,
+  hookShell: hookShell
+};

package/src/memory.js

@@ -0,0 +1,57 @@
+// Chrxmaticc Copilot — Persistent Memory Engine
+// Zero dependencies. JSON-backed. Auto-creates on first run.
+// Author: Chrxmee-Midnightt
+
+var fs = require('fs');
+var path = require('path');
+
+var MEMORY_DIR = path.join(process.env.HOME || '/tmp', '.chrxmaticc');
+var CONVERSATIONS_FILE = path.join(MEMORY_DIR, 'conversations.json');
+var FACTS_FILE = path.join(MEMORY_DIR, 'facts.json');
+
+var conversations = {};
+var facts = {};
+
+function init() {
+  if (!fs.existsSync(MEMORY_DIR)) {
+    fs.mkdirSync(MEMORY_DIR, { recursive: true });
+  }
+  if (fs.existsSync(CONVERSATIONS_FILE)) {
+    try { conversations = JSON.parse(fs.readFileSync(CONVERSATIONS_FILE, 'utf8')); } catch (e) {}
+  }
+  if (fs.existsSync(FACTS_FILE)) {
+    try { facts = JSON.parse(fs.readFileSync(FACTS_FILE, 'utf8')); } catch (e) {}
+  }
+}
+
+function save() {
+  fs.writeFileSync(CONVERSATIONS_FILE, JSON.stringify(conversations, null, 2));
+  fs.writeFileSync(FACTS_FILE, JSON.stringify(facts, null, 2));
+}
+
+function storeMessage(userId, role, content, provider) {
+  if (!conversations[userId]) conversations[userId] = [];
+  conversations[userId].push({ role: role, content: content, provider: provider || 'unknown', timestamp: Date.now() });
+  if (conversations[userId].length > 500) conversations[userId] = conversations[userId].slice(-500);
+  save();
+}
+
+function storeConversation(userId, history) {
+  conversations[userId] = history.map(function(msg) { return { role: msg.role, content: msg.content, timestamp: Date.now() }; });
+  save();
+}
+
+function recall(userId, query) {
+  if (!conversations[userId]) return null;
+  var lower = query.toLowerCase();
+  for (var i = conversations[userId].length - 1; i >= 0; i--) {
+    if (conversations[userId][i].content.toLowerCase().indexOf(lower) !== -1) return conversations[userId][i].content;
+  }
+  return null;
+}
+
+function getStats(userId) {
+  return { conversations: conversations[userId] ? conversations[userId].length : 0, facts: facts[userId] ? Object.keys(facts[userId]).length : 0 };
+}
+
+module.exports = { init: init, storeMessage: storeMessage, storeConversation: storeConversation, recall: recall, getStats: getStats };

package/src/multi-user-chat.js

@@ -0,0 +1,139 @@
+var chalk = require('chalk');
+// Chrxmaticc Copilot — Multi-User Chat Engine
+// Isolated memory per user. Shared AI providers.
+// Author: Chrxmee-Midnightt
+
+var PERSONALITY = require('./personality');
+var pollinations = require('./apis/pollinations');
+var groq = require('./apis/groq');
+
+var userMemories = {};
+var groqRateLimited = false;
+var rateLimitResetTime = 0;
+
+function getUserMemory(userId) {
+  if (!userMemories[userId]) {
+    userMemories[userId] = {
+      history: [],
+      createdAt: Date.now(),
+      messageCount: 0
+    };
+  }
+  return userMemories[userId];
+}
+
+function pickRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function getOfflineResponse(input) {
+  var lower = input.toLowerCase();
+  var topics = PERSONALITY.topics;
+  var responses = PERSONALITY.offline;
+  
+  for (var category in topics) {
+    for (var i = 0; i < topics[category].length; i++) {
+      if (lower.indexOf(topics[category][i]) !== -1) {
+        if (responses[category]) return pickRandom(responses[category]);
+      }
+    }
+  }
+  
+  if (lower.indexOf('hello') !== -1 || lower.indexOf('hey') !== -1 || lower.indexOf('hi') !== -1) {
+    return pickRandom(responses.greeting);
+  }
+  if (lower.indexOf('help') !== -1) {
+    return 'multi-user mode. each user has their own memory. commands: /memory, /clear. powered by Pollinations + Groq.';
+  }
+  if (lower.indexOf('/memory') === 0) {
+    return null;
+  }
+  if (lower.indexOf('/clear') === 0) {
+    return null;
+  }
+  if (lower.indexOf('who are you') !== -1) {
+    return pickRandom(responses.whoami);
+  }
+  
+  return pickRandom(responses.fallback);
+}
+
+async function askAI(userInput, userId) {
+  var memory = getUserMemory(userId);
+  
+  if (groqRateLimited && Date.now() > rateLimitResetTime) {
+    groqRateLimited = false;
+  }
+  
+  var result = await pollinations.ask(userInput, memory.history, PERSONALITY.systemPrompt);
+  
+  if (result.success) {
+    return result;
+  }
+  
+  if (!groqRateLimited) {
+    result = await groq.ask(userInput, memory.history, PERSONALITY.systemPrompt);
+    
+    if (result.success) {
+      return result;
+    }
+    
+    if (result.error === 'rate_limited') {
+      groqRateLimited = true;
+      rateLimitResetTime = Date.now() + 60000;
+    }
+  }
+  
+  result = await pollinations.ask(userInput, memory.history, PERSONALITY.systemPrompt);
+  if (result.success) {
+    return result;
+  }
+  
+  return { success: false, error: 'all providers down', provider: 'offline' };
+}
+
+async function getResponse(input, userId) {
+  userId = userId || 'anonymous';
+  
+  var lower = input.toLowerCase();
+  
+  if (lower.indexOf('/memory') === 0) {
+    var mem = getUserMemory(userId);
+    return {
+      text: '🧠 Your memory: ' + mem.history.length + ' messages. Created ' + new Date(mem.createdAt).toLocaleString() + '.',
+      provider: 'system'
+    };
+  }
+  
+  if (lower.indexOf('/clear') === 0) {
+    userMemories[userId] = { history: [], createdAt: Date.now(), messageCount: 0 };
+    return { text: '🧹 Your memory has been cleared.', provider: 'system' };
+  }
+  
+  var aiResult = await askAI(input, userId);
+  var memory = getUserMemory(userId);
+  
+  if (aiResult.success) {
+    memory.history.push({ role: 'user', content: input });
+    memory.history.push({ role: 'assistant', content: aiResult.text });
+    memory.messageCount = memory.messageCount + 1;
+    
+    if (memory.history.length > PERSONALITY.maxHistory) {
+      memory.history = memory.history.slice(-PERSONALITY.maxHistory);
+    }
+    
+    return { text: aiResult.text, provider: aiResult.provider };
+  }
+  
+  var offlineText = getOfflineResponse(input);
+  if (offlineText) {
+    memory.history.push({ role: 'user', content: input });
+    memory.history.push({ role: 'assistant', content: offlineText });
+    memory.messageCount = memory.messageCount + 1;
+    return { text: offlineText, provider: 'offline' };
+  }
+  
+  return { text: pickRandom(PERSONALITY.offline.fallback), provider: 'offline' };
+}
+
+module.exports = { getResponse: getResponse, getUserMemory: getUserMemory };