spiralcord-full 2.1.0 → 2.3.0

package/bin/spiral.js

@@ -3,14 +3,15 @@
 const { Command } = require('commander');
 const path = require('path');
 const fs = require('fs');
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
 
 const program = new Command();
+const SPIRAL_ROOT = path.resolve(__dirname, '..');
 
 program
   .name('spiral')
   .description('Spiralcord - Discord Bot Runtime & Maker')
-  .version('2.0.0');
+  .version(require('../package.json').version);
 
 program
   .command('install <repo>')
@@ -30,20 +31,33 @@ program
     }
 
     let repoUrl = repo;
-    if (!repo.includes('github.com') && !repo.startsWith('http')) {
+    if (!repo.includes('github.com') && !repo.startsWith('http') && !repo.startsWith('git@')) {
       repoUrl = `https://github.com/${repo}`;
     }
+    if (!repoUrl.endsWith('.git')) repoUrl += '.git';
 
     console.log(`Installing from ${repoUrl}...`);
 
     try {
-      execSync('git init', { cwd, stdio: 'inherit' });
-      execSync(`git remote add origin ${repoUrl}`, { cwd, stdio: 'inherit' });
-      execSync('git fetch origin main --depth 1', { cwd, stdio: 'inherit' });
-      execSync('git checkout -b main FETCH_HEAD', { cwd, stdio: 'inherit' });
+      execFileSync('git', ['init'], { cwd, stdio: 'inherit' });
+      execFileSync('git', ['remote', 'add', 'origin', repoUrl], { cwd, stdio: 'inherit' });
+
+      let fetched = false;
+      for (const branch of ['main', 'master']) {
+        try {
+          execFileSync('git', ['fetch', 'origin', branch, '--depth', '1'], { cwd, stdio: 'inherit' });
+          execFileSync('git', ['checkout', '-b', branch, 'FETCH_HEAD'], { cwd, stdio: 'inherit' });
+          fetched = true;
+          break;
+        } catch {}
+      }
+
+      if (!fetched) {
+        throw new Error('Could not fetch main or master branch');
+      }
     } catch (error) {
-      console.error('Failed to clone repository.');
-      try { execSync('git clean -fd', { cwd, stdio: 'inherit' }); } catch {}
+      console.error('Failed to clone repository:', error.message);
+      try { execFileSync('git', ['clean', '-fd'], { cwd, stdio: 'inherit' }); } catch {}
       try { fs.rmSync(path.join(cwd, '.git'), { recursive: true }); } catch {}
       return;
     }
@@ -65,106 +79,531 @@ program
 
 program
   .command('update')
-  .description('Update bot from GitHub (preserves token and configs)')
-  .option('--no-install', 'Skip npm install')
-  .action(async (options) => {
-    const cwd = process.cwd();
+  .description('Update spiralcord to latest version')
+  .action(async () => {
+    const pkgPath = path.join(SPIRAL_ROOT, 'package.json');
+    const currentVer = require(pkgPath).version;
+    console.log(`Current version: v${currentVer}`);
+    console.log('Updating spiralcord...');
 
-    if (!fs.existsSync(path.join(cwd, 'spiral.json'))) {
-      console.error('Error: spiral.json not found. Run "spiral install" first.');
-      return;
+    try {
+      execSync('npm install -g spiralcord@latest', { stdio: 'inherit' });
+      delete require.cache[require.resolve(pkgPath)];
+      const newVer = require(pkgPath).version;
+      if (newVer !== currentVer) {
+        console.log(`\nUpdated: v${currentVer} → v${newVer}`);
+      } else {
+        console.log('\nAlready up to date!');
+      }
+    } catch (error) {
+      console.error('Failed to update:', error.message);
     }
+  });
 
-    if (!fs.existsSync(path.join(cwd, '.git'))) {
-      console.error('Error: Not a git repo. Run "spiral install" first.');
-      return;
-    }
+async function loadConfig() {
+  const configPath = path.join(process.cwd(), 'spiral.json');
+
+  if (!fs.existsSync(configPath)) {
+    console.log('spiral.json not found. Creating default config...');
+    const defaultConfig = {
+      name: 'My Spiral Bot',
+      token: '',
+      prefix: '!',
+      intents: ['Guilds', 'GuildMessages', 'MessageContent'],
+      clientId: '',
+      disabledCommands: []
+    };
+    fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+    console.log('Created spiral.json — edit it with your bot token, then run "spiral run".');
+    return null;
+  }
 
-    console.log('Saving configs...');
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  } catch (e) {
+    console.error(`Error: spiral.json is invalid JSON: ${e.message}`);
+    return null;
+  }
 
-    const spiralConfig = fs.readFileSync(path.join(cwd, 'spiral.json'), 'utf-8');
+  if (!config || typeof config !== 'object') {
+    console.error('Error: spiral.json must be a JSON object');
+    return null;
+  }
 
-    const pluginConfigs = {};
-    const pluginsDir = path.join(cwd, 'plugins');
-    if (fs.existsSync(pluginsDir)) {
-      for (const plugin of fs.readdirSync(pluginsDir)) {
-        const configPath = path.join(pluginsDir, plugin, 'config.json');
-        if (fs.existsSync(configPath)) {
-          pluginConfigs[plugin] = fs.readFileSync(configPath, 'utf-8');
-        }
-      }
-    }
+  if (!config.token || config.token === '') {
+    console.error('Error: Set your bot token in spiral.json');
+    return null;
+  }
 
-    console.log('Pulling updates...');
+  if (!Array.isArray(config.intents)) {
+    console.warn('Warning: Missing intents in spiral.json, using defaults');
+    config.intents = ['Guilds', 'GuildMessages', 'MessageContent'];
+  }
 
+  return config;
+}
+
+async function startBot(config) {
+  const SpiralRuntime = require('../src/runtime');
+  const runtime = new SpiralRuntime(config);
+  await runtime.start();
+  return runtime;
+}
+
+program
+  .command('run')
+  .description('Start the bot runtime')
+  .option('-R, --realtime', 'Start with auto-reload and REPL console')
+  .action(async (options) => {
     try {
-      execSync('git fetch origin main', { cwd, stdio: 'inherit' });
-      execSync('git reset --hard origin/main', { cwd, stdio: 'inherit' });
-    } catch (error) {
-      console.error('Failed to pull updates.');
-      return;
-    }
+      const config = await loadConfig();
+      if (!config) return;
+
+      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);
+        }
 
-    console.log('Restoring configs...');
+        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();
+        }
 
-    fs.writeFileSync(path.join(cwd, 'spiral.json'), spiralConfig);
+        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.');
+          });
+        }
 
-    if (fs.existsSync(pluginsDir)) {
-      for (const [plugin, config] of Object.entries(pluginConfigs)) {
-        const configPath = path.join(pluginsDir, plugin, 'config.json');
-        if (fs.existsSync(path.join(pluginsDir, plugin))) {
-          fs.writeFileSync(configPath, config);
+        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];
+            }
+          });
         }
-      }
-    }
 
-    if (options.install !== false) {
-      console.log('\nInstalling dependencies...');
-      try {
-        execSync('npm install', { cwd, stdio: 'inherit' });
-      } catch (error) {
-        console.error('Failed to install dependencies. Run "npm install" manually.');
+        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);
     }
-
-    console.log('\nBot updated!');
-    console.log('Run: spiral run');
   });
 
 program
-  .command('run')
-  .description('Start the bot runtime')
+  .command('dev')
+  .description('Start bot with auto-reload on file changes')
   .action(async () => {
-    const configPath = path.join(process.cwd(), 'spiral.json');
-
-    if (!fs.existsSync(configPath)) {
-      console.error('Error: spiral.json not found. Use "spiral install" to clone a bot.');
+    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);
     }
 
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    let runtime = null;
+    let restarting = false;
+    let pendingRestart = false;
 
-    if (!config.token || config.token === 'YOUR_DISCORD_TOKEN_HERE') {
-      console.error('Error: Please set your bot token in spiral.json');
-      process.exit(1);
+    async function start() {
+      const config = await loadConfig();
+      if (!config) return;
+      runtime = await startBot(config);
+      console.log('Dev mode active — watching for changes. Press Ctrl+C to stop.');
+    }
+
+    async function restart() {
+      if (restarting) {
+        pendingRestart = true;
+        return;
+      }
+      restarting = true;
+      console.log('\n[dev] File changed, restarting...');
+      try {
+        if (runtime) await runtime.stop();
+      } catch {}
+      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];
+        }
+      });
+      try {
+        await start();
+      } catch (error) {
+        console.error('[dev] Restart failed:', error.message);
+      }
+      restarting = false;
+      if (pendingRestart) {
+        pendingRestart = false;
+        restart();
+      }
     }
 
-    const SpiralRuntime = require('../src/runtime');
-    const runtime = new SpiralRuntime(config);
+    const watchDirs = [
+      path.join(process.cwd(), 'plugins'),
+      path.join(process.cwd(), 'src')
+    ].filter(d => fs.existsSync(d));
 
-    try {
-      await runtime.start();
-      console.log('Bot is running! Press Ctrl+C to stop.');
+    const watcher = chokidar.watch(watchDirs, {
+      ignored: /node_modules|\.git|data\.json|spiral\.json/,
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
+    });
 
-      process.on('SIGINT', async () => {
-        console.log('\nShutting down...');
-        await runtime.stop();
-        process.exit(0);
-      });
+    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(() => {});
+      }
+    });
+
+    try {
+      await start();
     } catch (error) {
       console.error('Failed to start bot:', error.message);
       process.exit(1);
     }
+
+    process.on('SIGINT', async () => {
+      console.log('\nShutting down...');
+      watcher.close();
+      if (runtime) await runtime.stop();
+      process.exit(0);
+    });
   });
 
 program
@@ -172,16 +611,24 @@ program
   .description('Start the web plugin manager')
   .option('-p, --port <port>', 'Port number', '3000')
   .action(async (options) => {
-    const SpiralWeb = require('../src/web/server');
-    const web = new SpiralWeb(null);
-
-    process.env.PORT = options.port;
-    web.port = parseInt(options.port);
+    const port = parseInt(options.port, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+      console.error('Error: Invalid port number');
+      return;
+    }
 
-    web.start();
-    console.log(`\nSpiralcord Web Manager started!`);
-    console.log(`Open http://localhost:${options.port} in your browser`);
-    console.log(`Press Ctrl+C to stop`);
+    try {
+      const SpiralWeb = require('../src/web/server');
+      const web = new SpiralWeb(null);
+      process.env.PORT = String(port);
+      web.port = port;
+      web.start();
+      console.log(`\nSpiralcord Web Manager started!`);
+      console.log(`Open http://localhost:${port} in your browser`);
+      console.log(`Press Ctrl+C to stop`);
+    } catch (error) {
+      console.error('Failed to start web manager:', error.message);
+    }
   });
 
 program
@@ -197,300 +644,127 @@ program
 
     console.log('Testing plugins...\n');
 
-    const SpiralTester = require('../src/test');
-    const tester = new SpiralTester(pluginsDir);
-    const result = await tester.test();
+    try {
+      const SpiralTester = require('../src/test');
+      const tester = new SpiralTester(pluginsDir);
+      const result = await tester.test();
 
-    for (const r of result.results) {
-      const icon = r.status === 'ok' ? '\x1b[32m✓\x1b[0m' :
-                   r.status === 'warning' ? '\x1b[33m⚠\x1b[0m' :
-                   '\x1b[31m✗\x1b[0m';
+      for (const r of result.results) {
+        const icon = r.status === 'ok' ? '\x1b[32m✓\x1b[0m' :
+                     r.status === 'warning' ? '\x1b[33m⚠\x1b[0m' :
+                     '\x1b[31m✗\x1b[0m';
 
-      const extra = r.commands > 0 ? ` (${r.commands} commands)` : '';
-      console.log(`${icon} ${r.name}${extra}`);
+        const extra = r.commands > 0 ? ` (${r.commands} commands)` : '';
+        console.log(`${icon} ${r.name}${extra}`);
 
-      for (const issue of r.issues) {
-        console.log(`  → ${issue}`);
+        for (const issue of r.issues) {
+          console.log(`  → ${issue}`);
+        }
       }
-    }
 
-    console.log('\n' + '─'.repeat(40));
+      console.log('\n' + '─'.repeat(40));
 
-    const passedColor = result.errors === 0 ? '\x1b[32m' : '\x1b[31m';
-    console.log(`${passedColor}Results: ${result.passed} passed, ${result.warnings} warnings, ${result.errors} errors\x1b[0m`);
+      const passedColor = result.errors === 0 ? '\x1b[32m' : '\x1b[31m';
+      console.log(`${passedColor}Results: ${result.passed} passed, ${result.warnings} warnings, ${result.errors} errors\x1b[0m`);
 
-    if (result.details.errors.length > 0) {
-      console.log('\n\x1b[31mErrors:\x1b[0m');
-      for (const err of result.details.errors) {
-        console.log(`  ✗ ${err}`);
+      if (result.details.errors.length > 0) {
+        console.log('\n\x1b[31mErrors:\x1b[0m');
+        for (const err of result.details.errors) {
+          console.log(`  ✗ ${err}`);
+        }
       }
-    }
 
-    if (result.details.warnings.length > 0) {
-      console.log('\n\x1b[33mWarnings:\x1b[0m');
-      for (const warn of result.details.warnings) {
-        console.log(`  ⚠ ${warn}`);
+      if (result.details.warnings.length > 0) {
+        console.log('\n\x1b[33mWarnings:\x1b[0m');
+        for (const warn of result.details.warnings) {
+          console.log(`  ⚠ ${warn}`);
+        }
       }
-    }
 
-    if (result.errors > 0) {
-      console.log('\n\x1b[31mFix errors before running the bot.\x1b[0m');
+      if (result.errors > 0) {
+        console.log('\n\x1b[31mFix errors before running the bot.\x1b[0m');
+        process.exit(1);
+      } else {
+        console.log('\n\x1b[32mAll tests passed! Run "spiral run" to start.\x1b[0m');
+      }
+    } catch (error) {
+      console.error('Test failed:', error.message);
       process.exit(1);
-    } else {
-      console.log('\n\x1b[32mAll tests passed! Run "spiral run" to start.\x1b[0m');
     }
   });
 
-const pluginCmd = program
+program
   .command('plugin')
-  .description('Manage plugins');
-
-pluginCmd
-  .command('list')
-  .description('List installed plugins')
-  .action(() => {
-    const pluginsDir = path.join(process.cwd(), 'plugins');
-
-    if (!fs.existsSync(pluginsDir)) {
-      console.log('No plugins directory found. Use "spiral install" to clone a bot.');
-      return;
-    }
-
-    const enabled = [];
-    const disabled = [];
-
-    const folders = fs.readdirSync(pluginsDir);
-    for (const f of folders) {
-      const isDisabled = f.startsWith('.') && (f.endsWith('.disabled') || !fs.existsSync(path.join(pluginsDir, f, 'plugin.json')));
-      const pluginDirName = f.endsWith('.disabled') ? f.slice(1, -9) : f;
-      const pluginPath = path.join(pluginsDir, pluginDirName, 'plugin.json');
-      const manifestPath = path.join(pluginsDir, f, 'plugin.json');
-
-      const actualManifestPath = fs.existsSync(manifestPath) ? manifestPath : pluginPath;
-      if (fs.existsSync(actualManifestPath)) {
-        const manifest = JSON.parse(fs.readFileSync(actualManifestPath, 'utf-8'));
-        if (isDisabled) {
-          disabled.push(manifest);
-        } else {
-          enabled.push(manifest);
-        }
-      }
-    }
-
-    if (enabled.length === 0 && disabled.length === 0) {
-      console.log('No plugins installed.');
-      return;
-    }
-
-    console.log('Installed plugins:');
-    for (const m of enabled) {
-      console.log(`  [enabled]  ${m.name} v${m.version}: ${m.description}`);
-    }
-    for (const m of disabled) {
-      console.log(`  [disabled] ${m.name} v${m.version}: ${m.description}`);
-    }
-  });
-
-pluginCmd
-  .command('install <source>')
-  .description('Install a plugin from GitHub or npm')
-  .action(async (source) => {
-    const cwd = process.cwd();
-    const pluginsDir = path.join(cwd, 'plugins');
-
-    if (!fs.existsSync(pluginsDir)) {
-      fs.mkdirSync(pluginsDir, { recursive: true });
-    }
-
-    let repoUrl = source;
-    let pluginName = '';
-
-    if (source.includes('github.com')) {
-      repoUrl = source;
-      const match = source.match(/github\.com\/[^\/]+\/([^\/\.]+)/);
-      pluginName = match ? match[1] : '';
-    } else if (source.startsWith('http')) {
-      repoUrl = source;
-      const match = source.match(/\/([^\/\.]+?)(?:\.git)?$/);
-      pluginName = match ? match[1] : '';
-    } else {
-      pluginName = source;
-      repoUrl = `https://github.com/${source}`;
-    }
-
-    if (!pluginName) {
-      console.error('Could not determine plugin name from source.');
-      return;
-    }
-
-    const pluginDir = path.join(pluginsDir, pluginName);
-
-    if (fs.existsSync(pluginDir)) {
-      console.error(`Plugin "${pluginName}" already exists. Remove it first.`);
-      return;
-    }
-
-    console.log(`Installing plugin "${pluginName}"...`);
-
+  .description('Manage plugins (delegates to spm)')
+  .argument('[args...]', 'spm arguments')
+  .action((args) => {
+    const spmPath = path.join(__dirname, '..', 'spm', 'bin', 'spm.js');
     try {
-      execSync(`git clone --depth 1 ${repoUrl} "${pluginDir}"`, { stdio: 'inherit' });
-
-      const gitDir = path.join(pluginDir, '.git');
-      if (fs.existsSync(gitDir)) {
-        fs.rmSync(gitDir, { recursive: true });
-      }
-
-      const manifestPath = path.join(pluginDir, 'plugin.json');
-      if (!fs.existsSync(manifestPath)) {
-        console.error('Error: plugin.json not found in the cloned repository.');
-        fs.rmSync(pluginDir, { recursive: true });
-        return;
-      }
-
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-      console.log(`Installed ${manifest.name} v${manifest.version}`);
+      execFileSync('node', [spmPath, ...args], { stdio: 'inherit' });
     } catch (error) {
-      console.error('Failed to install plugin:', error.message);
-      if (fs.existsSync(pluginDir)) {
-        fs.rmSync(pluginDir, { recursive: true });
+      if (error.status !== 0) {
+        console.error('spm exited with error');
       }
     }
   });
 
-pluginCmd
-  .command('enable <name>')
-  .description('Enable a plugin')
-  .action((name) => {
-    const pluginsDir = path.join(process.cwd(), 'plugins');
-    const pluginDir = path.join(pluginsDir, name);
-    const disabledDir = path.join(pluginsDir, `.${name}.disabled`);
-
-    if (fs.existsSync(pluginDir)) {
-      console.log(`Plugin "${name}" is already enabled.`);
-      return;
-    }
-
-    if (fs.existsSync(disabledDir)) {
-      fs.renameSync(disabledDir, pluginDir);
-      console.log(`Plugin "${name}" enabled.`);
-      return;
-    }
-
-    console.error(`Plugin "${name}" not found.`);
-  });
-
-pluginCmd
-  .command('disable <name>')
-  .description('Disable a plugin by renaming its folder')
-  .action((name) => {
-    const pluginsDir = path.join(process.cwd(), 'plugins');
-    const pluginDir = path.join(pluginsDir, name);
-    const disabledDir = path.join(pluginsDir, `.${name}.disabled`);
-
-    if (!fs.existsSync(pluginDir)) {
-      console.error(`Plugin "${name}" not found.`);
-      return;
-    }
-
-    fs.renameSync(pluginDir, disabledDir);
-    console.log(`Plugin "${name}" disabled.`);
-  });
-
-pluginCmd
-  .command('create <name>')
-  .description('Create a new plugin')
-  .action((name) => {
-    const cwd = process.cwd();
-    const pluginDir = path.join(cwd, 'plugins', name);
+program
+  .command('doctor')
+  .description('Check bot health and configuration')
+  .action(async () => {
+    console.log('Spiralcord Doctor\n');
+    let issues = 0;
 
-    if (fs.existsSync(pluginDir)) {
-      console.error(`Plugin "${name}" already exists.`);
-      return;
+    const nodeMajor = parseInt(process.versions.node.split('.')[0], 10);
+    if (nodeMajor >= 16) {
+      console.log(`\x1b[32m✓\x1b[0m Node.js ${process.version}`);
+    } else {
+      console.log(`\x1b[31m✗\x1b[0m Node.js ${process.version} (need >=16)`);
+      issues++;
     }
 
-    fs.mkdirSync(pluginDir, { recursive: true });
-
-    const manifest = {
-      name: name,
-      version: '1.0.0',
-      description: `${name} plugin`,
-      hooks: ['message_received']
-    };
-
-    const config = {
-      enabled: true,
-      message: `Hello from ${name}!`
-    };
-
-    const schema = {
-      $schema: 'http://json-schema.org/draft-07/schema#',
-      title: `${name} Plugin Config`,
-      type: 'object',
-      properties: {
-        enabled: { type: 'boolean', default: true },
-        message: { type: 'string', default: `Hello from ${name}!` }
-      }
-    };
-
-    const code = `module.exports = {
-  hooks: {
-    message_received: async (payload, runtime) => {
-      const { message } = payload;
-      if (message.content.startsWith('!${name}')) {
-        const config = runtime.getPluginConfig('${name}');
-        await message.reply(config.message);
+    const configPath = path.join(process.cwd(), 'spiral.json');
+    if (fs.existsSync(configPath)) {
+      console.log(`\x1b[32m✓\x1b[0m spiral.json found`);
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        if (config.token && config.token !== '' && config.token !== 'YOUR_DISCORD_TOKEN_HERE') {
+          console.log(`\x1b[32m✓\x1b[0m Bot token configured`);
+        } else {
+          console.log(`\x1b[31m✗\x1b[0m Bot token not set`);
+          issues++;
+        }
+        if (config.intents && config.intents.length > 0) {
+          console.log(`\x1b[32m✓\x1b[0m Intents: ${config.intents.join(', ')}`);
+        } else {
+          console.log(`\x1b[33m⚠\x1b[0m No intents configured`);
+        }
+      } catch (e) {
+        console.log(`\x1b[31m✗\x1b[0m spiral.json invalid: ${e.message}`);
+        issues++;
       }
+    } else {
+      console.log(`\x1b[31m✗\x1b[0m spiral.json not found`);
+      issues++;
     }
-  }
-};`;
-
-    fs.writeFileSync(path.join(pluginDir, 'plugin.json'), JSON.stringify(manifest, null, 2));
-    fs.writeFileSync(path.join(pluginDir, 'config.json'), JSON.stringify(config, null, 2));
-    fs.writeFileSync(path.join(pluginDir, 'config.schema.json'), JSON.stringify(schema, null, 2));
-    fs.writeFileSync(path.join(pluginDir, 'index.js'), code);
-
-    console.log(`Plugin "${name}" created at plugins/${name}/`);
-  });
-
-pluginCmd
-  .command('remove <name>')
-  .description('Remove a plugin')
-  .action((name) => {
-    const pluginsDir = path.join(process.cwd(), 'plugins', name);
-    const disabledDir = path.join(process.cwd(), 'plugins', `.${name}.disabled`);
 
+    const pluginsDir = path.join(process.cwd(), 'plugins');
     if (fs.existsSync(pluginsDir)) {
-      fs.rmSync(pluginsDir, { recursive: true });
-      console.log(`Plugin "${name}" removed.`);
-    } else if (fs.existsSync(disabledDir)) {
-      fs.rmSync(disabledDir, { recursive: true });
-      console.log(`Plugin "${name}" removed.`);
+      const folders = fs.readdirSync(pluginsDir).filter(f => !f.startsWith('.'));
+      console.log(`\x1b[32m✓\x1b[0m ${folders.length} plugin(s) found`);
     } else {
-      console.log(`Plugin "${name}" not found.`);
+      console.log(`\x1b[33m⚠\x1b[0m No plugins directory`);
     }
-  });
 
-pluginCmd
-  .command('edit <name>')
-  .description('Show plugin file location for editing')
-  .action((name) => {
-    const pluginsDir = path.join(process.cwd(), 'plugins', name);
+    const spiralVer = require(path.join(__dirname, '..', 'package.json')).version;
+    console.log(`\x1b[32m✓\x1b[0m Spiralcord v${spiralVer}`);
 
-    if (!fs.existsSync(pluginsDir)) {
-      console.error(`Plugin "${name}" not found.`);
-      return;
+    console.log('\n' + '─'.repeat(40));
+    if (issues === 0) {
+      console.log('\x1b[32mAll checks passed!\x1b[0m');
+    } else {
+      console.log(`\x1b[31m${issues} issue(s) found. Fix them before running the bot.\x1b[0m`);
     }
-
-    console.log(`Plugin "${name}" files:`);
-    const files = fs.readdirSync(pluginsDir);
-    files.forEach(f => {
-      const fullPath = path.join(pluginsDir, f);
-      const stat = fs.statSync(fullPath);
-      if (stat.isFile()) {
-        console.log(`  ${f}`);
-      }
-    });
-    console.log(`\nDirectory: ${pluginsDir}`);
   });
 
-program.parse();
+program.parse();