feat(app): allow passing command function without name

```
function helloWorld(name: string) {
}

const app = new App();
app.command(helloWorld);
app.run();
```

registers `hello-world [name]` as CLI command.

packages/app/src/app.ts

@@ -247,7 +247,9 @@ export class App<T extends RootModuleDefinition> {
         return this;
     }
 
-    command(name: string, callback: (...args: any[]) => any): this {
+    command(name: string | ((...args: any[]) => any), callback?: (...args: any[]) => any): this {
+        callback = isFunction(name) ? name : callback!;
+        name = isFunction(name) ? '' : name;
         this.appModule.addCommand(name, callback);
         return this;
     }
@@ -348,7 +350,6 @@ export class App<T extends RootModuleDefinition> {
         }
 
         const scopedInjectorContext = this.getInjectorContext().createChildScope('cli');
-        const commands = [...this.serviceContainer.cliControllerRegistry.controllers.entries()];
 
         if ('string' !== typeof bin) {
             bin = bin || getBinFromEnvironment();
@@ -360,7 +361,8 @@ export class App<T extends RootModuleDefinition> {
         return await executeCommand(
             bin, argv || getArgsFromEnvironment(),
             eventDispatcher, logger,
-            scopedInjectorContext, commands.map(c => c[1])
+            scopedInjectorContext,
+            this.serviceContainer.cliControllerRegistry.controllers
         );
     }
 }

packages/app/src/module.ts

@@ -260,7 +260,7 @@ export class AppModule<T extends RootModuleDefinition = {}, C extends ExtractCla
 
     public imports: AppModule<any>[] = [];
     public controllers: ClassType[] = [];
-    public commands: { name: string, callback: Function }[] = [];
+    public commands: { name?: string, callback: Function }[] = [];
     public workflows: WorkflowDefinition<any>[] = [];
     public listeners: ListenerType[] = [];
     public middlewares: MiddlewareFactory[] = [];
@@ -369,11 +369,11 @@ export class AppModule<T extends RootModuleDefinition = {}, C extends ExtractCla
         return this.controllers;
     }
 
-    getCommands(): { name: string, callback: Function }[] {
+    getCommands(): { name?: string, callback: Function }[] {
         return this.commands;
     }
 
-    addCommand(name: string, callback: (...args: []) => any): this {
+    addCommand(name: string | undefined, callback: (...args: []) => any): this {
         this.assertInjectorNotBuilt();
         this.commands.push({ name, callback });
         return this;

packages/app/src/service-container.ts

@@ -40,7 +40,7 @@ export interface ControllerConfig {
 }
 
 export class CliControllerRegistry {
-    public readonly controllers = new Map<string, ControllerConfig>();
+    public readonly controllers: ControllerConfig[] = [];
 }
 
 export type MiddlewareRegistryEntry = { config: MiddlewareConfig, module: AppModule<any> };
@@ -303,19 +303,22 @@ export class ServiceContainer {
     protected processController(module: AppModule<any>, controller: ControllerConfig) {
         let name = controller.name || '';
         if (controller.controller) {
+
             if (!name) {
                 const cliConfig = cli._fetch(controller.controller);
                 if (cliConfig) {
-                    name = cliConfig.name || '';
+                    controller.name = name || cliConfig.name || '';
+
                     //make sure CLI controllers are provided in cli scope
                     if (!module.isProvided(controller.controller)) {
                         module.addProvider({ provide: controller.controller, scope: 'cli' });
                     }
-                    this.cliControllerRegistry.controllers.set(name, controller);
+                    this.cliControllerRegistry.controllers.push(controller);
                 }
             }
+
         } else if (controller.for === 'cli') {
-            this.cliControllerRegistry.controllers.set(name, controller);
+            this.cliControllerRegistry.controllers.push(controller);
         }
 
         for (const m of this.modules) {