spiralcord-full 2.1.0

package/src/test.js

@@ -0,0 +1,361 @@
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+
+class SpiralTester {
+  constructor(pluginsDir) {
+    this.pluginsDir = pluginsDir;
+    this.errors = [];
+    this.warnings = [];
+    this.results = [];
+    this.allCommands = new Map();
+    this.allHooks = new Map();
+  }
+
+  async test() {
+    try {
+      await fs.access(this.pluginsDir);
+    } catch {
+      return {
+        passed: 0,
+        warnings: 0,
+        errors: 0,
+        results: [],
+        details: { warnings: [], errors: ['Plugins directory not found'] }
+      };
+    }
+
+    const entries = await fs.readdir(this.pluginsDir, { withFileTypes: true });
+    const pluginFolders = entries.filter(e => e.isDirectory() && !e.name.startsWith('.'));
+
+    for (const folder of pluginFolders) {
+      const pluginPath = path.join(this.pluginsDir, folder.name);
+      const result = await this.testPlugin(folder.name, pluginPath);
+      this.results.push(result);
+    }
+
+    this.checkCommandConflicts();
+    this.checkHookConflicts();
+
+    return {
+      passed: this.results.filter(r => r.status === 'ok').length,
+      warnings: this.warnings.length,
+      errors: this.errors.length,
+      results: this.results,
+      details: { warnings: this.warnings, errors: this.errors }
+    };
+  }
+
+  async testPlugin(name, pluginPath) {
+    const result = { name, status: 'ok', commands: 0, hooks: 0, issues: [] };
+
+    const manifestPath = path.join(pluginPath, 'plugin.json');
+    try {
+      await fs.access(manifestPath);
+    } catch {
+      result.status = 'error';
+      result.issues.push('Missing plugin.json');
+      this.errors.push(`${name}: Missing plugin.json`);
+      return result;
+    }
+
+    let manifest;
+    try {
+      const data = await fs.readFile(manifestPath, 'utf-8');
+      manifest = JSON.parse(data);
+    } catch (e) {
+      result.status = 'error';
+      result.issues.push(`Invalid plugin.json: ${e.message}`);
+      this.errors.push(`${name}: Invalid plugin.json - ${e.message}`);
+      return result;
+    }
+
+    if (!manifest.name) {
+      result.issues.push('Missing "name" in plugin.json');
+      this.warnings.push(`${name}: Missing "name" in manifest`);
+    }
+
+    if (!manifest.version) {
+      result.issues.push('Missing "version" in plugin.json');
+      this.warnings.push(`${name}: Missing "version" in manifest`);
+    }
+
+    const indexPath = path.join(pluginPath, 'index.js');
+    const dslPath = path.join(pluginPath, 'plugin.dsl');
+
+    const hasIndex = await this.fileExists(indexPath);
+    const hasDsl = await this.fileExists(dslPath);
+
+    if (!hasIndex && !hasDsl) {
+      result.status = 'error';
+      result.issues.push('No index.js or plugin.dsl found');
+      this.errors.push(`${name}: No index.js or plugin.dsl found`);
+      return result;
+    }
+
+    if (hasIndex) {
+      const jsResult = await this.testJSPlugin(name, indexPath);
+      result.commands += jsResult.commands;
+      result.hooks += jsResult.hooks;
+      if (jsResult.issues.length > 0) {
+        result.issues.push(...jsResult.issues);
+        if (jsResult.status === 'error') result.status = 'error';
+      }
+    }
+
+    if (hasDsl) {
+      const dslResult = await this.testDSLPlugin(name, dslPath);
+      result.commands += dslResult.commands;
+      if (dslResult.issues.length > 0) {
+        result.issues.push(...dslResult.issues);
+        if (dslResult.status === 'error') result.status = 'error';
+      }
+    }
+
+    const configResult = await this.testConfig(name, pluginPath, manifest);
+    if (configResult.issues.length > 0) {
+      result.issues.push(...configResult.issues);
+    }
+
+    if (result.issues.length > 0 && result.status === 'ok') {
+      result.status = 'warning';
+    }
+
+    return result;
+  }
+
+  async testJSPlugin(name, indexPath) {
+    const result = { commands: 0, hooks: 0, issues: [], status: 'ok' };
+
+    try {
+      const code = await fs.readFile(indexPath, 'utf-8');
+
+      const syntaxCheck = this.checkJSSyntax(code);
+      if (!syntaxCheck.valid) {
+        result.status = 'error';
+        result.issues.push(`JS syntax error: ${syntaxCheck.error}`);
+        this.errors.push(`${name}: JS syntax error - ${syntaxCheck.error}`);
+        return result;
+      }
+
+      const exportsMatch = code.match(/module\.exports\s*=\s*\{/);
+      if (!exportsMatch) {
+        result.issues.push('No module.exports found');
+        this.warnings.push(`${name}: No module.exports found`);
+      }
+
+      const commandsMatch = code.match(/commands\s*:\s*\{/);
+      const hooksMatch = code.match(/hooks\s*:\s*\{/);
+      const apiMatch = code.match(/api\s*:\s*\{/);
+
+      if (!commandsMatch && !hooksMatch && !apiMatch) {
+        result.issues.push('No commands, hooks, or api exported');
+        this.warnings.push(`${name}: No commands, hooks, or api exported`);
+      }
+
+      if (commandsMatch) {
+        const cmdRegex = /(\w+)\s*:\s*\{/g;
+        let match;
+        while ((match = cmdRegex.exec(code)) !== null) {
+          if (match[1] !== 'commands' && match[1] !== 'hooks' && match[1] !== 'api' && match[1] !== 'init') {
+            result.commands++;
+            this.allCommands.set(match[1], name);
+          }
+        }
+      }
+
+      if (hooksMatch) {
+        const hookRegex = /(\w+)\s*:\s*async\s*\(/g;
+        let match;
+        while ((match = hookRegex.exec(code)) !== null) {
+          if (['message_received', 'bot_ready', 'interaction_received', 'presence_update', 'guild_joined', 'guild_left', 'voice_state_update', 'reaction_add', 'reaction_remove', 'bot_shutdown'].includes(match[1])) {
+            result.hooks++;
+            if (!this.allHooks.has(match[1])) this.allHooks.set(match[1], []);
+            this.allHooks.get(match[1]).push(name);
+          }
+        }
+      }
+
+      const requireMatches = code.match(/require\(['"]([^'"]+)['"]\)/g);
+      if (requireMatches) {
+        for (const req of requireMatches) {
+          const module = req.match(/require\(['"]([^'"]+)['"]\)/)[1];
+          if (module.startsWith('.') || module.startsWith('/')) continue;
+          try {
+            require.resolve(module);
+          } catch {
+            result.issues.push(`Missing dependency: ${module}`);
+            this.warnings.push(`${name}: Missing dependency - ${module}`);
+          }
+        }
+      }
+
+    } catch (e) {
+      result.status = 'error';
+      result.issues.push(`Failed to read: ${e.message}`);
+      this.errors.push(`${name}: Failed to read index.js - ${e.message}`);
+    }
+
+    return result;
+  }
+
+  async testDSLPlugin(name, dslPath) {
+    const result = { commands: 0, issues: [], status: 'ok' };
+
+    try {
+      const dsl = await fs.readFile(dslPath, 'utf-8');
+      const lines = dsl.split('\n');
+
+      let inCommand = false;
+      let inResponsePool = false;
+      let commandName = '';
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+
+        if (line === '' || line.startsWith('#')) continue;
+
+        if (line.startsWith('COMMAND ')) {
+          const match = line.match(/COMMAND\s+(\S+)\s+"([^"]+)"/);
+          if (!match) {
+            result.status = 'error';
+            result.issues.push(`Line ${i + 1}: Invalid COMMAND syntax`);
+            this.errors.push(`${name}: Line ${i + 1} - Invalid COMMAND syntax`);
+          } else {
+            inCommand = true;
+            commandName = match[1];
+            result.commands++;
+            this.allCommands.set(commandName, name);
+          }
+        } else if (line === 'END') {
+          if (inResponsePool) {
+            inResponsePool = false;
+          } else {
+            inCommand = false;
+            commandName = '';
+          }
+        } else if (inCommand) {
+          if (line.startsWith('RESPONSE_POOL')) {
+            inResponsePool = true;
+          } else if (!inResponsePool) {
+            if (!line.startsWith('ALIASES') && !line.startsWith('COOLDOWN') &&
+                !line.startsWith('REQUIRES') && !line.startsWith('RESPONSE ') &&
+                !line.startsWith('EMBED') && !line.startsWith('TITLE') &&
+                !line.startsWith('DESCRIPTION')) {
+              result.issues.push(`Line ${i + 1}: Unknown DSL keyword: ${line.split(' ')[0]}`);
+              this.warnings.push(`${name}: Line ${i + 1} - Unknown DSL keyword`);
+            }
+          }
+        }
+      }
+
+      if (inCommand) {
+        result.status = 'error';
+        result.issues.push('Unclosed COMMAND block (missing END)');
+        this.errors.push(`${name}: Unclosed COMMAND block`);
+      }
+
+    } catch (e) {
+      result.status = 'error';
+      result.issues.push(`Failed to read: ${e.message}`);
+      this.errors.push(`${name}: Failed to read plugin.dsl - ${e.message}`);
+    }
+
+    return result;
+  }
+
+  async testConfig(name, pluginPath, manifest) {
+    const result = { issues: [] };
+
+    const configSchemaPath = path.join(pluginPath, 'config.schema.json');
+    const configPath = path.join(pluginPath, 'config.json');
+
+    const hasSchema = await this.fileExists(configSchemaPath);
+    const hasConfig = await this.fileExists(configPath);
+
+    if (hasSchema) {
+      try {
+        const schemaData = await fs.readFile(configSchemaPath, 'utf-8');
+        JSON.parse(schemaData);
+      } catch (e) {
+        result.issues.push(`Invalid config.schema.json: ${e.message}`);
+        this.warnings.push(`${name}: Invalid config.schema.json`);
+      }
+    }
+
+    if (hasConfig) {
+      try {
+        const configData = await fs.readFile(configPath, 'utf-8');
+        const config = JSON.parse(configData);
+
+        if (hasSchema) {
+          try {
+            const schemaData = await fs.readFile(configSchemaPath, 'utf-8');
+            const schema = JSON.parse(schemaData);
+
+            if (schema.properties) {
+              for (const [key, prop] of Object.entries(schema.properties)) {
+                if (prop.type === 'string' && config[key] !== undefined && typeof config[key] !== 'string') {
+                  result.issues.push(`Config "${key}" should be string, got ${typeof config[key]}`);
+                  this.warnings.push(`${name}: Config "${key}" type mismatch`);
+                }
+                if (prop.type === 'number' && config[key] !== undefined && typeof config[key] !== 'number') {
+                  result.issues.push(`Config "${key}" should be number, got ${typeof config[key]}`);
+                  this.warnings.push(`${name}: Config "${key}" type mismatch`);
+                }
+                if (prop.type === 'boolean' && config[key] !== undefined && typeof config[key] !== 'boolean') {
+                  result.issues.push(`Config "${key}" should be boolean, got ${typeof config[key]}`);
+                  this.warnings.push(`${name}: Config "${key}" type mismatch`);
+                }
+              }
+            }
+          } catch {}
+        }
+      } catch (e) {
+        result.issues.push(`Invalid config.json: ${e.message}`);
+        this.warnings.push(`${name}: Invalid config.json`);
+      }
+    }
+
+    return result;
+  }
+
+  checkCommandConflicts() {
+    const seen = new Map();
+    for (const [cmd, plugin] of this.allCommands) {
+      if (seen.has(cmd)) {
+        this.warnings.push(`Command conflict: "${cmd}" in ${seen.get(cmd)} and ${plugin}`);
+      } else {
+        seen.set(cmd, plugin);
+      }
+    }
+  }
+
+  checkHookConflicts() {
+    for (const [hook, plugins] of this.allHooks) {
+      if (plugins.length > 1) {
+        this.warnings.push(`Hook "${hook}" used by ${plugins.length} plugins: ${plugins.join(', ')}`);
+      }
+    }
+  }
+
+  checkJSSyntax(code) {
+    try {
+      new Function(code);
+      return { valid: true };
+    } catch (e) {
+      return { valid: false, error: e.message };
+    }
+  }
+
+  async fileExists(path) {
+    try {
+      await fs.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = SpiralTester;