@mantiq/cli 0.1.6 → 0.2.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantiq/cli",
-  "version": "0.1.6",
+  "version": "0.2.0-rc.2",
   "description": "Command runner, code generators, dev server",
   "type": "module",
   "license": "MIT",
@@ -43,14 +43,16 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --packages=external",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   },
   "devDependencies": {
     "bun-types": "latest",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "@mantiq/core": "workspace:*",
+    "@mantiq/database": "workspace:*"
   },
   "peerDependencies": {
     "@mantiq/core": "^0.1.0",

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/commands/MakeJobCommand.ts

@@ -0,0 +1,34 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeJobCommand extends GeneratorCommand {
+  override name = 'make:job'
+  override description = 'Create a new job class'
+  override usage = 'make:job <name>'
+
+  override directory() { return 'app/Jobs' }
+  override suffix() { return '' }
+
+  override stub(name: string): string {
+    return `import { Job } from '@mantiq/queue'
+
+export class ${name} extends Job {
+  override tries = 3
+  override backoff = 10
+
+  constructor(public readonly data: Record<string, any> = {}) {
+    super()
+  }
+
+  override async handle(): Promise<void> {
+    // TODO: implement ${name} job logic
+  }
+
+  override async failed(error: Error): Promise<void> {
+    // TODO: handle failure (e.g., log, notify)
+    console.error(\`${name} failed: \${error.message}\`)
+  }
+}
+`
+  }
+}

package/src/commands/MakeMailCommand.ts

@@ -0,0 +1,34 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeMailCommand extends GeneratorCommand {
+  override name = 'make:mail'
+  override description = 'Create a new mailable class'
+  override usage = 'make:mail <name>'
+
+  override directory() { return 'app/Mail' }
+  override suffix() { return '' }
+
+  override stub(name: string): string {
+    return `import { Mailable } from '@mantiq/mail'
+
+export class ${name} extends Mailable {
+  constructor(private readonly data: Record<string, any> = {}) {
+    super()
+  }
+
+  override build(): void {
+    this.setSubject('${this.toSubject(name)}')
+    this.html(\`
+      <h1>${this.toSubject(name)}</h1>
+      <p>This is the ${name} mailable.</p>
+    \`)
+  }
+}
+`
+  }
+
+  private toSubject(name: string): string {
+    return name.replace(/([A-Z])/g, ' $1').trim()
+  }
+}

package/src/commands/MakeNotificationCommand.ts

@@ -0,0 +1,49 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeNotificationCommand extends GeneratorCommand {
+  override name = 'make:notification'
+  override description = 'Create a new notification class'
+  override usage = 'make:notification <name>'
+
+  override directory() { return 'app/Notifications' }
+  override suffix() { return '' }
+
+  override stub(name: string): string {
+    return `import { Notification } from '@mantiq/notify'
+import type { Notifiable } from '@mantiq/notify'
+
+export class ${name} extends Notification {
+  constructor(private readonly data: Record<string, any> = {}) {
+    super()
+  }
+
+  override via(notifiable: Notifiable): string[] {
+    return ['mail', 'database']
+  }
+
+  override toMail(notifiable: Notifiable): any {
+    return {
+      subject: '${this.toSubject(name)}',
+      html: '<p>${this.toSubject(name)}</p>',
+    }
+  }
+
+  override toDatabase(notifiable: Notifiable): Record<string, any> {
+    return {
+      type: '${this.toSnake(name)}',
+      ...this.data,
+    }
+  }
+}
+`
+  }
+
+  private toSubject(name: string): string {
+    return name.replace(/([A-Z])/g, ' $1').trim()
+  }
+
+  private toSnake(name: string): string {
+    return name.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '')
+  }
+}

package/src/commands/MakePolicyCommand.ts

@@ -0,0 +1,47 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakePolicyCommand extends GeneratorCommand {
+  override name = 'make:policy'
+  override description = 'Create a new policy class'
+  override usage = 'make:policy <name> [--model=ModelName]'
+
+  override directory() { return 'app/Policies' }
+  override suffix() { return 'Policy' }
+
+  override stub(name: string, args: ParsedArgs): string {
+    const modelName = (args.flags['model'] as string) ?? name
+    const modelImport = `import { ${modelName} } from '../Models/${modelName}.ts'`
+
+    return `import { Policy } from '@mantiq/auth'
+${modelImport}
+
+export class ${name}Policy extends Policy {
+  /**
+   * Called before any other policy method.
+   * Return true to allow, false to deny, null to continue to the specific check.
+   */
+  // before(user: any, ability: string): boolean | null {
+  //   if (user.role === 'admin') return true
+  //   return null
+  // }
+
+  view(user: any, ${modelName.toLowerCase()}: ${modelName}): boolean {
+    return true
+  }
+
+  create(user: any): boolean {
+    return true
+  }
+
+  update(user: any, ${modelName.toLowerCase()}: ${modelName}): boolean {
+    return user.getAuthIdentifier() === ${modelName.toLowerCase()}.getAttribute('user_id')
+  }
+
+  delete(user: any, ${modelName.toLowerCase()}: ${modelName}): boolean {
+    return user.getAuthIdentifier() === ${modelName.toLowerCase()}.getAttribute('user_id')
+  }
+}
+`
+  }
+}

package/src/commands/TinkerCommand.ts

@@ -74,6 +74,20 @@ export class TinkerCommand extends Command {
       }
     }
 
+    // ── Auto-import factories ─────────────────────────────────────────────
+    const factoriesDir = `${process.cwd()}/database/factories`
+    if (existsSync(factoriesDir)) {
+      const files = readdirSync(factoriesDir).filter((f) => f.endsWith('.ts'))
+      for (const file of files) {
+        try {
+          const mod = await import(`${factoriesDir}/${file}`)
+          const name = file.replace(/\.ts$/, '')
+          const cls = mod[name] ?? mod.default ?? Object.values(mod)[0]
+          if (cls) context[name] = cls
+        } catch {}
+      }
+    }
+
     // ── Assign to globalThis ─────────────────────────────────────────────
     for (const [key, value] of Object.entries(context)) {
       ;(globalThis as any)[key] = value

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'
 
@@ -34,6 +37,10 @@ export { MakeRequestCommand } from './commands/MakeRequestCommand.ts'
 export { MakeRuleCommand } from './commands/MakeRuleCommand.ts'
 export { MakeSeederCommand } from './commands/MakeSeederCommand.ts'
 export { MakeTestCommand } from './commands/MakeTestCommand.ts'
+export { MakeMailCommand } from './commands/MakeMailCommand.ts'
+export { MakeNotificationCommand } from './commands/MakeNotificationCommand.ts'
+export { MakeJobCommand } from './commands/MakeJobCommand.ts'
+export { MakePolicyCommand } from './commands/MakePolicyCommand.ts'
 
 // Utility commands
 export { AboutCommand } from './commands/AboutCommand.ts'