@engjts/nexus 0.1.0

package/src/cli/cli.ts

@@ -0,0 +1,155 @@
+import { CreateCommand } from './commands/create';
+import { InitCommand } from './commands/init';
+import { GenerateCommand } from './commands/generate';
+import { DevCommand } from './commands/dev';
+import { BuildCommand } from './commands/build';
+import { HelpCommand } from './commands/help';
+import { VersionCommand } from './commands/version';
+import { Logger } from './utils/logger';
+
+export interface Command {
+  name: string;
+  description: string;
+  usage: string;
+  options?: CommandOption[];
+  execute(args: string[], options: Record<string, string | boolean>): Promise<void>;
+}
+
+export interface CommandOption {
+  name: string;
+  alias?: string;
+  description: string;
+  required?: boolean;
+  defaultValue?: string | boolean;
+}
+
+export class CLI {
+  private commands: Map<string, Command> = new Map();
+  private logger = new Logger();
+
+  constructor() {
+    this.registerCommands();
+  }
+
+  private registerCommands(): void {
+    const commands: Command[] = [
+      new CreateCommand(),
+      new InitCommand(),
+      new GenerateCommand(),
+      new DevCommand(),
+      new BuildCommand(),
+      new HelpCommand(() => this.commands),
+      new VersionCommand(),
+    ];
+
+    for (const command of commands) {
+      this.commands.set(command.name, command);
+    }
+  }
+
+  async run(args: string[]): Promise<void> {
+    if (args.length === 0) {
+      this.showWelcome();
+      return;
+    }
+
+    const [commandName, ...rest] = args;
+
+    // Handle global flags
+    if (commandName === '--help' || commandName === '-h') {
+      const helpCommand = this.commands.get('help');
+      await helpCommand?.execute([], {});
+      return;
+    }
+
+    if (commandName === '--version' || commandName === '-v') {
+      const versionCommand = this.commands.get('version');
+      await versionCommand?.execute([], {});
+      return;
+    }
+
+    const command = this.commands.get(commandName);
+    if (!command) {
+      this.logger.error(`Unknown command: ${commandName}`);
+      this.logger.info('Run "nexus --help" for available commands');
+      process.exit(1);
+    }
+
+    const { positionalArgs, options } = this.parseArgs(rest);
+
+    try {
+      await command.execute(positionalArgs, options);
+    } catch (error) {
+      if (error instanceof Error) {
+        this.logger.error(error.message);
+      }
+      process.exit(1);
+    }
+  }
+
+  private parseArgs(args: string[]): {
+    positionalArgs: string[];
+    options: Record<string, string | boolean>;
+  } {
+    const positionalArgs: string[] = [];
+    const options: Record<string, string | boolean> = {};
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+
+      if (arg.startsWith('--')) {
+        const [key, value] = arg.slice(2).split('=');
+        if (value !== undefined) {
+          options[key] = value;
+        } else if (args[i + 1] && !args[i + 1].startsWith('-')) {
+          options[key] = args[++i];
+        } else {
+          options[key] = true;
+        }
+      } else if (arg.startsWith('-')) {
+        const key = arg.slice(1);
+        if (args[i + 1] && !args[i + 1].startsWith('-')) {
+          options[key] = args[++i];
+        } else {
+          options[key] = true;
+        }
+      } else {
+        positionalArgs.push(arg);
+      }
+    }
+
+    return { positionalArgs, options };
+  }
+
+  private showWelcome(): void {
+    console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   ███╗   ██╗███████╗██╗  ██╗██╗   ██╗███████╗             ║
+║   ████╗  ██║██╔════╝╚██╗██╔╝██║   ██║██╔════╝             ║
+║   ██╔██╗ ██║█████╗   ╚███╔╝ ██║   ██║███████╗             ║
+║   ██║╚██╗██║██╔══╝   ██╔██╗ ██║   ██║╚════██║             ║
+║   ██║ ╚████║███████╗██╔╝ ██╗╚██████╔╝███████║             ║
+║   ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝             ║
+║                                                           ║
+║   Async-First Web Framework with Type-Safety              ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+
+  ${this.logger.colors.cyan}Usage:${this.logger.colors.reset} nexus <command> [options]
+
+  ${this.logger.colors.cyan}Commands:${this.logger.colors.reset}
+    create <name>     Create a new Nexus project
+    init              Initialize Nexus in current directory
+    generate <type>   Generate components (route, middleware, etc.)
+    dev               Start development server
+    build             Build for production
+
+  ${this.logger.colors.cyan}Options:${this.logger.colors.reset}
+    --help, -h        Show help
+    --version, -v     Show version
+
+  Run ${this.logger.colors.green}nexus <command> --help${this.logger.colors.reset} for more information on a command.
+`);
+  }
+}

package/src/cli/commands/build.ts

@@ -0,0 +1,73 @@
+import { Command } from '../cli';
+import { Logger } from '../utils/logger';
+import { FileSystem } from '../utils/file-system';
+import { spawnCommand } from '../utils/exec';
+
+export class BuildCommand implements Command {
+  name = 'build';
+  description = 'Build the project for production';
+  usage = 'nexus build [options]';
+  options = [
+    {
+      name: 'outDir',
+      alias: 'o',
+      description: 'Output directory',
+      defaultValue: 'dist',
+    },
+    {
+      name: 'minify',
+      description: 'Minify the output',
+      defaultValue: false,
+    },
+  ];
+
+  private logger = new Logger();
+
+  async execute(
+    args: string[],
+    options: Record<string, string | boolean>
+  ): Promise<void> {
+    const outDir = (options.outDir || options.o || 'dist') as string;
+
+    // Check if we're in a Nexus project
+    const packageJsonPath = FileSystem.joinPath(process.cwd(), 'package.json');
+    if (!(await FileSystem.exists(packageJsonPath))) {
+      this.logger.error('No package.json found. Are you in a Nexus project?');
+      return;
+    }
+
+    this.logger.header('Building Nexus Project');
+
+    // Check for tsconfig.json
+    const tsconfigPath = FileSystem.joinPath(process.cwd(), 'tsconfig.json');
+    if (!(await FileSystem.exists(tsconfigPath))) {
+      this.logger.warning('No tsconfig.json found, using default configuration');
+    }
+
+    // Clean output directory
+    this.logger.step(1, 3, 'Cleaning output directory...');
+    const outputPath = FileSystem.joinPath(process.cwd(), outDir);
+    await FileSystem.removeDirectory(outputPath);
+    this.logger.success(`Cleaned ${outDir}`);
+
+    // Run TypeScript compiler
+    this.logger.step(2, 3, 'Compiling TypeScript...');
+    const exitCode = await spawnCommand('npx', ['tsc', '--outDir', outDir], {
+      cwd: process.cwd(),
+    });
+
+    if (exitCode !== 0) {
+      this.logger.error('Build failed');
+      return;
+    }
+    this.logger.success('TypeScript compiled');
+
+    // Done
+    this.logger.step(3, 3, 'Finalizing...');
+    this.logger.success('Build completed!');
+
+    this.logger.blank();
+    this.logger.info(`Output directory: ${outDir}`);
+    this.logger.info('Run "npm start" or "node dist/index.js" to start the server');
+  }
+}

package/src/cli/commands/create.ts

@@ -0,0 +1,166 @@
+import { Command, CommandOption } from '../cli';
+import { Logger } from '../utils/logger';
+import { FileSystem } from '../utils/file-system';
+import { spawnCommand, checkCommandExists } from '../utils/exec';
+import { ProjectTemplates } from '../templates';
+
+export class CreateCommand implements Command {
+  name = 'create';
+  description = 'Create a new Nexus project';
+  usage = 'nexus create <project-name> [options]';
+  options: CommandOption[] = [
+    {
+      name: 'template',
+      alias: 't',
+      description: 'Project template (basic, api, fullstack)',
+      defaultValue: 'basic',
+    },
+    {
+      name: 'package-manager',
+      alias: 'pm',
+      description: 'Package manager to use (npm, yarn, pnpm, bun)',
+      defaultValue: 'npm',
+    },
+    {
+      name: 'skip-install',
+      description: 'Skip dependency installation',
+      defaultValue: false,
+    },
+    {
+      name: 'skip-git',
+      description: 'Skip git initialization',
+      defaultValue: false,
+    },
+  ];
+
+  private logger = new Logger();
+
+  async execute(
+    args: string[],
+    options: Record<string, string | boolean>
+  ): Promise<void> {
+    if (args.length === 0) {
+      this.logger.error('Project name is required');
+      this.logger.info('Usage: nexus create <project-name>');
+      return;
+    }
+
+    const projectName = args[0];
+    const template = (options.template || options.t || 'basic') as string;
+    const packageManager = (options['package-manager'] || options.pm || 'npm') as string;
+    const skipInstall = options['skip-install'] === true;
+    const skipGit = options['skip-git'] === true;
+
+    // Validate project name
+    if (!/^[a-z0-9-_]+$/i.test(projectName)) {
+      this.logger.error('Project name can only contain letters, numbers, hyphens, and underscores');
+      return;
+    }
+
+    const projectPath = FileSystem.resolvePath(process.cwd(), projectName);
+
+    // Check if directory already exists
+    if (await FileSystem.exists(projectPath)) {
+      this.logger.error(`Directory "${projectName}" already exists`);
+      return;
+    }
+
+    console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   Creating new Nexus project: ${projectName.padEnd(25)}   ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+`);
+
+    const totalSteps = skipInstall ? (skipGit ? 2 : 3) : (skipGit ? 3 : 4);
+    let currentStep = 0;
+
+    // Step 1: Create project structure
+    this.logger.step(++currentStep, totalSteps, 'Creating project structure...');
+    await this.createProjectStructure(projectPath, projectName, template);
+    this.logger.success('Project structure created');
+
+    // Step 2: Initialize git
+    if (!skipGit) {
+      this.logger.step(++currentStep, totalSteps, 'Initializing git repository...');
+      if (await checkCommandExists('git')) {
+        await spawnCommand('git', ['init'], { cwd: projectPath, stdio: 'pipe' });
+        this.logger.success('Git repository initialized');
+      } else {
+        this.logger.warning('Git not found, skipping git initialization');
+      }
+    }
+
+    // Step 3: Install dependencies
+    if (!skipInstall) {
+      this.logger.step(++currentStep, totalSteps, `Installing dependencies with ${packageManager}...`);
+      
+      const installCommand = this.getInstallCommand(packageManager);
+      if (await checkCommandExists(packageManager)) {
+        await spawnCommand(installCommand.cmd, installCommand.args, { cwd: projectPath });
+        this.logger.success('Dependencies installed');
+      } else {
+        this.logger.warning(`${packageManager} not found, skipping dependency installation`);
+        this.logger.info(`Run "${packageManager} install" manually to install dependencies`);
+      }
+    }
+
+    // Step 4: Done!
+    this.logger.step(++currentStep, totalSteps, 'Finalizing...');
+    this.logger.success('Project created successfully!');
+
+    this.showNextSteps(projectName, packageManager);
+  }
+
+  private async createProjectStructure(
+    projectPath: string,
+    projectName: string,
+    template: string
+  ): Promise<void> {
+    const templates = new ProjectTemplates(projectName);
+    const files = templates.getTemplate(template);
+
+    for (const [filePath, content] of Object.entries(files)) {
+      await FileSystem.writeFile(
+        FileSystem.joinPath(projectPath, filePath),
+        content
+      );
+    }
+  }
+
+  private getInstallCommand(pm: string): { cmd: string; args: string[] } {
+    switch (pm) {
+      case 'yarn':
+        return { cmd: 'yarn', args: ['install'] };
+      case 'pnpm':
+        return { cmd: 'pnpm', args: ['install'] };
+      case 'bun':
+        return { cmd: 'bun', args: ['install'] };
+      default:
+        return { cmd: 'npm', args: ['install'] };
+    }
+  }
+
+  private showNextSteps(projectName: string, pm: string): void {
+    const runCmd = pm === 'npm' ? 'npm run' : pm;
+
+    console.log(`
+${this.logger.colors.green}✓ Success!${this.logger.colors.reset} Created ${this.logger.colors.cyan}${projectName}${this.logger.colors.reset}
+
+${this.logger.colors.bright}Next steps:${this.logger.colors.reset}
+
+  ${this.logger.colors.cyan}cd${this.logger.colors.reset} ${projectName}
+  ${this.logger.colors.cyan}${runCmd}${this.logger.colors.reset} dev
+
+${this.logger.colors.bright}Available commands:${this.logger.colors.reset}
+
+  ${this.logger.colors.cyan}${runCmd} dev${this.logger.colors.reset}      Start development server
+  ${this.logger.colors.cyan}${runCmd} build${this.logger.colors.reset}    Build for production
+  ${this.logger.colors.cyan}${runCmd} start${this.logger.colors.reset}    Start production server
+  ${this.logger.colors.cyan}${runCmd} test${this.logger.colors.reset}     Run tests
+
+${this.logger.colors.dim}Happy coding with Nexus! 🚀${this.logger.colors.reset}
+`);
+  }
+}

package/src/cli/commands/dev.ts

@@ -0,0 +1,85 @@
+import { Command } from '../cli';
+import { Logger } from '../utils/logger';
+import { FileSystem } from '../utils/file-system';
+import { spawnCommand } from '../utils/exec';
+
+export class DevCommand implements Command {
+  name = 'dev';
+  description = 'Start development server with hot reload';
+  usage = 'nexus dev [options]';
+  options = [
+    {
+      name: 'port',
+      alias: 'p',
+      description: 'Port to run the server on',
+      defaultValue: '3000',
+    },
+    {
+      name: 'host',
+      alias: 'H',
+      description: 'Host to bind the server to',
+      defaultValue: 'localhost',
+    },
+  ];
+
+  private logger = new Logger();
+
+  async execute(
+    args: string[],
+    options: Record<string, string | boolean>
+  ): Promise<void> {
+    const port = options.port || options.p || '3000';
+    const host = options.host || options.H || 'localhost';
+
+    // Check if we're in a Nexus project
+    const packageJsonPath = FileSystem.joinPath(process.cwd(), 'package.json');
+    if (!(await FileSystem.exists(packageJsonPath))) {
+      this.logger.error('No package.json found. Are you in a Nexus project?');
+      return;
+    }
+
+    // Check for main entry file
+    const possibleEntries = ['src/index.ts', 'src/main.ts', 'src/app.ts', 'index.ts'];
+    let entryFile: string | null = null;
+
+    for (const entry of possibleEntries) {
+      if (await FileSystem.exists(FileSystem.joinPath(process.cwd(), entry))) {
+        entryFile = entry;
+        break;
+      }
+    }
+
+    if (!entryFile) {
+      this.logger.error('No entry file found (src/index.ts, src/main.ts, etc.)');
+      return;
+    }
+
+    this.logger.header('Starting Nexus Development Server');
+    this.logger.info(`Entry: ${entryFile}`);
+    this.logger.info(`Server: http://${host}:${port}`);
+    this.logger.blank();
+
+    // Try to use ts-node-dev, tsx, or ts-node
+    const runners = [
+      { cmd: 'npx', args: ['tsx', 'watch', entryFile] },
+      { cmd: 'npx', args: ['ts-node-dev', '--respawn', '--transpile-only', entryFile] },
+      { cmd: 'npx', args: ['ts-node', entryFile] },
+    ];
+
+    for (const runner of runners) {
+      try {
+        await spawnCommand(runner.cmd, runner.args, {
+          cwd: process.cwd(),
+          env: {
+            PORT: String(port),
+            HOST: String(host),
+            NODE_ENV: 'development',
+          },
+        });
+        break;
+      } catch (error) {
+        continue;
+      }
+    }
+  }
+}

package/src/cli/commands/generate.ts

@@ -0,0 +1,97 @@
+import { Command, CommandOption } from '../cli';
+import { Logger } from '../utils/logger';
+import { FileSystem } from '../utils/file-system';
+import { GeneratorTemplates } from '../templates/generators';
+
+type GeneratorType = 'route' | 'middleware' | 'controller' | 'service' | 'model' | 'validator';
+
+export class GenerateCommand implements Command {
+  name = 'generate';
+  description = 'Generate components (route, middleware, controller, etc.)';
+  usage = 'nexus generate <type> <name> [options]';
+  options: CommandOption[] = [
+    {
+      name: 'path',
+      alias: 'p',
+      description: 'Custom path for the generated file',
+    },
+    {
+      name: 'methods',
+      alias: 'm',
+      description: 'HTTP methods for route (comma-separated)',
+      defaultValue: 'get',
+    },
+  ];
+
+  private logger = new Logger();
+  private validTypes: GeneratorType[] = ['route', 'middleware', 'controller', 'service', 'model', 'validator'];
+
+  async execute(
+    args: string[],
+    options: Record<string, string | boolean>
+  ): Promise<void> {
+    if (args.length < 2) {
+      this.showUsage();
+      return;
+    }
+
+    const [type, name] = args;
+
+    if (!this.validTypes.includes(type as GeneratorType)) {
+      this.logger.error(`Invalid type: ${type}`);
+      this.logger.info(`Valid types: ${this.validTypes.join(', ')}`);
+      return;
+    }
+
+    const customPath = options.path as string | undefined;
+    const methods = ((options.methods || 'get') as string).split(',').map(m => m.trim().toLowerCase());
+
+    await this.generate(type as GeneratorType, name, { customPath, methods });
+  }
+
+  private async generate(
+    type: GeneratorType,
+    name: string,
+    options: { customPath?: string; methods: string[] }
+  ): Promise<void> {
+    const generator = new GeneratorTemplates();
+    const { filePath, content } = generator.generate(type, name, options);
+
+    const targetPath = options.customPath 
+      ? FileSystem.joinPath(process.cwd(), options.customPath, `${name}.ts`)
+      : FileSystem.joinPath(process.cwd(), filePath);
+
+    // Check if file already exists
+    if (await FileSystem.exists(targetPath)) {
+      this.logger.error(`File already exists: ${targetPath}`);
+      return;
+    }
+
+    await FileSystem.writeFile(targetPath, content);
+    this.logger.success(`Created ${type}: ${targetPath}`);
+  }
+
+  private showUsage(): void {
+    console.log(`
+${this.logger.colors.bright}Usage:${this.logger.colors.reset} nexus generate <type> <name> [options]
+
+${this.logger.colors.bright}Types:${this.logger.colors.reset}
+  route        Generate a route handler
+  middleware   Generate a middleware
+  controller   Generate a controller class
+  service      Generate a service class
+  model        Generate a model/entity
+  validator    Generate a validation schema
+
+${this.logger.colors.bright}Examples:${this.logger.colors.reset}
+  nexus generate route users
+  nexus generate controller UserController
+  nexus generate middleware auth
+  nexus generate route products --methods get,post,put,delete
+
+${this.logger.colors.bright}Options:${this.logger.colors.reset}
+  --path, -p    Custom output path
+  --methods, -m HTTP methods for routes (comma-separated)
+`);
+  }
+}

package/src/cli/commands/help.ts

@@ -0,0 +1,95 @@
+import { Command } from '../cli';
+import { Logger } from '../utils/logger';
+
+export class HelpCommand implements Command {
+  name = 'help';
+  description = 'Show help information';
+  usage = 'nexus help [command]';
+
+  private logger = new Logger();
+  private getCommands: () => Map<string, Command>;
+
+  constructor(getCommands: () => Map<string, Command>) {
+    this.getCommands = getCommands;
+  }
+
+  async execute(
+    args: string[],
+    options: Record<string, string | boolean>
+  ): Promise<void> {
+    const commands = this.getCommands();
+
+    if (args.length > 0) {
+      const commandName = args[0];
+      const command = commands.get(commandName);
+
+      if (!command) {
+        this.logger.error(`Unknown command: ${commandName}`);
+        return;
+      }
+
+      this.showCommandHelp(command);
+      return;
+    }
+
+    this.showGeneralHelp(commands);
+  }
+
+  private showGeneralHelp(commands: Map<string, Command>): void {
+    console.log(`
+${this.logger.colors.bright}Nexus CLI${this.logger.colors.reset} - Async-First Web Framework
+
+${this.logger.colors.bright}Usage:${this.logger.colors.reset}
+  nexus <command> [options]
+
+${this.logger.colors.bright}Commands:${this.logger.colors.reset}
+`);
+
+    for (const [name, command] of commands) {
+      console.log(`  ${this.logger.colors.cyan}${name.padEnd(12)}${this.logger.colors.reset} ${command.description}`);
+    }
+
+    console.log(`
+${this.logger.colors.bright}Global Options:${this.logger.colors.reset}
+  --help, -h     Show help
+  --version, -v  Show version
+
+${this.logger.colors.bright}Examples:${this.logger.colors.reset}
+  ${this.logger.colors.dim}# Create a new project${this.logger.colors.reset}
+  nexus create my-app
+
+  ${this.logger.colors.dim}# Create with specific template${this.logger.colors.reset}
+  nexus create my-api --template api
+
+  ${this.logger.colors.dim}# Generate a route${this.logger.colors.reset}
+  nexus generate route users
+
+  ${this.logger.colors.dim}# Start development server${this.logger.colors.reset}
+  nexus dev
+
+Run ${this.logger.colors.cyan}nexus help <command>${this.logger.colors.reset} for more information on a specific command.
+`);
+  }
+
+  private showCommandHelp(command: Command): void {
+    console.log(`
+${this.logger.colors.bright}${command.name}${this.logger.colors.reset} - ${command.description}
+
+${this.logger.colors.bright}Usage:${this.logger.colors.reset}
+  ${command.usage}
+`);
+
+    if (command.options && command.options.length > 0) {
+      console.log(`${this.logger.colors.bright}Options:${this.logger.colors.reset}`);
+      for (const option of command.options) {
+        const aliasStr = option.alias ? `, -${option.alias}` : '';
+        const defaultStr = option.defaultValue !== undefined 
+          ? ` (default: ${option.defaultValue})` 
+          : '';
+        console.log(`  --${option.name}${aliasStr}`);
+        console.log(`      ${option.description}${defaultStr}`);
+      }
+      console.log('');
+    }
+  }
+}