@shiva-fw/cli 1.0.0

package/src/commands/make/module.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+const { requireServerRoot, getShivaModulesDir } = require('../../utils/server-root');
+const { writeTemplate, toPascalCase, normalizeModuleName } = require('../../generators/index');
+
+/**
+ * Register the `shiva make:module` command.
+ * @param {import('commander').Command} program
+ */
+function makeModuleCommand(program) {
+  program
+    .command('make:module <name>')
+    .description('Scaffold a new Shiva module')
+    .option('-d, --description <desc>', 'Module description')
+    .option('-a, --author <author>', 'Module author')
+    .option('--no-git', 'Skip .gitkeep files')
+    .action(async (name, options) => {
+      await run(name, options);
+    });
+}
+
+async function run(rawName, options) {
+  const moduleName = normalizeModuleName(rawName);
+  const moduleShort = moduleName.replace(/^shiva-/, '');
+  const PascalName = toPascalCase(moduleShort);
+
+  let description = options.description;
+  let author = options.author;
+
+  if (!description || !author) {
+    const answers = await inquirer.prompt([
+      !description && {
+        type: 'input',
+        name: 'description',
+        message: 'Module description:',
+        default: `${PascalName} module for Shiva`,
+      },
+      !author && {
+        type: 'input',
+        name: 'author',
+        message: 'Author:',
+        default: '',
+      },
+    ].filter(Boolean));
+
+    description = description || answers.description;
+    author = author || answers.author || '';
+  }
+
+  const serverRoot = requireServerRoot();
+  const modulesDir = getShivaModulesDir(serverRoot);
+  const moduleDir = path.join(modulesDir, moduleName);
+
+  if (fs.existsSync(moduleDir)) {
+    console.error(chalk.red(`✖ Module already exists: ${moduleDir}`));
+    process.exit(1);
+  }
+
+  const vars = {
+    module_name: moduleName,
+    module_short: moduleShort,
+    PascalName,
+    description,
+    author,
+  };
+
+  const files = [
+    ['module/fxmanifest.lua.tpl',     'fxmanifest.lua'],
+    ['module/module.lua.tpl',         'module.lua'],
+    ['module/client/init.lua.tpl',    'client/boot.lua'],
+    ['module/server/init.lua.tpl',    'server/boot.lua'],
+    ['module/shared/init.lua.tpl',    `shared/sh_${moduleShort}.lua`],
+    ['module/config/config.lua.tpl',  'config/config.lua'],
+    ['module/locales/en.lua.tpl',     'locales/en.lua'],
+  ];
+
+  for (const [tpl, dest] of files) {
+    writeTemplate(tpl, path.join(moduleDir, dest), vars);
+  }
+
+  // Create empty directories with .gitkeep
+  const emptyDirs = ['migrations', 'tests'];
+  for (const dir of emptyDirs) {
+    const dirPath = path.join(moduleDir, dir);
+    fs.mkdirSync(dirPath, { recursive: true });
+    if (options.git !== false) {
+      fs.writeFileSync(path.join(dirPath, '.gitkeep'), '', 'utf-8');
+    }
+  }
+
+  console.log('');
+  console.log(chalk.green(`✔ Created module: ${chalk.bold(moduleName)}`));
+  console.log(chalk.gray(`  Path: ${path.relative(process.cwd(), moduleDir)}`));
+  console.log('');
+  console.log('  Files created:');
+  for (const [, dest] of files) {
+    console.log(chalk.gray(`    ${dest}`));
+  }
+  for (const dir of emptyDirs) {
+    console.log(chalk.gray(`    ${dir}/`));
+  }
+  console.log('');
+  console.log(chalk.bold('Next steps:'));
+  console.log(chalk.gray(`  shiva make:service ${PascalName}Service --module ${moduleName}`));
+  console.log(chalk.gray(`  shiva make:model ${PascalName} --module ${moduleName}`));
+  console.log(chalk.gray(`  shiva make:migration create_${rawName.replace(/-/g, '_')}_table --module ${moduleName}`));
+  console.log('');
+}
+
+module.exports = makeModuleCommand;

package/src/commands/make/seed.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+const { requireServerRoot, getShivaModulesDir } = require('../../utils/server-root');
+const { writeTemplate, toSnakeCase, normalizeModuleName } = require('../../generators/index');
+
+function makeSeedCommand(program) {
+  program
+    .command('make:seed <name>')
+    .description('Scaffold a database seeder inside a module')
+    .requiredOption('-m, --module <module>', 'Target module name')
+    .option('-t, --table <table>', 'Target database table name')
+    .action((name, options) => { run(name, options); });
+}
+
+function run(rawName, options) {
+  const seedName   = toSnakeCase(rawName).replace(/-/g, '_');
+  const moduleName = normalizeModuleName(options.module);
+  const tableName  = options.table || seedName;
+  const fileName   = `${seedName}.lua`;
+
+  const serverRoot = requireServerRoot();
+  const moduleDir  = path.join(getShivaModulesDir(serverRoot), moduleName);
+
+  if (!fs.existsSync(moduleDir)) {
+    console.error(chalk.red(`✖ Module not found: ${moduleName}`));
+    process.exit(1);
+  }
+
+  const seedsDir = path.join(moduleDir, 'seeds');
+  fs.mkdirSync(seedsDir, { recursive: true });
+
+  const destFile = path.join(seedsDir, fileName);
+  if (fs.existsSync(destFile)) {
+    console.error(chalk.red(`✖ Seed already exists: ${destFile}`));
+    process.exit(1);
+  }
+
+  writeTemplate('seed.lua.tpl', destFile, { table_name: tableName });
+
+  console.log('');
+  console.log(chalk.green(`✔ Created seed: ${chalk.bold(fileName)}`));
+  console.log(chalk.gray(`  Path: ${path.relative(process.cwd(), destFile)}`));
+  console.log(chalk.gray(`  Run:  shiva seed --module ${moduleName}`));
+  console.log('');
+}
+
+module.exports = makeSeedCommand;

package/src/commands/make/service.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+const { requireServerRoot, getShivaModulesDir } = require('../../utils/server-root');
+const { writeTemplate, toPascalCase, normalizeModuleName } = require('../../generators/index');
+
+/**
+ * Register the `shiva make:service` command.
+ * @param {import('commander').Command} program
+ */
+function makeServiceCommand(program) {
+  program
+    .command('make:service <name>')
+    .description('Scaffold a new service inside a module')
+    .requiredOption('-m, --module <module>', 'Target module name')
+    .action((name, options) => {
+      run(name, options);
+    });
+}
+
+function run(rawName, options) {
+  const ServiceName = toPascalCase(rawName);
+  const moduleName = normalizeModuleName(options.module);
+
+  const serverRoot = requireServerRoot();
+  const modulesDir = getShivaModulesDir(serverRoot);
+  const moduleDir = path.join(modulesDir, moduleName);
+
+  if (!fs.existsSync(moduleDir)) {
+    console.error(chalk.red(`✖ Module not found: ${moduleName}`));
+    console.error(chalk.gray(`  Expected path: ${moduleDir}`));
+    console.error(chalk.gray(`  Run \`shiva make:module ${moduleName}\` first.`));
+    process.exit(1);
+  }
+
+  const destDir = path.join(moduleDir, 'server', 'services');
+  const destFile = path.join(destDir, `${ServiceName}.lua`);
+
+  if (fs.existsSync(destFile)) {
+    console.error(chalk.red(`✖ Service already exists: ${destFile}`));
+    process.exit(1);
+  }
+
+  const vars = {
+    ServiceName,
+    module_name: moduleName,
+  };
+
+  writeTemplate('service.lua.tpl', destFile, vars);
+
+  console.log('');
+  console.log(chalk.green(`✔ Created service: ${chalk.bold(ServiceName)}`));
+  console.log(chalk.gray(`  Path: ${path.relative(process.cwd(), destFile)}`));
+  console.log('');
+}
+
+module.exports = makeServiceCommand;

package/src/commands/make/test.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+const { requireServerRoot, getShivaModulesDir } = require('../../utils/server-root');
+const { writeTemplate, toPascalCase, toSnakeCase, normalizeModuleName } = require('../../generators/index');
+
+function makeTestCommand(program) {
+  program
+    .command('make:test <name>')
+    .description('Scaffold a test spec file inside a module')
+    .requiredOption('-m, --module <module>', 'Target module name')
+    .action((name, options) => { run(name, options); });
+}
+
+function run(rawName, options) {
+  const moduleName   = normalizeModuleName(options.module);
+  const moduleShort  = moduleName.replace(/^shiva-/, '');
+  const testName     = toSnakeCase(rawName).replace(/-/g, '_');
+  const describeName = toPascalCase(rawName);
+
+  const serverRoot = requireServerRoot();
+  const modulesDir = getShivaModulesDir(serverRoot);
+  const moduleDir  = path.join(modulesDir, moduleName);
+
+  if (!fs.existsSync(moduleDir)) {
+    console.error(chalk.red(`✖ Module not found: ${moduleName}`));
+    process.exit(1);
+  }
+
+  const destFile = path.join(moduleDir, 'tests', `${testName}_spec.lua`);
+  if (fs.existsSync(destFile)) {
+    console.error(chalk.red(`✖ Test already exists: ${destFile}`));
+    process.exit(1);
+  }
+
+  writeTemplate('test.lua.tpl', destFile, {
+    test_name:     testName,
+    describe_name: describeName,
+    module_name:   moduleName,
+    module_short:  moduleShort,
+  });
+
+  console.log('');
+  console.log(chalk.green(`✔ Created test: ${chalk.bold(testName + '_spec.lua')}`));
+  console.log(chalk.gray(`  Path: ${path.relative(process.cwd(), destFile)}`));
+  console.log(chalk.gray(`  Run:  shiva test --module ${moduleName}`));
+  console.log('');
+}
+
+module.exports = makeTestCommand;

package/src/commands/mcp.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const chalk = require('chalk');
+
+function mcpCommand(program) {
+  const mcp = program
+    .command('mcp')
+    .description('MCP server commands');
+
+  mcp
+    .command('start')
+    .description('Start the Shiva MCP server (stdio transport)')
+    .option('-p, --port <port>', 'Port (reserved for future HTTP transport)', '3100')
+    .action(async (options) => {
+      const { startMcpServer } = require('../mcp/server');
+      process.stderr.write(chalk.cyan('Shiva MCP server starting on stdio...\n'));
+      try {
+        await startMcpServer(options);
+      } catch (err) {
+        process.stderr.write(chalk.red(`MCP server error: ${err.message}\n`));
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = mcpCommand;

package/src/commands/migrate/rollback.js

@@ -0,0 +1,155 @@
+'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:rollback` command.
+ * @param {import('commander').Command} program
+ */
+function migrateRollbackCommand(program) {
+  program
+    .command('migrate:rollback')
+    .description('Roll back the last migration batch')
+    .option('-s, --steps <n>', 'Number of batches to roll back', '1')
+    .option('--dry-run', 'Show what would roll back without executing')
+    .action(async (options) => {
+      await run(options);
+    });
+}
+
+async function run(options) {
+  const serverRoot = requireServerRoot();
+  const dbConfig = getDatabaseConfig(serverRoot);
+  const steps = Math.max(1, parseInt(options.steps, 10) || 1);
+
+  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 tableExists = await checkTableExists(connection, dbConfig.database);
+    if (!tableExists) {
+      console.log(chalk.gray('  No migrations table found. Nothing to roll back.'));
+      return;
+    }
+
+    const [batchRows] = await connection.execute(
+      `SELECT MAX(\`batch\`) AS max_batch FROM \`${MIGRATIONS_TABLE}\``
+    );
+    const maxBatch = batchRows[0].max_batch;
+
+    if (!maxBatch) {
+      console.log(chalk.gray('  Nothing to roll back.'));
+      return;
+    }
+
+    const minBatch = Math.max(1, maxBatch - steps + 1);
+    const [rows] = await connection.execute(
+      `SELECT \`migration\` FROM \`${MIGRATIONS_TABLE}\` WHERE \`batch\` >= ? ORDER BY \`id\` DESC`,
+      [minBatch]
+    );
+
+    if (rows.length === 0) {
+      console.log(chalk.gray('  Nothing to roll back.'));
+      return;
+    }
+
+    const resourcesDir = path.join(serverRoot, 'resources');
+    const modules = scanModules(resourcesDir);
+    const migrationMap = buildMigrationMap(modules);
+
+    console.log('');
+    console.log(chalk.bold(`Rolling back ${rows.length} migration(s) (${steps} batch(es))...\n`));
+
+    for (const row of rows) {
+      const migName = row.migration;
+
+      if (options.dryRun) {
+        console.log(chalk.yellow(`  [dry-run] rollback: ${migName}`));
+        continue;
+      }
+
+      process.stdout.write(chalk.gray(`  Rolling back: ${migName} ...`));
+
+      const filePath = migrationMap[migName];
+      if (!filePath || !fs.existsSync(filePath)) {
+        console.log(chalk.yellow(' skipped (file not found)'));
+        continue;
+      }
+
+      try {
+        const mod = require(filePath);
+        if (typeof mod.down === 'function') {
+          await mod.down({ execute: (sql) => connection.execute(sql) });
+        }
+        await connection.execute(
+          `DELETE FROM \`${MIGRATIONS_TABLE}\` WHERE \`migration\` = ?`,
+          [migName]
+        );
+        console.log(chalk.green(' done'));
+      } catch (err) {
+        console.log(chalk.red(' failed'));
+        console.error(chalk.red(`    Error: ${err.message}`));
+        break;
+      }
+    }
+
+    if (!options.dryRun) {
+      console.log('');
+      console.log(chalk.green(`✔ Rolled back ${steps} batch(es).`));
+    }
+
+  } 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 buildMigrationMap(modules) {
+  const map = {};
+  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'));
+    for (const file of files) {
+      const key = `${mod.name}/${file.replace('.lua', '')}`;
+      map[key] = path.join(migrationsDir, file);
+    }
+  }
+  return map;
+}
+
+module.exports = migrateRollbackCommand;

package/src/commands/migrate/run.js

@@ -0,0 +1,159 @@
+'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` command.
+ * @param {import('commander').Command} program
+ */
+function migrateRunCommand(program) {
+  program
+    .command('migrate')
+    .description('Run all pending database migrations')
+    .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'));
+    console.error(chalk.gray('  Add a "database" section to shiva.json with host, port, user, password, database.'));
+    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 {
+    await ensureMigrationsTable(connection);
+
+    const resourcesDir = path.join(serverRoot, 'resources');
+    const modules = scanModules(resourcesDir);
+    const allMigrations = collectMigrations(modules);
+
+    if (allMigrations.length === 0) {
+      console.log(chalk.gray('  No migration files found.'));
+      return;
+    }
+
+    const ran = await getRanMigrations(connection);
+    const pending = allMigrations.filter(m => !ran.has(m.name));
+
+    if (pending.length === 0) {
+      console.log(chalk.green('✔ Nothing to migrate — all up to date.'));
+      return;
+    }
+
+    console.log('');
+    console.log(chalk.bold(`Running ${pending.length} migration(s)...\n`));
+
+    const batch = await getNextBatch(connection);
+
+    for (const migration of pending) {
+      if (options.dryRun) {
+        console.log(chalk.yellow(`  [dry-run] ${migration.name}`));
+        continue;
+      }
+
+      process.stdout.write(chalk.gray(`  Migrating: ${migration.name} ...`));
+
+      try {
+        const mod = require(migration.path);
+        await mod.up({ execute: (sql) => connection.execute(sql) });
+        await recordMigration(connection, migration.name, batch);
+        console.log(chalk.green(' done'));
+      } catch (err) {
+        console.log(chalk.red(' failed'));
+        console.error(chalk.red(`    Error: ${err.message}`));
+        console.error(chalk.yellow('  Migration stopped. Fix the error and re-run.'));
+        break;
+      }
+    }
+
+    if (!options.dryRun) {
+      console.log('');
+      console.log(chalk.green(`✔ Batch ${batch} complete.`));
+    }
+
+  } finally {
+    await connection.end();
+  }
+}
+
+async function ensureMigrationsTable(conn) {
+  await conn.execute(`
+    CREATE TABLE IF NOT EXISTS \`${MIGRATIONS_TABLE}\` (
+      \`id\`         INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+      \`migration\`  VARCHAR(255) NOT NULL UNIQUE,
+      \`batch\`      INT UNSIGNED NOT NULL DEFAULT 1,
+      \`ran_at\`     TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci
+  `);
+}
+
+async function getRanMigrations(conn) {
+  const [rows] = await conn.execute(`SELECT \`migration\` FROM \`${MIGRATIONS_TABLE}\``);
+  return new Set(rows.map(r => r.migration));
+}
+
+async function getNextBatch(conn) {
+  const [rows] = await conn.execute(`SELECT COALESCE(MAX(\`batch\`), 0) + 1 AS next_batch FROM \`${MIGRATIONS_TABLE}\``);
+  return rows[0].next_batch;
+}
+
+async function recordMigration(conn, name, batch) {
+  await conn.execute(
+    `INSERT INTO \`${MIGRATIONS_TABLE}\` (\`migration\`, \`batch\`) VALUES (?, ?)`,
+    [name, batch]
+  );
+}
+
+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', '')}`,
+        path: path.join(migrationsDir, file),
+        module: mod.name,
+      });
+    }
+  }
+
+  return migrations.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+module.exports = migrateRunCommand;