@mantiq/cli 0.2.0-rc.1 → 0.2.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantiq/cli",
-  "version": "0.2.0-rc.1",
+  "version": "0.2.0-rc.2",
   "description": "Command runner, code generators, dev server",
   "type": "module",
   "license": "MIT",

package/src/CommandRegistry.ts

@@ -0,0 +1,27 @@
+import type { Command } from './Command.ts'
+
+/**
+ * Global command registry. Service providers push their commands here
+ * during boot(), and the CLI Kernel collects them at run time.
+ *
+ * This decouples command registration from the Kernel — each package
+ * registers its own commands without the user needing to import them.
+ */
+
+const _commands: Command[] = []
+
+export function registerCommand(command: Command): void {
+  _commands.push(command)
+}
+
+export function registerCommands(commands: Command[]): void {
+  for (const cmd of commands) _commands.push(cmd)
+}
+
+export function getRegisteredCommands(): Command[] {
+  return [..._commands]
+}
+
+export function clearRegisteredCommands(): void {
+  _commands.length = 0
+}

package/src/Kernel.ts

@@ -1,6 +1,42 @@
 import type { Command } from './Command.ts'
 import { parse, type ParsedArgs } from './Parser.ts'
 import { IO } from './IO.ts'
+import { getRegisteredCommands } from './CommandRegistry.ts'
+
+// Built-in commands — utility
+import { AboutCommand } from './commands/AboutCommand.ts'
+import { ServeCommand } from './commands/ServeCommand.ts'
+import { RouteListCommand } from './commands/RouteListCommand.ts'
+import { TinkerCommand } from './commands/TinkerCommand.ts'
+
+// Built-in commands — database
+import { MigrateCommand } from './commands/MigrateCommand.ts'
+import { MigrateRollbackCommand } from './commands/MigrateRollbackCommand.ts'
+import { MigrateResetCommand } from './commands/MigrateResetCommand.ts'
+import { MigrateFreshCommand } from './commands/MigrateFreshCommand.ts'
+import { MigrateStatusCommand } from './commands/MigrateStatusCommand.ts'
+import { SeedCommand } from './commands/SeedCommand.ts'
+
+// Built-in commands — generators
+import { MakeCommandCommand } from './commands/MakeCommandCommand.ts'
+import { MakeControllerCommand } from './commands/MakeControllerCommand.ts'
+import { MakeEventCommand } from './commands/MakeEventCommand.ts'
+import { MakeExceptionCommand } from './commands/MakeExceptionCommand.ts'
+import { MakeFactoryCommand } from './commands/MakeFactoryCommand.ts'
+import { MakeJobCommand } from './commands/MakeJobCommand.ts'
+import { MakeListenerCommand } from './commands/MakeListenerCommand.ts'
+import { MakeMailCommand } from './commands/MakeMailCommand.ts'
+import { MakeMiddlewareCommand } from './commands/MakeMiddlewareCommand.ts'
+import { MakeMigrationCommand } from './commands/MakeMigrationCommand.ts'
+import { MakeModelCommand } from './commands/MakeModelCommand.ts'
+import { MakeNotificationCommand } from './commands/MakeNotificationCommand.ts'
+import { MakeObserverCommand } from './commands/MakeObserverCommand.ts'
+import { MakePolicyCommand } from './commands/MakePolicyCommand.ts'
+import { MakeProviderCommand } from './commands/MakeProviderCommand.ts'
+import { MakeRequestCommand } from './commands/MakeRequestCommand.ts'
+import { MakeRuleCommand } from './commands/MakeRuleCommand.ts'
+import { MakeSeederCommand } from './commands/MakeSeederCommand.ts'
+import { MakeTestCommand } from './commands/MakeTestCommand.ts'
 
 /**
  * The CLI Kernel — registers commands and dispatches to the right one.
@@ -9,6 +45,7 @@ export class Kernel {
   private commands = new Map<string, Command>()
   private io = new IO()
   private discovered = false
+  private builtinsRegistered = false
 
   constructor(public readonly app: any = null) {}
 
@@ -22,6 +59,66 @@ export class Kernel {
     return this
   }
 
+  /**
+   * Register all built-in framework commands (utility, database, generators).
+   * Called once on the first run() invocation.
+   */
+  private registerBuiltins(): void {
+    this.registerAll([
+      // Utility
+      new AboutCommand(),
+      new ServeCommand(),
+      new RouteListCommand(),
+      new TinkerCommand(),
+
+      // Database
+      new MigrateCommand(),
+      new MigrateRollbackCommand(),
+      new MigrateResetCommand(),
+      new MigrateFreshCommand(),
+      new MigrateStatusCommand(),
+      new SeedCommand(),
+
+      // Generators
+      new MakeCommandCommand(),
+      new MakeControllerCommand(),
+      new MakeEventCommand(),
+      new MakeExceptionCommand(),
+      new MakeFactoryCommand(),
+      new MakeJobCommand(),
+      new MakeListenerCommand(),
+      new MakeMailCommand(),
+      new MakeMiddlewareCommand(),
+      new MakeMigrationCommand(),
+      new MakeModelCommand(),
+      new MakeNotificationCommand(),
+      new MakeObserverCommand(),
+      new MakePolicyCommand(),
+      new MakeProviderCommand(),
+      new MakeRequestCommand(),
+      new MakeRuleCommand(),
+      new MakeSeederCommand(),
+      new MakeTestCommand(),
+    ])
+  }
+
+  /**
+   * Dynamically import and register commands from optional packages.
+   * Uses try/catch so the CLI works fine when a package isn't installed.
+   *
+   * Note: Queue commands (queue:work, queue:retry, etc.) require a QueueManager
+   * instance and are registered by QueueServiceProvider.boot() instead.
+   */
+  private async registerPackageCommands(): Promise<void> {
+    // Heartbeat commands (if @mantiq/heartbeat is installed)
+    try {
+      const { InstallCommand } = await import('@mantiq/heartbeat')
+      this.register(new InstallCommand())
+    } catch {
+      // @mantiq/heartbeat not installed — skip heartbeat commands
+    }
+  }
+
   /**
    * Auto-discover and register command files from app/Console/Commands/.
    * Each file must export a class that extends Command.
@@ -55,11 +152,24 @@ export class Kernel {
       // Directory doesn't exist — no commands to discover
     }
 
+    // Collect commands registered by service providers via CommandRegistry
+    for (const cmd of getRegisteredCommands()) {
+      if (!this.commands.has(cmd.name)) {
+        this.register(cmd)
+      }
+    }
+
     this.discovered = true
     return this
   }
 
   async run(argv: string[] = process.argv): Promise<number> {
+    if (!this.builtinsRegistered) {
+      this.registerBuiltins()
+      await this.registerPackageCommands()
+      this.builtinsRegistered = true
+    }
+
     await this.discover()
     const parsed = parse(argv)
 

package/src/index.ts

@@ -7,6 +7,9 @@ export { IO } from './IO.ts'
 export { parse } from './Parser.ts'
 export type { ParsedArgs } from './Parser.ts'
 
+// Command Registry (service providers register commands here)
+export { registerCommand, registerCommands, getRegisteredCommands, clearRegisteredCommands } from './CommandRegistry.ts'
+
 // Base
 export { GeneratorCommand } from './commands/GeneratorCommand.ts'