servcraft 0.1.7 → 0.3.1

package/src/cli/commands/list.ts

@@ -0,0 +1,274 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import { getProjectRoot, getModulesDir } from '../utils/helpers.js';
+
+// Pre-built modules that can be added
+const AVAILABLE_MODULES: Record<string, { name: string; description: string; category: string }> = {
+  // Core
+  auth: {
+    name: 'Authentication',
+    description: 'JWT authentication with access/refresh tokens',
+    category: 'Core',
+  },
+  users: {
+    name: 'User Management',
+    description: 'User CRUD with RBAC (roles & permissions)',
+    category: 'Core',
+  },
+  email: {
+    name: 'Email Service',
+    description: 'SMTP email with templates (Handlebars)',
+    category: 'Core',
+  },
+
+  // Security
+  mfa: {
+    name: 'MFA/TOTP',
+    description: 'Two-factor authentication with QR codes',
+    category: 'Security',
+  },
+  oauth: {
+    name: 'OAuth',
+    description: 'Social login (Google, GitHub, Facebook, Twitter, Apple)',
+    category: 'Security',
+  },
+  'rate-limit': {
+    name: 'Rate Limiting',
+    description: 'Advanced rate limiting with multiple algorithms',
+    category: 'Security',
+  },
+
+  // Data & Storage
+  cache: {
+    name: 'Redis Cache',
+    description: 'Redis caching with TTL & invalidation',
+    category: 'Data & Storage',
+  },
+  upload: {
+    name: 'File Upload',
+    description: 'File upload with local/S3/Cloudinary storage',
+    category: 'Data & Storage',
+  },
+  search: {
+    name: 'Search',
+    description: 'Full-text search with Elasticsearch/Meilisearch',
+    category: 'Data & Storage',
+  },
+
+  // Communication
+  notification: {
+    name: 'Notifications',
+    description: 'Email, SMS, Push notifications',
+    category: 'Communication',
+  },
+  webhook: {
+    name: 'Webhooks',
+    description: 'Outgoing webhooks with HMAC signatures & retry',
+    category: 'Communication',
+  },
+  websocket: {
+    name: 'WebSockets',
+    description: 'Real-time communication with Socket.io',
+    category: 'Communication',
+  },
+
+  // Background Processing
+  queue: {
+    name: 'Queue/Jobs',
+    description: 'Background jobs with Bull/BullMQ & cron scheduling',
+    category: 'Background Processing',
+  },
+  'media-processing': {
+    name: 'Media Processing',
+    description: 'Image/video processing with FFmpeg',
+    category: 'Background Processing',
+  },
+
+  // Monitoring & Analytics
+  audit: {
+    name: 'Audit Logs',
+    description: 'Activity logging and audit trail',
+    category: 'Monitoring & Analytics',
+  },
+  analytics: {
+    name: 'Analytics/Metrics',
+    description: 'Prometheus metrics & event tracking',
+    category: 'Monitoring & Analytics',
+  },
+
+  // Internationalization
+  i18n: {
+    name: 'i18n/Localization',
+    description: 'Multi-language support with 7+ locales',
+    category: 'Internationalization',
+  },
+
+  // API Management
+  'feature-flag': {
+    name: 'Feature Flags',
+    description: 'A/B testing & progressive rollout',
+    category: 'API Management',
+  },
+  'api-versioning': {
+    name: 'API Versioning',
+    description: 'Multiple API versions support',
+    category: 'API Management',
+  },
+
+  // Payments
+  payment: {
+    name: 'Payments',
+    description: 'Payment processing (Stripe, PayPal, Mobile Money)',
+    category: 'Payments',
+  },
+};
+
+async function getInstalledModules(): Promise<string[]> {
+  try {
+    const modulesDir = getModulesDir();
+    const entries = await fs.readdir(modulesDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+function isServercraftProject(): boolean {
+  try {
+    getProjectRoot();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export const listCommand = new Command('list')
+  .alias('ls')
+  .description('List available and installed modules')
+  .option('-a, --available', 'Show only available modules')
+  .option('-i, --installed', 'Show only installed modules')
+  .option('-c, --category <category>', 'Filter by category')
+  .option('--json', 'Output as JSON')
+  .action(
+    async (options: {
+      available?: boolean;
+      installed?: boolean;
+      category?: string;
+      json?: boolean;
+    }) => {
+      const installedModules = await getInstalledModules();
+      const isProject = isServercraftProject();
+
+      if (options.json) {
+        const output: Record<string, unknown> = {
+          available: Object.entries(AVAILABLE_MODULES).map(([key, mod]) => ({
+            id: key,
+            ...mod,
+            installed: installedModules.includes(key),
+          })),
+        };
+
+        if (isProject) {
+          output.installed = installedModules;
+        }
+
+        console.log(JSON.stringify(output, null, 2));
+        return;
+      }
+
+      // Group modules by category
+      const byCategory: Record<
+        string,
+        Array<{ id: string; name: string; description: string; installed: boolean }>
+      > = {};
+
+      for (const [key, mod] of Object.entries(AVAILABLE_MODULES)) {
+        if (options.category && mod.category.toLowerCase() !== options.category.toLowerCase()) {
+          continue;
+        }
+
+        if (!byCategory[mod.category]) {
+          byCategory[mod.category] = [];
+        }
+
+        byCategory[mod.category]?.push({
+          id: key,
+          name: mod.name,
+          description: mod.description,
+          installed: installedModules.includes(key),
+        });
+      }
+
+      // Show installed modules only
+      if (options.installed) {
+        if (!isProject) {
+          console.log(chalk.yellow('\n⚠ Not in a Servcraft project directory\n'));
+          return;
+        }
+
+        console.log(chalk.bold('\n📦 Installed Modules:\n'));
+
+        if (installedModules.length === 0) {
+          console.log(chalk.gray('  No modules installed yet.\n'));
+          console.log(`  Run ${chalk.cyan('servcraft add <module>')} to add a module.\n`);
+          return;
+        }
+
+        for (const modId of installedModules) {
+          const mod = AVAILABLE_MODULES[modId];
+          if (mod) {
+            console.log(`  ${chalk.green('✓')} ${chalk.cyan(modId.padEnd(18))} ${mod.name}`);
+          } else {
+            console.log(
+              `  ${chalk.green('✓')} ${chalk.cyan(modId.padEnd(18))} ${chalk.gray('(custom module)')}`
+            );
+          }
+        }
+
+        console.log(`\n  Total: ${chalk.bold(installedModules.length)} module(s) installed\n`);
+        return;
+      }
+
+      // Show available modules (default or --available)
+      console.log(chalk.bold('\n📦 Available Modules\n'));
+
+      if (isProject) {
+        console.log(
+          chalk.gray(`  ${chalk.green('✓')} = installed    ${chalk.dim('○')} = not installed\n`)
+        );
+      }
+
+      for (const [category, modules] of Object.entries(byCategory)) {
+        console.log(chalk.bold.blue(`  ${category}`));
+        console.log(chalk.gray('  ' + '─'.repeat(40)));
+
+        for (const mod of modules) {
+          const status = isProject ? (mod.installed ? chalk.green('✓') : chalk.dim('○')) : ' ';
+          const nameColor = mod.installed ? chalk.green : chalk.cyan;
+          console.log(`  ${status} ${nameColor(mod.id.padEnd(18))} ${mod.name}`);
+          console.log(`    ${chalk.gray(mod.description)}`);
+        }
+        console.log();
+      }
+
+      // Summary
+      const totalAvailable = Object.keys(AVAILABLE_MODULES).length;
+      const totalInstalled = installedModules.filter((m) => AVAILABLE_MODULES[m]).length;
+
+      console.log(chalk.gray('─'.repeat(50)));
+      console.log(
+        `  ${chalk.bold(totalAvailable)} modules available` +
+          (isProject ? ` | ${chalk.green.bold(totalInstalled)} installed` : '')
+      );
+      console.log();
+
+      // Usage hints
+      console.log(chalk.bold('  Usage:'));
+      console.log(`    ${chalk.yellow('servcraft add <module>')}      Add a module`);
+      console.log(`    ${chalk.yellow('servcraft list --installed')}  Show installed only`);
+      console.log(`    ${chalk.yellow('servcraft list --category Security')}  Filter by category`);
+      console.log();
+    }
+  );

package/src/cli/commands/remove.ts

@@ -0,0 +1,102 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import path from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import inquirer from 'inquirer';
+import { getModulesDir, success, error, info } from '../utils/helpers.js';
+import { ServCraftError, displayError, validateProject } from '../utils/error-handler.js';
+
+export const removeCommand = new Command('remove')
+  .alias('rm')
+  .description('Remove an installed module from your project')
+  .argument('<module>', 'Module to remove')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .option('--keep-env', 'Keep environment variables')
+  .action(async (moduleName: string, options?: { yes?: boolean; keepEnv?: boolean }) => {
+    // Validate project
+    const projectError = validateProject();
+    if (projectError) {
+      displayError(projectError);
+      return;
+    }
+
+    console.log(chalk.bold.cyan('\n🗑️  ServCraft Module Removal\n'));
+
+    const moduleDir = path.join(getModulesDir(), moduleName);
+
+    try {
+      // Check if module exists
+      const exists = await fs
+        .access(moduleDir)
+        .then(() => true)
+        .catch(() => false);
+
+      if (!exists) {
+        displayError(
+          new ServCraftError(`Module "${moduleName}" is not installed`, [
+            `Run ${chalk.cyan('servcraft list --installed')} to see installed modules`,
+            `Check the spelling of the module name`,
+          ])
+        );
+        return;
+      }
+
+      // Get list of files
+      const files = await fs.readdir(moduleDir);
+      const fileCount = files.length;
+
+      // Confirm removal
+      if (!options?.yes) {
+        console.log(chalk.yellow(`⚠  This will remove the "${moduleName}" module:`));
+        console.log(chalk.gray(`   Directory: ${moduleDir}`));
+        console.log(chalk.gray(`   Files: ${fileCount} file(s)`));
+        console.log();
+
+        const { confirm } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Are you sure you want to remove this module?',
+            default: false,
+          },
+        ]);
+
+        if (!confirm) {
+          console.log(chalk.yellow('\n✖ Removal cancelled\n'));
+          return;
+        }
+      }
+
+      const spinner = ora('Removing module...').start();
+
+      // Remove module directory
+      await fs.rm(moduleDir, { recursive: true, force: true });
+
+      spinner.succeed(`Module "${moduleName}" removed successfully!`);
+
+      // Show what was removed
+      console.log('\n' + chalk.bold('✓ Removed:'));
+      success(`  src/modules/${moduleName}/ (${fileCount} files)`);
+
+      // Instructions for cleanup
+      if (!options?.keepEnv) {
+        console.log('\n' + chalk.bold('📌 Manual cleanup needed:'));
+        info('  1. Remove environment variables related to this module from .env');
+        info('  2. Remove module imports from your main app file');
+        info('  3. Remove related database migrations if any');
+        info('  4. Update your routes if they reference this module');
+      } else {
+        console.log('\n' + chalk.bold('📌 Manual cleanup needed:'));
+        info('  1. Environment variables were kept (--keep-env flag)');
+        info('  2. Remove module imports from your main app file');
+        info('  3. Update your routes if they reference this module');
+      }
+
+      console.log();
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      console.log();
+    }
+  });

package/src/cli/commands/update.ts

@@ -0,0 +1,221 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import inquirer from 'inquirer';
+import { getProjectRoot, getModulesDir } from '../utils/helpers.js';
+import { validateProject, displayError } from '../utils/error-handler.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Get list of available modules (same as list.ts)
+const AVAILABLE_MODULES = [
+  'auth',
+  'users',
+  'email',
+  'mfa',
+  'oauth',
+  'rate-limit',
+  'cache',
+  'upload',
+  'search',
+  'notification',
+  'webhook',
+  'websocket',
+  'queue',
+  'payment',
+  'i18n',
+  'feature-flag',
+  'analytics',
+  'media-processing',
+  'api-versioning',
+  'audit',
+  'swagger',
+  'validation',
+];
+
+async function getInstalledModules(): Promise<string[]> {
+  try {
+    const modulesDir = getModulesDir();
+
+    const entries = await fs.readdir(modulesDir, { withFileTypes: true });
+    const installedModules = entries
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .filter((name) => AVAILABLE_MODULES.includes(name));
+
+    return installedModules;
+  } catch {
+    return [];
+  }
+}
+
+async function copyModuleFiles(moduleName: string, _projectRoot: string): Promise<void> {
+  const cliRoot = path.resolve(__dirname, '../../../');
+  const sourceModulePath = path.join(cliRoot, 'src', 'modules', moduleName);
+  const targetModulesDir = getModulesDir();
+  const targetModulePath = path.join(targetModulesDir, moduleName);
+
+  // Check if source module exists
+  try {
+    await fs.access(sourceModulePath);
+  } catch {
+    throw new Error(`Module source not found: ${moduleName}`);
+  }
+
+  // Copy module files
+  await fs.cp(sourceModulePath, targetModulePath, { recursive: true });
+}
+
+async function updateModule(moduleName: string, options: { check?: boolean }): Promise<void> {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+
+  const projectRoot = getProjectRoot();
+  const installedModules = await getInstalledModules();
+
+  if (!installedModules.includes(moduleName)) {
+    console.log(chalk.yellow(`\n⚠ Module "${moduleName}" is not installed\n`));
+    console.log(
+      chalk.gray(`Run ${chalk.cyan(`servcraft add ${moduleName}`)} to install it first.\n`)
+    );
+    return;
+  }
+
+  if (options.check) {
+    console.log(chalk.cyan(`\n📦 Checking updates for "${moduleName}"...\n`));
+    console.log(chalk.gray('Note: Version tracking will be implemented in a future release.'));
+    console.log(chalk.gray('Currently, update will always reinstall the latest version.\n'));
+    return;
+  }
+
+  // Confirm update
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message: `Update "${moduleName}" module? This will overwrite existing files.`,
+      default: false,
+    },
+  ]);
+
+  if (!confirmed) {
+    console.log(chalk.yellow('\n⚠ Update cancelled\n'));
+    return;
+  }
+
+  console.log(chalk.cyan(`\n🔄 Updating "${moduleName}" module...\n`));
+
+  try {
+    await copyModuleFiles(moduleName, projectRoot);
+    console.log(chalk.green(`✔ Module "${moduleName}" updated successfully!\n`));
+    console.log(
+      chalk.gray('Note: Remember to review any breaking changes in the documentation.\n')
+    );
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk.red(`\n✗ Failed to update module: ${error.message}\n`));
+    }
+  }
+}
+
+async function updateAllModules(options: { check?: boolean }): Promise<void> {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+
+  const installedModules = await getInstalledModules();
+
+  if (installedModules.length === 0) {
+    console.log(chalk.yellow('\n⚠ No modules installed\n'));
+    console.log(chalk.gray(`Run ${chalk.cyan('servcraft list')} to see available modules.\n`));
+    return;
+  }
+
+  if (options.check) {
+    console.log(chalk.cyan('\n📦 Checking updates for all modules...\n'));
+    console.log(chalk.bold('Installed modules:'));
+    installedModules.forEach((mod) => {
+      console.log(`  • ${chalk.cyan(mod)}`);
+    });
+    console.log();
+    console.log(chalk.gray('Note: Version tracking will be implemented in a future release.'));
+    console.log(chalk.gray('Currently, update will always reinstall the latest version.\n'));
+    return;
+  }
+
+  console.log(chalk.cyan(`\n📦 Found ${installedModules.length} installed module(s):\n`));
+  installedModules.forEach((mod) => {
+    console.log(`  • ${chalk.cyan(mod)}`);
+  });
+  console.log();
+
+  // Confirm update all
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message: 'Update all modules? This will overwrite existing files.',
+      default: false,
+    },
+  ]);
+
+  if (!confirmed) {
+    console.log(chalk.yellow('\n⚠ Update cancelled\n'));
+    return;
+  }
+
+  console.log(chalk.cyan('\n🔄 Updating all modules...\n'));
+
+  const projectRoot = getProjectRoot();
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const moduleName of installedModules) {
+    try {
+      await copyModuleFiles(moduleName, projectRoot);
+      console.log(chalk.green(`✔ Updated: ${moduleName}`));
+      successCount++;
+    } catch {
+      console.error(chalk.red(`✗ Failed: ${moduleName}`));
+      failCount++;
+    }
+  }
+
+  console.log();
+  console.log(
+    chalk.bold(
+      `\n✔ Update complete: ${chalk.green(successCount)} succeeded, ${chalk.red(failCount)} failed\n`
+    )
+  );
+
+  if (successCount > 0) {
+    console.log(
+      chalk.gray('Note: Remember to review any breaking changes in the documentation.\n')
+    );
+  }
+}
+
+export const updateCommand = new Command('update')
+  .description('Update installed modules to latest version')
+  .argument('[module]', 'Specific module to update')
+  .option('--check', 'Check for updates without applying')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(async (moduleName?: string, options?: { check?: boolean; yes?: boolean }) => {
+    // If --yes flag is provided, we'll handle it by auto-confirming in the inquirer prompts
+    // For now, we'll just pass through to the update functions
+
+    if (moduleName) {
+      await updateModule(moduleName, { check: options?.check });
+    } else {
+      await updateAllModules({ check: options?.check });
+    }
+  });

package/src/cli/index.ts

@@ -6,6 +6,11 @@ import { generateCommand } from './commands/generate.js';
 import { addModuleCommand } from './commands/add-module.js';
 import { dbCommand } from './commands/db.js';
 import { docsCommand } from './commands/docs.js';
+import { listCommand } from './commands/list.js';
+import { removeCommand } from './commands/remove.js';
+import { doctorCommand } from './commands/doctor.js';
+import { updateCommand } from './commands/update.js';
+import { completionCommand } from './commands/completion.js';
 
 const program = new Command();
 
@@ -29,4 +34,19 @@ program.addCommand(dbCommand);
 // Documentation commands
 program.addCommand(docsCommand);
 
+// List modules
+program.addCommand(listCommand);
+
+// Remove module
+program.addCommand(removeCommand);
+
+// Diagnose project
+program.addCommand(doctorCommand);
+
+// Update modules
+program.addCommand(updateCommand);
+
+// Shell completion
+program.addCommand(completionCommand);
+
 program.parse();