@xeno-js/cli 0.1.0

package/lint-staged.config.mjs

@@ -0,0 +1,5 @@
+export default {
+  'src/**/*.ts': ['eslint --config eslint.config.mjs --fix --max-warnings=0', 'prettier --write'],
+  '*.{json,md,yml,yaml,css,scss,html}': ['prettier --write'],
+  '*.{js,mjs,cjs}': ['prettier --write'],
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@xeno-js/cli",
+  "version": "0.1.0",
+  "description": "Xeno CLI — Command Line Interface for Xeno projects",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xeno-js/xeno-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xeno-js/xeno-cli/issues"
+  },
+  "homepage": "https://github.com/xeno-js/xeno-cli#readme",
+  "bin": {
+    "xeno-js": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint --config eslint.config.mjs \"src/**/*.ts\" --max-warnings=0",
+    "lint:fix": "eslint --config eslint.config.mjs \"src/**/*.ts\" --fix --max-warnings=0",
+    "lint-staged": "lint-staged",
+    "commitlint": "commitlint",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run src",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "check": "npm run typecheck && npm run lint:fix && npm run test",
+    "verify:commit": "npm run lint-staged && npm run test",
+    "verify:push": "npm run check",
+    "prepare": "husky",
+    "prepublishOnly": "npm run check && npm run build",
+    "release": "npm run prepublishOnly && npm publish"
+  },
+  "keywords": [],
+  "author": "Xeno",
+  "license": "ISC",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "type": "commonjs",
+  "dependencies": {
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^21.0.1",
+    "@commitlint/config-conventional": "^21.0.1",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^26.6.1",
+    "@types/prompts": "^2.4.9",
+    "@vitest/coverage-v8": "^4.1.7",
+    "eslint": "^10.4.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-simple-import-sort": "^13.0.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.0.5",
+    "prettier": "^3.8.3",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.60.0",
+    "vitest": "^4.1.7"
+  }
+}

package/src/domain/contracts/icommand-cli.contracts.ts

@@ -0,0 +1,13 @@
+export interface ICliCommand {
+  /** Il nome principale del comando (es. 'new', 'generate') */
+  get name(): string
+
+  /** Eventuali alias (es. 'g' per 'generate') */
+  get aliases(): string[]
+
+  /**
+   * Il metodo esecutivo.
+   * Riceve solo gli argomenti di pertinenza (escludendo il nome del comando stesso).
+   */
+  execute(args: string[]): Promise<void>
+}

package/src/domain/contracts/icommand-runner.contracts.ts

@@ -0,0 +1,3 @@
+export interface ICommandRunner {
+  run(command: string, args: string[], cwd: string): Promise<void>
+}

package/src/domain/contracts/idispatch.contracts.ts

@@ -0,0 +1,3 @@
+export interface IDispatcher {
+  dispatch(rawArgs: string[]): Promise<void>
+}

package/src/domain/contracts/ifile-service.contracts.ts

@@ -0,0 +1,3 @@
+export interface IFileService {
+  writeFileRecursive(filePath: string, content: string): Promise<void>
+}

package/src/domain/contracts/igenerator.contracts.ts

@@ -0,0 +1,5 @@
+import { type BaseOptions, type ScaffoldingOptions } from '../../shared'
+
+export interface IGenerator<T extends BaseOptions = ScaffoldingOptions> {
+  generate(projectPath: string, options: T): Promise<void>
+}

package/src/domain/contracts/index.ts

@@ -0,0 +1,6 @@
+export type * from './icommand-cli.contracts'
+export type * from './icommand-runner.contracts'
+export type * from './idispatch.contracts'
+export type * from './ifile-service.contracts'
+export type * from './igenerator.contracts'
+export type * from './iscaffold-strategy.contracts'

package/src/domain/contracts/iscaffold-strategy.contracts.ts

@@ -0,0 +1,7 @@
+import { type BaseOptions, type ScaffoldingOptions } from '../../shared'
+import { type IGenerator } from './igenerator.contracts'
+
+export interface IScaffoldStrategy<T extends BaseOptions> {
+  promptOptions(targetDir: string): Promise<ScaffoldingOptions>
+  getGenerators(options: ScaffoldingOptions): Promise<IGenerator<T>[]>
+}

package/src/domain/index.ts

@@ -0,0 +1 @@
+export type * from './contracts'

package/src/index.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import pc from 'picocolors'
+
+import { Builder } from './infrastructure/builder'
+
+/**
+ * @function init
+ * @description Initializes the scaffolding process for a new Xeno project.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @license ISC
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+async function init() {
+  try {
+    const dispatcher = Builder.getDispatcher()
+
+    const rawArgs = process.argv.slice(2)
+
+    await dispatcher.dispatch(rawArgs)
+  } catch (error) {
+    console.error(pc.red('\n❌ Execution interrupted:'))
+    console.error(error instanceof Error ? error.message : error)
+    process.exit(1)
+  }
+}
+
+init().catch(console.error)

package/src/infrastructure/bootstrap/bootstrapper.ts

@@ -0,0 +1,30 @@
+// src/core/bootstrapper.ts
+import { mkdir } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+import pc from 'picocolors'
+
+import type { IGenerator } from '../../domain'
+import { type BaseOptions, type ScaffoldingOptions } from '../../shared'
+
+export class Bootstrapper<T extends BaseOptions = ScaffoldingOptions> {
+  constructor(private readonly _generators: IGenerator<T>[]) {}
+
+  public async run(projectPath: string, options: T): Promise<void> {
+    console.info(pc.cyan('\n🚀 Initializing scaffolding...'))
+
+    const absolutePath = resolve(process.cwd(), projectPath)
+    await mkdir(absolutePath, { recursive: true })
+
+    for (const generator of this._generators) {
+      try {
+        await generator.generate(absolutePath, options)
+      } catch (error) {
+        console.error(pc.red(`\n❌ Error during execution of ${generator.constructor.name}`))
+        throw error
+      }
+    }
+
+    console.info(pc.green('\n✨ Scaffolding completed succesfully!'))
+  }
+}

package/src/infrastructure/bootstrap/index.ts

@@ -0,0 +1 @@
+export * from './bootstrapper'

package/src/infrastructure/builder/builder.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { GenerateCommandQuery, HelpCommand, NewProjectCommand } from '../commands'
+import { CliDispatcher } from '../dispatcher'
+import { Builder } from './builder'
+
+describe('Builder', () => {
+  it('should create a dispatcher with the CLI commands registered', () => {
+    const dispatcher = Builder.getDispatcher()
+
+    expect(dispatcher).toBeInstanceOf(CliDispatcher)
+  })
+
+  it('should dispatch the registered commands through the built dispatcher', async () => {
+    const dispatcher = Builder.getDispatcher()
+
+    const newSpy = vi.spyOn(NewProjectCommand.prototype, 'execute').mockResolvedValue()
+    const generateSpy = vi.spyOn(GenerateCommandQuery.prototype, 'execute').mockResolvedValue()
+    const helpSpy = vi.spyOn(HelpCommand.prototype, 'execute').mockResolvedValue()
+
+    await dispatcher.dispatch(['new', 'demo-app'])
+    await dispatcher.dispatch(['generate', 'command', 'User'])
+    await dispatcher.dispatch(['--help'])
+    await dispatcher.dispatch(['-h'])
+
+    expect(newSpy).toHaveBeenCalledWith(['demo-app'])
+    expect(generateSpy).toHaveBeenCalledWith(['command', 'User'])
+    expect(helpSpy).toHaveBeenCalledTimes(2)
+    expect(helpSpy).toHaveBeenNthCalledWith(1, [])
+    expect(helpSpy).toHaveBeenNthCalledWith(2, [])
+
+    newSpy.mockRestore()
+    generateSpy.mockRestore()
+    helpSpy.mockRestore()
+  })
+})

package/src/infrastructure/builder/builder.ts

@@ -0,0 +1,15 @@
+import { type IDispatcher } from '../../domain'
+import { GenerateCommandQuery, HelpCommand, NewProjectCommand } from '../commands'
+import { CliDispatcher } from '../dispatcher'
+
+export class Builder {
+  public static getDispatcher(): IDispatcher {
+    const dispatcher = new CliDispatcher([
+      new NewProjectCommand(),
+      new GenerateCommandQuery(),
+      new HelpCommand(),
+    ])
+
+    return dispatcher
+  }
+}

package/src/infrastructure/builder/index.ts

@@ -0,0 +1 @@
+export * from './builder'

package/src/infrastructure/command_launcher/command.utils.ts

@@ -0,0 +1,31 @@
+// import { spawn } from 'node:child_process';
+
+// /**
+//  * @class CommandUtils
+//  * @description Utility class for executing shell commands in a cross-platform manner.
+//  *
+//  * @author Xeno
+//  * @version 1.0.0
+//  * @license ISC
+//  * @since 2025-09-30
+//  * @link https://github.com/xeno-js/xeno-js
+//  */
+// export const CommandLauncher = {
+//     runCommand: (command: string, args: string[], cwd: string): Promise<void> => {
+//         return new Promise((resolve, reject) => {
+//             const isWin = process.platform === "win32";
+//             const cmd = isWin ? `${command}.cmd` : command;
+
+//             const child = spawn(cmd, args, {
+//                 cwd,
+//                 stdio: 'inherit',
+//                 shell: true
+//             });
+
+//             child.on('close', (code) => {
+//                 if (code === 0) resolve();
+//                 else reject(new Error(`Command ${command} failed with code ${code}`));
+//             });
+//         });
+//     }
+// };

package/src/infrastructure/commands/command-runner.service.ts

@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process'
+
+import { type ICommandRunner } from '../../domain'
+
+/**
+ * @class CommandUtils
+ * @description Utility class for executing shell commands in a cross-platform manner.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @license ISC
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+export class CommandRunner implements ICommandRunner {
+  public async run(command: string, args: string[], cwd: string, isWin = false): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const cmd = isWin ? `${command}.cmd` : command
+
+      const child = spawn(cmd, args, {
+        cwd,
+        stdio: 'inherit',
+        shell: false,
+      })
+
+      child.on('error', (error) => {
+        reject(new Error(`Error during execution of the command ${command}: ${error.message}`))
+      })
+
+      child.on('close', (code) => {
+        if (code === 0) resolve()
+        else reject(new Error(`Command ${command} failed with code ${code}`))
+      })
+    })
+  }
+}

package/src/infrastructure/commands/generate.command.ts

@@ -0,0 +1,55 @@
+import pc from 'picocolors'
+
+import type { ICliCommand } from '../../domain'
+import { Guards } from '../../shared'
+import { COMMAND_CONSTANTS } from '../../shared/constants/command.constants'
+import { FileUtils } from '../file'
+
+export class GenerateCommandQuery implements ICliCommand {
+  public readonly name: string = 'generate'
+  public readonly aliases: string[] = ['g']
+
+  public async execute(args: string[]): Promise<void> {
+    const type = args[0] // "command" o "query"
+    const componentName = args[1] // es: "User"
+    const isCore = args.includes('--core')
+    const isVue = args.includes('--vue')
+
+    if (Guards.isNullOrEmpty(type) || Guards.isNullOrEmpty(componentName)) {
+      throw new Error(`Invalid syntax. Usage: xeno-js g [command | query] <Name> [--core | --vue]`)
+    }
+
+    let outputPath: string | undefined = undefined
+    const outputIndex = args.findIndex((arg) => arg === '--output' || arg === '-o' || arg === '--o')
+    if (outputIndex !== -1 && args.length > outputIndex + 1) {
+      outputPath = args[outputIndex + 1]
+    }
+
+    const targetDir = process.cwd()
+    const fileService = new FileUtils()
+
+    if (isCore || !isVue) {
+      const cqrsType =
+        type === COMMAND_CONSTANTS.COMMAND ? COMMAND_CONSTANTS.COMMAND : COMMAND_CONSTANTS.QUERY
+      const { CqrsGenerator } = await import('../generators/core/command/cqrs.generator.js')
+      const generator = new CqrsGenerator(fileService)
+
+      await generator.generate(targetDir, componentName, cqrsType, outputPath)
+
+      console.info(pc.green(`\n  Successfully generated ${type} component '${componentName}'!`))
+    } else if (isVue) {
+      const cqrsType =
+        type === COMMAND_CONSTANTS.COMMAND ? COMMAND_CONSTANTS.COMMAND : COMMAND_CONSTANTS.QUERY
+      const { CqrsVueGenerator } = await import('../generators/vue/command_query/cqrs.generator.js')
+      const generator = new CqrsVueGenerator(fileService)
+
+      await generator.generate(targetDir, componentName, cqrsType, outputPath)
+
+      console.info(
+        pc.green(`\n✅ Successfully generated Vue ${type} component '${componentName}'!`),
+      )
+    } else {
+      throw new Error(`Unsupported generator type: '${type}'. Use 'command' or 'query'.`)
+    }
+  }
+}

package/src/infrastructure/commands/help.command.ts

@@ -0,0 +1,63 @@
+import pc from 'picocolors'
+
+import type { ICliCommand } from '../../domain'
+import { ARGS_CONSTANTS, COMMAND_CONSTANTS } from '../../shared'
+
+export class HelpCommand implements ICliCommand {
+  public get name(): string {
+    return COMMAND_CONSTANTS.HELP
+  }
+  public get aliases(): string[] {
+    return [ARGS_CONSTANTS.HELP, '-h']
+  }
+
+  public async execute(): Promise<void> {
+    console.info(pc.greenBright('\n🚀 Xeno CLI - Usage Guide\n'))
+
+    // --- NEW PROJECT ---
+    console.info(pc.bold(pc.blue('1. Create a new project:')))
+    console.info(`  xeno-js new ${pc.yellow('<name>')} ${pc.cyan('[--vue | --core]')}`)
+    console.info(`  ${pc.gray('•')} ${pc.yellow('<name>')}: The name of your project directory.`)
+    console.info(
+      `  ${pc.gray('•')} ${pc.cyan('[--vue | --core]')}: Project type. ${pc.gray('(Default: --core)')}`,
+    )
+    console.info(`    - ${pc.cyan('--core')}: Initializes a Backend project (Node.js/TS).`)
+    console.info(`    - ${pc.cyan('--vue')}: Initializes a Frontend project (Vue.js).\n`)
+
+    // --- GENERATE ---
+    console.info(pc.bold(pc.blue('2. Generate CQRS components:')))
+    console.info(
+      `  xeno-js generate ${pc.magenta('<type>')} ${pc.yellow('<Name>')} ${pc.cyan('[--vue | --core]')} ${pc.green('[--output <path>]')}`,
+    )
+    console.info(
+      `  ${pc.gray('•')} ${pc.magenta('<type>')}: Component type to generate (${pc.magenta('command')} | ${pc.magenta('query')}).`,
+    )
+    console.info(
+      `  ${pc.gray('•')} ${pc.yellow('<Name>')}: The name of the component (e.g., UserCreate).`,
+    )
+    console.info(
+      `  ${pc.gray('•')} ${pc.cyan('[--vue | --core]')}: Target context. ${pc.gray('(Default: --core)')}`,
+    )
+    console.info(
+      `    - ${pc.cyan('--core')}: Generates Controller, Handler, Command/Query, Module, and Zod/DB schemas.`,
+    )
+    console.info(
+      `    - ${pc.cyan('--vue')}: Generates frontend-specific files (Stores, Services, etc.).`,
+    )
+    console.info(
+      `  ${pc.gray('•')} ${pc.green('[--output | -o]')}: Custom destination path inside 'src/'. ${pc.gray('(Default: src/<name-in-lowercase>)')}`,
+    )
+    console.info(
+      `  ${pc.gray('Alias:')} ${pc.gray('xeno-js g <type> <Name> [--vue | --core] [-o | --o <path>]')}\n`,
+    )
+
+    // --- HELP ---
+    console.info(pc.bold(pc.blue('3. Help:')))
+    console.info(`  xeno-js --help     ${pc.gray('Displays this guide.')}`)
+    console.info(`  ${pc.gray('Alias:')} ${pc.gray('xeno-js --h | -h')}\n`)
+
+    // --- DOCS ---
+    console.info(pc.bold(pc.blue('Documentation:')))
+    console.info(`  ${pc.underline('https://www.xeno-js.it')}\n`)
+  }
+}

package/src/infrastructure/commands/index.ts

@@ -0,0 +1,4 @@
+export * from './command-runner.service'
+export * from './generate.command'
+export * from './help.command'
+export * from './new-project.command'

package/src/infrastructure/commands/new-project.command.ts

@@ -0,0 +1,47 @@
+import pc from 'picocolors'
+
+import type { ICliCommand } from '../../domain'
+import type { IScaffoldStrategy } from '../../domain'
+import { type ScaffoldingOptions } from '../../shared'
+import { Bootstrapper } from '../bootstrap'
+import { FileUtils } from '../file'
+import { CommandRunner } from './command-runner.service'
+
+export class NewProjectCommand implements ICliCommand {
+  public readonly name: string = 'new'
+  public readonly aliases: string[] = []
+
+  public async execute(args: string[]): Promise<void> {
+    const targetDir = args.find((arg) => !arg.startsWith('--')) ?? 'my-xeno-app'
+    const isVue = args.includes('--vue')
+    const fileService = new FileUtils()
+
+    let strategy: IScaffoldStrategy<ScaffoldingOptions>
+
+    if (isVue) {
+      const { VueScaffoldStrategy } = await import('../strategies/vue-scaffold.strategy.js')
+      strategy = new VueScaffoldStrategy(fileService)
+    } else {
+      const { CoreScaffoldStrategy } = await import('../strategies/core-scaffold.strategy.js')
+      strategy = new CoreScaffoldStrategy(fileService)
+    }
+
+    const options = await strategy.promptOptions(targetDir)
+
+    const generators = await strategy.getGenerators(options)
+    const bootstrapper = new Bootstrapper(generators)
+    await bootstrapper.run(targetDir, options)
+
+    const commandRunner = new CommandRunner()
+    if (options.gitInit) {
+      console.info(pc.greenBright('\n🗂️ Initializing Git repository...'))
+      await commandRunner.run('git', ['init'], targetDir)
+    }
+    console.info(pc.greenBright('\n📦 Installing dependencies...'))
+    const isWin = process.platform === 'win32'
+    await commandRunner.run('npm', ['install'], targetDir, isWin)
+
+    console.info(pc.green(`\n✅ Project successfully created in ./${targetDir}`))
+    console.info(pc.white(`\nNext steps:\n  cd ${targetDir}\n  npm run start\n`))
+  }
+}

package/src/infrastructure/dispatcher/dispatcher.ts

@@ -0,0 +1,45 @@
+import pc from 'picocolors'
+
+import type { ICliCommand, IDispatcher } from '../../domain'
+import { ARGS_CONSTANTS, COMMAND_CONSTANTS, Guards } from '../../shared'
+
+export class CliDispatcher implements IDispatcher {
+  private readonly _commands = new Map<string, ICliCommand>()
+
+  constructor(commands: ICliCommand[]) {
+    for (const command of commands) {
+      this._commands.set(command.name, command)
+      for (const alias of command.aliases) {
+        this._commands.set(alias, command)
+      }
+    }
+  }
+
+  public async dispatch(rawArgs: string[]): Promise<void> {
+    const action = rawArgs[0]
+
+    if (
+      !Guards.isDefined(action) ||
+      action === ARGS_CONSTANTS.HELP ||
+      action === '-h' ||
+      action === '--h'
+    ) {
+      const helpCommand = this._commands.get(COMMAND_CONSTANTS.HELP)
+      await helpCommand?.execute([])
+      return
+    }
+
+    const command = this._commands.get(action)
+
+    if (!Guards.isDefined(command)) {
+      console.error(pc.red(`\n❌ '${action}' is not a command`))
+      console.info(
+        pc.yellow(`See 'xeno-js --help' for cli usage guide or https://www.xeno-js.it for docs.\n`),
+      )
+      process.exit(1)
+    }
+
+    const commandArgs = rawArgs.slice(1)
+    await command.execute(commandArgs)
+  }
+}

package/src/infrastructure/dispatcher/index.ts

@@ -0,0 +1 @@
+export * from './dispatcher'

package/src/infrastructure/file/file.service.ts

@@ -0,0 +1,14 @@
+import { mkdir, writeFile } from 'fs/promises'
+import { dirname } from 'path'
+
+import { type IFileService } from '../../domain'
+
+export class FileUtils implements IFileService {
+  public async writeFileRecursive(filePath: string, content: string): Promise<void> {
+    const dir = dirname(filePath)
+
+    await mkdir(dir, { recursive: true })
+
+    await writeFile(filePath, content, 'utf8')
+  }
+}

package/src/infrastructure/file/index.ts

@@ -0,0 +1 @@
+export * from './file.service'