spiralcord-full 2.2.7 → 2.3.0

package/bin/spiral.js

@@ -154,18 +154,364 @@ async function startBot(config) {
 program
   .command('run')
   .description('Start the bot runtime')
-  .action(async () => {
+  .option('-R, --realtime', 'Start with auto-reload and REPL console')
+  .action(async (options) => {
     try {
       const config = await loadConfig();
       if (!config) return;
-      const runtime = await startBot(config);
-      console.log('Bot is running! Press Ctrl+C to stop.');
 
-      process.on('SIGINT', async () => {
-        console.log('\nShutting down...');
-        await runtime.stop();
-        process.exit(0);
-      });
+      if (options.realtime) {
+        const chokidar = (() => {
+          try {
+            const resolved = require.resolve('chokidar', { paths: [process.cwd()] });
+            return require(resolved);
+          } catch { return null; }
+        })();
+        if (!chokidar) {
+          console.error('Error: "spiral run -R" requires chokidar. Run: npm install chokidar');
+          process.exit(1);
+        }
+
+        let runtime = null;
+        let restarting = false;
+        let pendingRestart = false;
+        let r = null;
+
+        async function start() {
+          const cfg = await loadConfig();
+          if (!cfg) return;
+          runtime = await startBot(cfg);
+          console.log('[runtime] Ready. Press Ctrl+C to stop.');
+          startRepl();
+        }
+
+        function startRepl() {
+          if (r) r.close();
+          const repl = require('repl');
+          r = repl.start({
+            prompt: 'spiral> ',
+            useGlobal: false,
+            terminal: true
+          });
+
+          r.context.runtime = runtime;
+          r.context.client = runtime.client;
+          r.context.db = runtime.db;
+          r.context.manager = runtime.pluginManager;
+          r.context.config = runtime.config;
+
+          const spmCmds = (() => {
+            try {
+              return require('../spm/lib/commands');
+            } catch { return null; }
+          })();
+
+          const pluginCmds = runtime.pluginManager.getReplCommands();
+          const cmdCount = Object.keys(pluginCmds).length;
+          if (cmdCount > 0) {
+            console.log(`[repl] ${cmdCount} plugin command(s) registered: ${Object.keys(pluginCmds).map(c => `.${c}`).join(', ')}`);
+          }
+
+          r.defineCommand('status', {
+            help: 'Show uptime, servers, users',
+            action: function () {
+              this.clearBufferedCommand();
+              const uptime = process.uptime();
+              const h = Math.floor(uptime / 3600);
+              const m = Math.floor((uptime % 3600) / 60);
+              const s = Math.floor(uptime % 60);
+              const servers = runtime.client.guilds.cache.size;
+              const users = runtime.client.guilds.cache.reduce((acc, g) => acc + g.memberCount, 0);
+              console.log(`Uptime: ${h}h ${m}m ${s}s | Servers: ${servers} | Users: ${users}`);
+              this.displayPrompt();
+            }
+          });
+
+          r.defineCommand('reload', {
+            help: 'Hot-reload all plugins',
+            action: function () {
+              this.clearBufferedCommand();
+              (async () => {
+                try {
+                  await runtime.stop();
+                  clearSpiralCache();
+                  await start();
+                  console.log('Plugins reloaded.');
+                } catch (err) {
+                  console.error('Reload failed:', err.message);
+                }
+                r.displayPrompt();
+              })();
+            }
+          });
+
+          r.defineCommand('stop', {
+            help: 'Stop the bot',
+            action: function () {
+              this.clearBufferedCommand();
+              (async () => {
+                console.log('Shutting down...');
+                if (runtime) await runtime.stop();
+                process.exit(0);
+              })();
+            }
+          });
+
+          r.defineCommand('commands', {
+            help: 'List all registered commands',
+            action: function () {
+              this.clearBufferedCommand();
+              const cmds = runtime.pluginManager.getAllCommands();
+              if (cmds.size === 0) {
+                console.log('No commands registered.');
+              } else {
+                for (const [name, cmd] of cmds) {
+                  console.log(`  ${cmd.slash ? '/' : '.'}${name} — ${cmd.description || ''}`);
+                }
+              }
+              r.displayPrompt();
+            }
+          });
+
+          r.defineCommand('plugins', {
+            help: 'List installed plugins',
+            action: function () {
+              this.clearBufferedCommand();
+              (async () => {
+                const result = await spmCmds.listPlugins();
+                if (result.message) process.stdout.write(result.message);
+                r.displayPrompt();
+              })();
+            }
+          });
+
+          r.defineCommand('install', {
+            help: 'Install a plugin from GitHub: spm.install <user/repo>',
+            action: function (source) {
+              this.clearBufferedCommand();
+              (async () => {
+                if (!source.trim()) {
+                  console.log('Usage: spm.install <user/repo>');
+                } else {
+                  const result = await spmCmds.installPlugin(source.trim());
+                  if (result.message) process.stdout.write(result.message);
+                }
+                r.displayPrompt();
+              })();
+            }
+          });
+
+          r.defineCommand('create', {
+            help: 'Create a new plugin: spm.create <name> [js|dsl|voice|ai]',
+            action: function (input) {
+              this.clearBufferedCommand();
+              (async () => {
+                const parts = input.trim().split(/\s+/);
+                const name = parts[0];
+                const template = parts[1] || 'js';
+                if (!name) {
+                  console.log('Usage: spm.create <name> [js|dsl|voice|ai]');
+                } else {
+                  const result = await spmCmds.createPlugin(name, template);
+                  if (result.message) process.stdout.write(result.message);
+                }
+                r.displayPrompt();
+              })();
+            }
+          });
+
+          r.defineCommand('enable', {
+            help: 'Enable a plugin: spm.enable <name>',
+            action: function (name) {
+              this.clearBufferedCommand();
+              (async () => {
+                if (!name.trim()) {
+                  console.log('Usage: spm.enable <name>');
+                } else {
+                  const result = await spmCmds.enablePlugin(name.trim());
+                  if (result.message) process.stdout.write(result.message);
+                }
+                r.displayPrompt();
+              })();
+            }
+          });
+
+          r.defineCommand('disable', {
+            help: 'Disable a plugin: spm.disable <name>',
+            action: function (name) {
+              this.clearBufferedCommand();
+              (async () => {
+                if (!name.trim()) {
+                  console.log('Usage: spm.disable <name>');
+                } else {
+                  const result = await spmCmds.disablePlugin(name.trim());
+                  if (result.message) process.stdout.write(result.message);
+                }
+                r.displayPrompt();
+              })();
+            }
+          });
+
+          r.defineCommand('remove', {
+            help: 'Remove a plugin: spm.remove <name>',
+            action: function (name) {
+              this.clearBufferedCommand();
+              (async () => {
+                if (!name.trim()) {
+                  console.log('Usage: spm.remove <name>');
+                } else {
+                  const result = await spmCmds.removePlugin(name.trim());
+                  if (result.message) process.stdout.write(result.message);
+                }
+                r.displayPrompt();
+              })();
+            }
+          });
+
+          r.defineCommand('test', {
+            help: 'Test a plugin: spm.test <name>',
+            action: function (name) {
+              this.clearBufferedCommand();
+              (async () => {
+                if (!name.trim()) {
+                  console.log('Usage: spm.test <name>');
+                } else {
+                  const result = await spmCmds.testPlugin(name.trim());
+                  if (result.message) process.stdout.write(result.message);
+                }
+                r.displayPrompt();
+              })();
+            }
+          });
+
+          r.defineCommand('info', {
+            help: 'Show plugin info: spm.info <name>',
+            action: function (name) {
+              this.clearBufferedCommand();
+              (async () => {
+                if (!name.trim()) {
+                  console.log('Usage: spm.info <name>');
+                } else {
+                  const result = await spmCmds.infoPlugin(name.trim());
+                  if (result.message) process.stdout.write(result.message);
+                }
+                r.displayPrompt();
+              })();
+            }
+          });
+
+          r.defineCommand('update', {
+            help: 'Update all plugins',
+            action: function () {
+              this.clearBufferedCommand();
+              (async () => {
+                const result = await spmCmds.updatePlugins();
+                if (result.message) process.stdout.write(result.message);
+                r.displayPrompt();
+              })();
+            }
+          });
+
+          for (const [cmdName, cmd] of Object.entries(pluginCmds)) {
+            r.defineCommand(cmdName, {
+              help: cmd.description || `Plugin command (${cmd.plugin})`,
+              action: function (args) {
+                this.clearBufferedCommand();
+                (async () => {
+                  try {
+                    const ctx = {
+                      runtime,
+                      client: runtime.client,
+                      db: runtime.db,
+                      manager: runtime.pluginManager,
+                      config: runtime.config,
+                      user: runtime.client.user
+                    };
+                    const result = await cmd.execute(args.split(/\s+/), ctx);
+                    if (result) console.log(result);
+                  } catch (err) {
+                    console.error(`[${cmdName}] Error:`, err.message);
+                  }
+                  r.displayPrompt();
+                })();
+              }
+            });
+          }
+
+          r.on('exit', () => {
+            console.log('Bot continues running. Press Ctrl+C to stop.');
+          });
+        }
+
+        function clearSpiralCache() {
+          const spiralRoot = path.resolve(__dirname, '..');
+          Object.keys(require.cache).forEach(key => {
+            if (key.startsWith(spiralRoot + path.sep) && !key.includes('node_modules')) {
+              delete require.cache[key];
+            }
+          });
+        }
+
+        async function restart() {
+          if (restarting) {
+            pendingRestart = true;
+            return;
+          }
+          restarting = true;
+          console.log('\n[dev] File changed, restarting...');
+          try {
+            if (runtime) await runtime.stop();
+          } catch {}
+          clearSpiralCache();
+          try {
+            await start();
+          } catch (error) {
+            console.error('[dev] Restart failed:', error.message);
+          }
+          restarting = false;
+          if (pendingRestart) {
+            pendingRestart = false;
+            restart();
+          }
+        }
+
+        const watchDirs = [
+          path.join(process.cwd(), 'plugins'),
+          path.join(process.cwd(), 'src')
+        ].filter(d => fs.existsSync(d));
+
+        const watcher = chokidar.watch(watchDirs, {
+          ignored: /node_modules|\.git|data\.json|spiral\.json/,
+          persistent: true,
+          ignoreInitial: true,
+          awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
+        });
+
+        watcher.on('change', (filePath) => {
+          if (filePath.endsWith('.js') || filePath.endsWith('.dsl') || filePath.endsWith('.json')) {
+            console.log(`[dev] Changed: ${path.relative(process.cwd(), filePath)}`);
+            restart().catch(() => {});
+          }
+        });
+
+        await start();
+
+        process.on('SIGINT', async () => {
+          console.log('\nShutting down...');
+          watcher.close();
+          if (runtime) await runtime.stop();
+          process.exit(0);
+        });
+      } else {
+        const runtime = await startBot(config);
+        console.log('Bot is running! Press Ctrl+C to stop.');
+
+        process.on('SIGINT', async () => {
+          console.log('\nShutting down...');
+          await runtime.stop();
+          process.exit(0);
+        });
+      }
     } catch (error) {
       console.error('Failed to start bot:', error.message);
       process.exit(1);
@@ -176,7 +522,12 @@ program
   .command('dev')
   .description('Start bot with auto-reload on file changes')
   .action(async () => {
-    const chokidar = (() => { try { return require('chokidar'); } catch { return null; } })();
+    const chokidar = (() => {
+      try {
+        const resolved = require.resolve('chokidar', { paths: [process.cwd()] });
+        return require(resolved);
+      } catch { return null; }
+    })();
     if (!chokidar) {
       console.error('Error: "spiral dev" requires chokidar. Run: npm install chokidar');
       process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spiralcord-full",
-  "version": "2.2.7",
+  "version": "2.3.0",
   "description": "Spiralcord Full - Discord Bot Runtime with Voice, Music, AI, Database & Image Support",
   "main": "src/index.js",
   "types": "src/types/index.d.ts",

package/src/plugins/manager.js

@@ -255,6 +255,21 @@ class SpiralPluginManager extends EventEmitter {
     return result;
   }
 
+  getReplCommands() {
+    const result = {};
+    for (const [pluginName, { module: mod }] of this.plugins) {
+      if (mod.repl) {
+        for (const [cmdName, cmd] of Object.entries(mod.repl)) {
+          result[cmdName] = {
+            ...cmd,
+            plugin: pluginName
+          };
+        }
+      }
+    }
+    return result;
+  }
+
   async executeCommand(name, message, args) {
     const cmd = this.getCommand(name);
     if (!cmd) return false;

package/src/types/index.d.ts

@@ -44,11 +44,26 @@ export interface SpiralHooks {
   [key: string]: ((payload: any, runtime: SpiralRuntime) => Promise<void>) | undefined;
 }
 
+export interface ReplContext {
+  runtime: SpiralRuntime;
+  client: any;
+  db: SpiralDB;
+  manager: SpiralPluginManager;
+  config: SpiralConfig;
+  user: any;
+}
+
+export interface PluginReplCommand {
+  description: string;
+  execute: (args: string[], context: ReplContext) => Promise<string | void> | string | void;
+}
+
 export interface SpiralPlugin {
   init?: (config: SpiralPluginConfig, runtime: SpiralRuntime) => Promise<void>;
   commands?: Record<string, SpiralCommand>;
   keywords?: Record<string, (message: any, args: string[], runtime: SpiralRuntime) => Promise<void>>;
   hooks?: SpiralHooks;
+  repl?: Record<string, PluginReplCommand>;
   api?: Record<string, (...args: any[]) => any>;
 }
 
@@ -66,6 +81,7 @@ export interface SpiralRuntime {
   config: SpiralConfig;
   client: any;
   db: SpiralDB;
+  pluginManager: SpiralPluginManager;
   startTime: number;
   start(): Promise<void>;
   restart(): Promise<void>;
@@ -80,6 +96,16 @@ export interface SpiralRuntime {
   emitHookWithResult(eventName: string, payload: any): Promise<boolean>;
 }
 
+export interface SpiralPluginManager {
+  loadPlugins(pluginsDir: string): Promise<void>;
+  reloadPlugins(): Promise<void>;
+  getCommand(name: string): any;
+  getAllCommands(): Map<string, any>;
+  getReplCommands(): Record<string, PluginReplCommand & { plugin: string }>;
+  getSlashCommands(): Array<{ name: string; description: string }>;
+  executeCommand(name: string, message: any, args: string[]): Promise<void>;
+}
+
 export interface SpiralTester {
   test(): Promise<{
     passed: number;