@shiva-fw/cli 1.0.0

package/src/commands/migrate/status.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+
+const { requireServerRoot } = require('../../utils/server-root');
+const { getDatabaseConfig } = require('../../utils/config-reader');
+const { scanModules } = require('../../utils/lua-parser');
+
+const MIGRATIONS_TABLE = 'shiva_migrations';
+
+/**
+ * Register the `shiva migrate:status` command.
+ * @param {import('commander').Command} program
+ */
+function migrateStatusCommand(program) {
+  program
+    .command('migrate:status')
+    .description('Show the status of all database migrations')
+    .action(async () => {
+      await run();
+    });
+}
+
+async function run() {
+  const serverRoot = requireServerRoot();
+  const dbConfig = getDatabaseConfig(serverRoot);
+
+  if (!dbConfig) {
+    console.error(chalk.red('✖ No database configuration found in shiva.json'));
+    process.exit(1);
+  }
+
+  let connection;
+  try {
+    const mysql = require('mysql2/promise');
+    connection = await mysql.createConnection({
+      host: dbConfig.host,
+      port: dbConfig.port || 3306,
+      user: dbConfig.user,
+      password: dbConfig.password,
+      database: dbConfig.database,
+    });
+  } catch (err) {
+    console.error(chalk.red('✖ Could not connect to database:'), err.message);
+    process.exit(1);
+  }
+
+  try {
+    const resourcesDir = path.join(serverRoot, 'resources');
+    const modules = scanModules(resourcesDir);
+    const allMigrations = collectMigrations(modules);
+
+    let ranMigrations = new Map();
+    const tableExists = await checkTableExists(connection, dbConfig.database);
+    if (tableExists) {
+      const [rows] = await connection.execute(
+        `SELECT \`migration\`, \`batch\`, \`ran_at\` FROM \`${MIGRATIONS_TABLE}\` ORDER BY \`id\``
+      );
+      for (const row of rows) {
+        ranMigrations.set(row.migration, row);
+      }
+    }
+
+    console.log('');
+    console.log(chalk.bold('Migration Status'));
+    console.log(chalk.gray('─'.repeat(72)));
+
+    if (allMigrations.length === 0) {
+      console.log(chalk.gray('  No migration files found.'));
+    } else {
+      const statusWidth = 9;
+      const batchWidth = 7;
+      console.log(
+        chalk.bold(
+          `  ${'Status'.padEnd(statusWidth)}  ${'Batch'.padEnd(batchWidth)}  Migration`
+        )
+      );
+      console.log(chalk.gray('  ' + '─'.repeat(68)));
+
+      for (const migration of allMigrations) {
+        const info = ranMigrations.get(migration.name);
+        if (info) {
+          console.log(
+            chalk.green('  ' + 'Ran'.padEnd(statusWidth)) +
+            chalk.gray('  ' + String(info.batch).padEnd(batchWidth)) +
+            '  ' + migration.name
+          );
+        } else {
+          console.log(
+            chalk.yellow('  ' + 'Pending'.padEnd(statusWidth)) +
+            chalk.gray('  ' + '—'.padEnd(batchWidth)) +
+            '  ' + chalk.yellow(migration.name)
+          );
+        }
+      }
+    }
+
+    console.log(chalk.gray('─'.repeat(72)));
+    const ranCount = allMigrations.filter(m => ranMigrations.has(m.name)).length;
+    const pendingCount = allMigrations.length - ranCount;
+    console.log(chalk.gray(`  ${ranCount} ran  ·  ${pendingCount} pending`));
+    console.log('');
+
+  } finally {
+    await connection.end();
+  }
+}
+
+async function checkTableExists(conn, database) {
+  const [rows] = await conn.execute(
+    `SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?`,
+    [database, MIGRATIONS_TABLE]
+  );
+  return rows.length > 0;
+}
+
+function collectMigrations(modules) {
+  const migrations = [];
+  for (const mod of modules) {
+    const migrationsDir = path.join(mod.path, 'migrations');
+    if (!fs.existsSync(migrationsDir)) continue;
+    const files = fs.readdirSync(migrationsDir)
+      .filter(f => f.endsWith('.lua'))
+      .sort();
+    for (const file of files) {
+      migrations.push({
+        name: `${mod.name}/${file.replace('.lua', '')}`,
+        module: mod.name,
+      });
+    }
+  }
+  return migrations.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+module.exports = migrateStatusCommand;

package/src/commands/module/list.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const path = require('path');
+const chalk = require('chalk');
+
+const { requireServerRoot, getResourcesDir } = require('../../utils/server-root');
+const { scanModules } = require('../../utils/lua-parser');
+
+function moduleListCommand(program) {
+  program
+    .command('module:list')
+    .description('List all installed Shiva modules')
+    .action(() => { run(); });
+}
+
+function run() {
+  const serverRoot   = requireServerRoot();
+  const resourcesDir = getResourcesDir(serverRoot);
+  const modules      = scanModules(resourcesDir);
+
+  console.log('');
+  if (modules.length === 0) {
+    console.log(chalk.gray('  No modules found. Run `shiva install` to install modules.'));
+    console.log('');
+    return;
+  }
+
+  const nameW = Math.max(20, ...modules.map(m => m.name.length)) + 2;
+  const verW  = 10;
+
+  console.log(chalk.bold(`  ${'Module'.padEnd(nameW)} ${'Version'.padEnd(verW)} Dependencies`));
+  console.log(chalk.gray('  ' + '─'.repeat(nameW + verW + 30)));
+
+  for (const mod of modules) {
+    const name    = mod.name.padEnd(nameW);
+    const version = (mod.manifest.version || '?').padEnd(verW);
+    const deps    = (mod.manifest.dependencies || []).join(', ') || chalk.gray('—');
+    console.log(`  ${chalk.cyan(name)} ${chalk.gray(version)} ${deps}`);
+  }
+
+  console.log('');
+  console.log(chalk.gray(`  ${modules.length} module(s) installed.`));
+  console.log('');
+}
+
+module.exports = moduleListCommand;

package/src/commands/module/status.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const path = require('path');
+const fs   = require('fs');
+const chalk = require('chalk');
+
+const { requireServerRoot, getResourcesDir } = require('../../utils/server-root');
+const { scanModules } = require('../../utils/lua-parser');
+
+function moduleStatusCommand(program) {
+  program
+    .command('module:status')
+    .description('Show detailed status for all installed modules')
+    .option('-m, --module <name>', 'Show status for a specific module only')
+    .action((options) => { run(options); });
+}
+
+function run(options) {
+  const serverRoot   = requireServerRoot();
+  const resourcesDir = getResourcesDir(serverRoot);
+  let modules        = scanModules(resourcesDir);
+
+  if (options.module) {
+    const filter = options.module.startsWith('shiva-') ? options.module : `shiva-${options.module}`;
+    modules = modules.filter(m => m.name === filter);
+    if (modules.length === 0) {
+      console.error(chalk.red(`✖ Module not found: ${filter}`));
+      process.exit(1);
+    }
+  }
+
+  if (modules.length === 0) {
+    console.log(chalk.gray('\n  No modules found.\n'));
+    return;
+  }
+
+  console.log('');
+  for (const mod of modules) {
+    const m = mod.manifest;
+    const migrationsDir = path.join(mod.path, 'migrations');
+    const migrationCount = fs.existsSync(migrationsDir)
+      ? fs.readdirSync(migrationsDir).filter(f => f.endsWith('.lua')).length
+      : 0;
+
+    const testsDir = path.join(mod.path, 'tests');
+    const testCount = fs.existsSync(testsDir)
+      ? fs.readdirSync(testsDir).filter(f => f.endsWith('_spec.lua')).length
+      : 0;
+
+    console.log(chalk.bold.cyan(`  ${mod.name}`));
+    console.log(chalk.gray(`  ${'─'.repeat(50)}`));
+    console.log(`    Version      : ${chalk.white(m.version || '?')}`);
+    console.log(`    Description  : ${chalk.gray(m.description || '—')}`);
+    console.log(`    Path         : ${chalk.gray(mod.path)}`);
+    console.log(`    Dependencies : ${(m.dependencies || []).length > 0 ? (m.dependencies || []).join(', ') : chalk.gray('none')}`);
+    console.log(`    Provides     : ${(m.provides || []).length > 0 ? (m.provides || []).join(', ') : chalk.gray('none')}`);
+    console.log(`    Migrations   : ${migrationCount}`);
+    console.log(`    Tests        : ${testCount}`);
+    console.log(`    Events       : ${(m.events || []).length}`);
+    console.log('');
+  }
+}
+
+module.exports = moduleStatusCommand;

package/src/commands/outdated.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireServerRoot } = require('../utils/server-root');
+const { readShivaConfig }   = require('../utils/config-reader');
+const { readLockfile }      = require('../packages/lockfile');
+const { resolveVersion }    = require('../packages/resolver');
+const registry              = require('../packages/registry');
+
+function outdatedCommand(program) {
+  program
+    .command('outdated')
+    .description('Show modules with available updates')
+    .action(async () => { await run(); });
+}
+
+async function run() {
+  const serverRoot = requireServerRoot();
+  const config     = readShivaConfig(serverRoot);
+  const lock       = readLockfile(serverRoot);
+  const regUrl     = registry.getRegistryUrl(config);
+  const modules    = config.modules || {};
+
+  console.log('');
+
+  const rows = [];
+  for (const [name, constraint] of Object.entries(modules)) {
+    if (constraint.startsWith('file:')) continue;
+    let versions;
+    try { versions = await registry.fetchVersions(regUrl, name); } catch { continue; }
+    const latest  = resolveVersion(versions, 'latest');
+    const wanted  = resolveVersion(versions, constraint);
+    const current = lock.modules[name]?.version || chalk.gray('not installed');
+    if (latest && latest !== current) {
+      rows.push({ name, current, wanted: wanted || '?', latest });
+    }
+  }
+
+  if (rows.length === 0) {
+    console.log(chalk.green('✔ All modules are up to date.'));
+    console.log('');
+    return;
+  }
+
+  const nw = Math.max(20, ...rows.map(r => r.name.length)) + 2;
+  console.log(chalk.bold(`  ${'Module'.padEnd(nw)} ${'Current'.padEnd(12)} ${'Wanted'.padEnd(12)} Latest`));
+  console.log(chalk.gray('  ' + '─'.repeat(nw + 38)));
+  for (const r of rows) {
+    console.log(
+      `  ${chalk.cyan(r.name.padEnd(nw))} ` +
+      `${chalk.gray(String(r.current).padEnd(12))} ` +
+      `${chalk.yellow(String(r.wanted).padEnd(12))} ` +
+      `${chalk.green(r.latest)}`
+    );
+  }
+  console.log('');
+}
+
+module.exports = outdatedCommand;

package/src/commands/remove.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const path     = require('path');
+const fs       = require('fs');
+const chalk    = require('chalk');
+const inquirer = require('inquirer');
+
+const { requireServerRoot, getShivaModulesDir, getResourcesDir } = require('../utils/server-root');
+const { readShivaConfig, writeShivaConfig } = require('../utils/config-reader');
+const { unlockModule } = require('../packages/lockfile');
+const { scanModules }  = require('../utils/lua-parser');
+const { normalizeModuleName } = require('../generators/index');
+
+function removeCommand(program) {
+  program
+    .command('remove <module>')
+    .description('Remove an installed module')
+    .option('-f, --force', 'Skip confirmation prompt')
+    .action(async (moduleName, options) => { await run(moduleName, options); });
+}
+
+async function run(rawName, options) {
+  const serverRoot = requireServerRoot();
+  const name       = normalizeModuleName(rawName);
+  const moduleDir  = path.join(getShivaModulesDir(serverRoot), name);
+
+  if (!fs.existsSync(moduleDir)) {
+    console.error(chalk.red(`✖ Module not found: ${name}`));
+    process.exit(1);
+  }
+
+  const modules    = scanModules(getResourcesDir(serverRoot));
+  const dependents = modules.filter(m => (m.manifest.dependencies || []).includes(name));
+  if (dependents.length > 0) {
+    console.log('');
+    console.log(chalk.yellow(`  ⚠  The following modules depend on ${name}:`));
+    dependents.forEach(m => console.log(chalk.yellow(`     - ${m.name}`)));
+  }
+
+  if (!options.force) {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm', name: 'confirm',
+      message: `Remove ${chalk.bold(name)}?`,
+      default: false,
+    }]);
+    if (!confirm) { console.log(chalk.gray('Aborted.')); return; }
+  }
+
+  fs.rmSync(moduleDir, { recursive: true, force: true });
+  unlockModule(serverRoot, name);
+
+  const config = readShivaConfig(serverRoot);
+  delete config.modules[name];
+  writeShivaConfig(serverRoot, config);
+
+  console.log('');
+  console.log(chalk.green(`✔ Removed ${name}`));
+  console.log('');
+}
+
+module.exports = removeCommand;

package/src/commands/seed.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const path = require('path');
+const fs   = require('fs');
+const chalk = require('chalk');
+
+const { requireServerRoot, getResourcesDir } = require('../utils/server-root');
+const { getDatabaseConfig } = require('../utils/config-reader');
+const { scanModules } = require('../utils/lua-parser');
+const { normalizeModuleName } = require('../generators/index');
+
+function seedCommand(program) {
+  program
+    .command('seed')
+    .description('Run database seeders')
+    .option('-m, --module <module>', 'Seed only a specific module')
+    .option('--dry-run', 'Show what would run without executing')
+    .action(async (options) => { await run(options); });
+}
+
+async function run(options) {
+  const serverRoot = requireServerRoot();
+  const dbConfig   = getDatabaseConfig(serverRoot);
+
+  if (!dbConfig) {
+    console.error(chalk.red('✖ No database configuration found in shiva.json'));
+    process.exit(1);
+  }
+
+  let connection;
+  try {
+    const mysql = require('mysql2/promise');
+    connection  = await mysql.createConnection({
+      host:               dbConfig.host,
+      port:               dbConfig.port || 3306,
+      user:               dbConfig.user,
+      password:           dbConfig.password,
+      database:           dbConfig.database,
+      multipleStatements: true,
+    });
+  } catch (err) {
+    console.error(chalk.red('✖ Could not connect to database:'), err.message);
+    process.exit(1);
+  }
+
+  try {
+    const resourcesDir = getResourcesDir(serverRoot);
+    let modules        = scanModules(resourcesDir);
+
+    if (options.module) {
+      const name = normalizeModuleName(options.module);
+      modules    = modules.filter(m => m.name === name);
+      if (modules.length === 0) {
+        console.error(chalk.red(`✖ Module not found: ${name}`));
+        process.exit(1);
+      }
+    }
+
+    const seeds = collectSeeds(modules);
+
+    if (seeds.length === 0) {
+      console.log(chalk.gray('  No seed files found (expected at seeds/*.lua inside each module).'));
+      return;
+    }
+
+    console.log('');
+    console.log(chalk.bold(`Running ${seeds.length} seeder(s)...\n`));
+
+    for (const seed of seeds) {
+      if (options.dryRun) {
+        console.log(chalk.yellow(`  [dry-run] ${seed.name}`));
+        continue;
+      }
+
+      process.stdout.write(chalk.gray(`  Seeding: ${seed.name} ...`));
+      try {
+        const mod = require(seed.path);
+        await mod.run({ execute: (sql, params) => connection.execute(sql, params || []) });
+        console.log(chalk.green(' done'));
+      } catch (err) {
+        console.log(chalk.red(' failed'));
+        console.error(chalk.red(`    Error: ${err.message}`));
+      }
+    }
+
+    if (!options.dryRun) {
+      console.log('');
+      console.log(chalk.green('✔ Seeding complete.'));
+    }
+  } finally {
+    await connection.end();
+  }
+}
+
+function collectSeeds(modules) {
+  const seeds = [];
+  for (const mod of modules) {
+    const seedsDir = path.join(mod.path, 'seeds');
+    if (!fs.existsSync(seedsDir)) continue;
+    const files = fs.readdirSync(seedsDir).filter(f => f.endsWith('.lua')).sort();
+    for (const file of files) {
+      seeds.push({ name: `${mod.name}/${file}`, path: path.join(seedsDir, file) });
+    }
+  }
+  return seeds;
+}
+
+module.exports = seedCommand;

package/src/commands/test.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const path = require('path');
+const fs   = require('fs');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+const { requireServerRoot, getResourcesDir } = require('../utils/server-root');
+const { scanModules } = require('../utils/lua-parser');
+const { normalizeModuleName } = require('../generators/index');
+
+function testCommand(program) {
+  program
+    .command('test')
+    .description('Run module test suites')
+    .option('-m, --module <module>', 'Run tests for a specific module')
+    .option('-f, --filter <pattern>', 'Filter test files by name pattern')
+    .action(async (options) => { await run(options); });
+}
+
+async function run(options) {
+  const serverRoot   = requireServerRoot();
+  const resourcesDir = getResourcesDir(serverRoot);
+  let   modules      = scanModules(resourcesDir);
+
+  if (options.module) {
+    const name = normalizeModuleName(options.module);
+    modules    = modules.filter(m => m.name === name);
+    if (modules.length === 0) {
+      console.error(chalk.red(`✖ Module not found: ${name}`));
+      process.exit(1);
+    }
+  }
+
+  const specs = collectSpecs(modules, options.filter);
+
+  if (specs.length === 0) {
+    console.log(chalk.gray('\n  No test specs found (_spec.lua files in tests/ directories).\n'));
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.bold(`Running ${specs.length} spec file(s)...\n`));
+
+  let passed = 0;
+  let failed = 0;
+
+  for (const spec of specs) {
+    process.stdout.write(chalk.gray(`  ${spec.label} ...`));
+    try {
+      execSync(`lua ${spec.path}`, { stdio: 'pipe', cwd: path.dirname(spec.path) });
+      console.log(chalk.green(' pass'));
+      passed++;
+    } catch (err) {
+      console.log(chalk.red(' fail'));
+      const output = err.stdout?.toString() || err.stderr?.toString() || err.message;
+      output.split('\n').filter(Boolean).forEach(l => console.log(chalk.red(`    ${l}`)));
+      failed++;
+    }
+  }
+
+  console.log('');
+  console.log(
+    failed === 0
+      ? chalk.green(`✔ All ${passed} spec(s) passed.`)
+      : chalk.red(`✖ ${failed} failed, ${passed} passed.`)
+  );
+  console.log('');
+
+  if (failed > 0) process.exit(1);
+}
+
+function collectSpecs(modules, filter) {
+  const specs = [];
+  for (const mod of modules) {
+    const testsDir = path.join(mod.path, 'tests');
+    if (!fs.existsSync(testsDir)) continue;
+    const files = fs.readdirSync(testsDir)
+      .filter(f => f.endsWith('_spec.lua'))
+      .filter(f => !filter || f.includes(filter));
+    for (const file of files) {
+      specs.push({ label: `${mod.name}/${file}`, path: path.join(testsDir, file) });
+    }
+  }
+  return specs;
+}
+
+module.exports = testCommand;

package/src/commands/update.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const path = require('path');
+const fs   = require('fs');
+const chalk = require('chalk');
+
+const { requireServerRoot, getShivaModulesDir } = require('../utils/server-root');
+const { readShivaConfig } = require('../utils/config-reader');
+const { readLockfile, lockModule } = require('../packages/lockfile');
+const { resolveVersion } = require('../packages/resolver');
+const registry = require('../packages/registry');
+const { normalizeModuleName } = require('../generators/index');
+
+function updateCommand(program) {
+  program
+    .command('update [module]')
+    .description('Update installed modules to the latest compatible version')
+    .action(async (moduleName) => { await run(moduleName); });
+}
+
+async function run(moduleName) {
+  const serverRoot = requireServerRoot();
+  const config     = readShivaConfig(serverRoot);
+  const lock       = readLockfile(serverRoot);
+  const regUrl     = registry.getRegistryUrl(config);
+
+  let targets = Object.entries(config.modules || {});
+  if (moduleName) {
+    const name = normalizeModuleName(moduleName);
+    targets    = targets.filter(([n]) => n === name);
+    if (targets.length === 0) {
+      console.error(chalk.red(`✖ ${name} not found in shiva.json`));
+      process.exit(1);
+    }
+  }
+
+  console.log('');
+  let updated = 0;
+
+  for (const [name, constraint] of targets) {
+    if (constraint.startsWith('file:')) {
+      console.log(chalk.gray(`  ${name}: file reference, skipping`));
+      continue;
+    }
+
+    let versions;
+    try {
+      versions = await registry.fetchVersions(regUrl, name);
+    } catch (err) {
+      console.log(chalk.red(`  ${name}: failed to fetch versions — ${err.message}`));
+      continue;
+    }
+
+    const latest  = resolveVersion(versions, constraint);
+    const current = lock.modules[name]?.version;
+
+    if (!latest) {
+      console.log(chalk.yellow(`  ${name}: no version matching ${constraint}`));
+      continue;
+    }
+
+    if (current === latest) {
+      console.log(chalk.gray(`  ${name}@${latest} already up to date`));
+      continue;
+    }
+
+    const destDir = path.join(getShivaModulesDir(serverRoot), name);
+    process.stdout.write(chalk.gray(`  Updating ${name} ${current || '?'} → ${latest} ...`));
+
+    try {
+      const meta = await registry.fetchModuleMeta(regUrl, name, latest);
+      if (fs.existsSync(destDir)) fs.rmSync(destDir, { recursive: true, force: true });
+      await registry.downloadModule(meta.downloadUrl, destDir);
+      lockModule(serverRoot, name, { version: latest, resolved: meta.downloadUrl });
+      console.log(chalk.green(' done'));
+      updated++;
+    } catch (err) {
+      console.log(chalk.red(' failed'));
+      console.error(chalk.red(`    ${err.message}`));
+    }
+  }
+
+  console.log('');
+  console.log(updated > 0
+    ? chalk.green(`✔ Updated ${updated} module(s).`)
+    : chalk.gray('  Everything is up to date.'));
+  console.log('');
+}
+
+module.exports = updateCommand;