@mantiq/cli 0.0.1

package/src/commands/MigrateResetCommand.ts

@@ -0,0 +1,33 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { Migrator } from '@mantiq/database'
+import { getManager } from '@mantiq/database'
+
+export class MigrateResetCommand extends Command {
+  override name = 'migrate:reset'
+  override description = 'Rollback all migrations'
+
+  override async handle(args: ParsedArgs): Promise<number> {
+    if (!args.flags['force'] && process.env['APP_ENV'] === 'production') {
+      this.io.error('Use --force to run in production.')
+      return 1
+    }
+
+    const connection = getManager().connection()
+    const migrator = new Migrator(connection, { migrationsPath: `${process.cwd()}/database/migrations` })
+
+    this.io.info('Resetting all migrations...')
+    const rolled = await migrator.reset()
+
+    if (rolled.length === 0) {
+      this.io.success('Nothing to reset.')
+    } else {
+      for (const name of rolled) {
+        this.io.twoColumn(`  ${this.io.yellow('ROLLED BACK')}`, name, 16)
+      }
+      this.io.newLine()
+      this.io.success(`Reset ${rolled.length} migration${rolled.length > 1 ? 's' : ''}.`)
+    }
+    return 0
+  }
+}

package/src/commands/MigrateRollbackCommand.ts

@@ -0,0 +1,28 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { Migrator } from '@mantiq/database'
+import { getManager } from '@mantiq/database'
+
+export class MigrateRollbackCommand extends Command {
+  override name = 'migrate:rollback'
+  override description = 'Rollback the last batch of migrations'
+
+  override async handle(_args: ParsedArgs): Promise<number> {
+    const connection = getManager().connection()
+    const migrator = new Migrator(connection, { migrationsPath: `${process.cwd()}/database/migrations` })
+
+    this.io.info('Rolling back last batch...')
+    const rolled = await migrator.rollback()
+
+    if (rolled.length === 0) {
+      this.io.success('Nothing to rollback.')
+    } else {
+      for (const name of rolled) {
+        this.io.twoColumn(`  ${this.io.yellow('ROLLED BACK')}`, name, 16)
+      }
+      this.io.newLine()
+      this.io.success(`Rolled back ${rolled.length} migration${rolled.length > 1 ? 's' : ''}.`)
+    }
+    return 0
+  }
+}

package/src/commands/MigrateStatusCommand.ts

@@ -0,0 +1,41 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { Migrator } from '@mantiq/database'
+import { getManager } from '@mantiq/database'
+
+export class MigrateStatusCommand extends Command {
+  override name = 'migrate:status'
+  override description = 'Show the status of each migration'
+
+  override async handle(_args: ParsedArgs): Promise<number> {
+    const connection = getManager().connection()
+    const migrator = new Migrator(connection, { migrationsPath: `${process.cwd()}/database/migrations` })
+
+    const statuses = await migrator.status()
+
+    if (statuses.length === 0) {
+      this.io.info('No migrations found.')
+      return 0
+    }
+
+    this.io.heading('Migration Status')
+    this.io.newLine()
+
+    this.io.table(
+      ['Status', 'Migration', 'Batch'],
+      statuses.map((s) => [
+        s.ran ? this.io.green('Ran') : this.io.yellow('Pending'),
+        s.name,
+        s.batch !== null ? String(s.batch) : '',
+      ]),
+    )
+
+    const pending = statuses.filter((s) => !s.ran).length
+    if (pending > 0) {
+      this.io.newLine()
+      this.io.info(`${pending} pending migration${pending > 1 ? 's' : ''}.`)
+    }
+
+    return 0
+  }
+}

package/src/commands/RouteListCommand.ts

@@ -0,0 +1,89 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class RouteListCommand extends Command {
+  override name = 'route:list'
+  override description = 'List all registered routes'
+  override usage = 'route:list [--method=GET] [--path=prefix]'
+
+  override async handle(args: ParsedArgs): Promise<number> {
+    try {
+      const entryPath = `${process.cwd()}/index.ts`
+      const mod = await import(entryPath)
+
+      const app = mod.default ?? mod.app
+      if (!app) {
+        this.io.error('No default export or "app" export found in index.ts')
+        return 1
+      }
+
+      // Resolve the router from the container
+      let router: any = null
+      try {
+        const { RouterImpl } = await import('@mantiq/core')
+        router = app.make?.(RouterImpl)
+      } catch {}
+      if (!router) {
+        try { router = app.make?.('router') } catch {}
+      }
+      if (!router || typeof router.routes !== 'function') {
+        this.io.error('Could not resolve router from the application container.')
+        return 1
+      }
+
+      let routes: any[] = router.routes()
+
+      // Filter by method
+      const methodFilter = args.flags['method'] as string | undefined
+      if (methodFilter) {
+        const m = methodFilter.toUpperCase()
+        routes = routes.filter((r: any) => r.method === m)
+      }
+
+      // Filter by path prefix
+      const pathFilter = args.flags['path'] as string | undefined
+      if (pathFilter) {
+        routes = routes.filter((r: any) => r.path.startsWith(pathFilter))
+      }
+
+      if (routes.length === 0) {
+        this.io.info('No routes found.')
+        return 0
+      }
+
+      this.io.heading('Registered Routes')
+      this.io.newLine()
+
+      this.io.table(
+        ['Method', 'Path', 'Name', 'Middleware'],
+        routes.map((r: any) => {
+          const method = Array.isArray(r.method) ? r.method.join('|') : String(r.method)
+          return [
+            this.colorMethod(method),
+            r.path,
+            r.name ?? '',
+            Array.isArray(r.middleware) ? r.middleware.join(', ') : (r.middleware ?? ''),
+          ]
+        }),
+      )
+
+      this.io.newLine()
+      this.io.muted(`  Showing ${routes.length} route${routes.length !== 1 ? 's' : ''}`)
+      return 0
+    } catch (e: any) {
+      this.io.error(e.message ?? String(e))
+      return 1
+    }
+  }
+
+  private colorMethod(method: string): string {
+    switch (method) {
+      case 'GET': return this.io.green(method)
+      case 'POST': return this.io.cyan(method)
+      case 'PUT': return this.io.yellow(method)
+      case 'PATCH': return this.io.yellow(method)
+      case 'DELETE': return this.io.red(method)
+      default: return method
+    }
+  }
+}

package/src/commands/SeedCommand.ts

@@ -0,0 +1,42 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { getManager } from '@mantiq/database'
+
+export class SeedCommand extends Command {
+  override name = 'seed'
+  override description = 'Run database seeders'
+  override usage = 'seed [SeederName]'
+
+  override async handle(args: ParsedArgs): Promise<number> {
+    const connection = getManager().connection()
+    const seederName = args.args[0] ?? 'DatabaseSeeder'
+    const seedersDir = `${process.cwd()}/database/seeders`
+
+    this.io.info(`Seeding: ${seederName}...`)
+
+    try {
+      const mod = await import(`${seedersDir}/${seederName}.ts`)
+      const SeederClass = mod.default
+      if (!SeederClass) {
+        this.io.error(`No default export found in ${seederName}.ts`)
+        return 1
+      }
+
+      const seeder = new SeederClass()
+      if (typeof seeder.setConnection === 'function') {
+        seeder.setConnection(connection)
+      }
+      await seeder.run()
+
+      this.io.success(`${seederName} completed.`)
+      return 0
+    } catch (e: any) {
+      if (e.code === 'ERR_MODULE_NOT_FOUND' || e.message?.includes('Cannot find module')) {
+        this.io.error(`Seeder not found: ${seedersDir}/${seederName}.ts`)
+      } else {
+        this.io.error(e.message)
+      }
+      return 1
+    }
+  }
+}

package/src/commands/ServeCommand.ts

@@ -0,0 +1,43 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class ServeCommand extends Command {
+  override name = 'serve'
+  override description = 'Start the development server'
+  override usage = 'serve [--port=3000] [--host=0.0.0.0]'
+
+  override async handle(args: ParsedArgs): Promise<number> {
+    const port = args.flags['port'] ? Number(args.flags['port']) : undefined
+    const host = args.flags['host'] as string | undefined
+
+    try {
+      // Load the app entry point
+      const entryPath = `${process.cwd()}/index.ts`
+      const mod = await import(entryPath)
+
+      const app = mod.default ?? mod.app
+      if (!app) {
+        this.io.error('No default export or "app" export found in index.ts')
+        return 1
+      }
+
+      // Resolve the HTTP kernel and start serving
+      const kernel = app.make?.('HttpKernel') ?? app.make?.('httpKernel')
+      if (!kernel) {
+        this.io.error('Could not resolve HttpKernel from the application container.')
+        return 1
+      }
+
+      // Override port/host if provided via flags
+      if (port) app.make?.('config')?.set?.('app.port', port)
+      if (host) app.make?.('config')?.set?.('app.host', host)
+
+      await kernel.start()
+      // Server is now running — keep process alive
+      return new Promise(() => {}) // never resolves, keeps the process running
+    } catch (e: any) {
+      this.io.error(e.message ?? String(e))
+      return 1
+    }
+  }
+}

package/src/commands/TinkerCommand.ts

@@ -0,0 +1,261 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { createInterface } from 'node:readline'
+import { readdirSync, existsSync } from 'node:fs'
+
+/**
+ * Interactive REPL with the full application context loaded.
+ * Like Laravel's `php artisan tinker`.
+ */
+export class TinkerCommand extends Command {
+  override name = 'tinker'
+  override description = 'Interact with your application (REPL)'
+  override usage = 'tinker'
+
+  override async handle(_args: ParsedArgs): Promise<number> {
+    // ── Bootstrap the app ──────────────────────────────────────────────────
+    let app: any = null
+    const context: Record<string, any> = {}
+
+    try {
+      const entryPath = `${process.cwd()}/index.ts`
+      const mod = await import(entryPath)
+      app = mod.default ?? mod.app
+    } catch (e: any) {
+      this.io.warn(`Could not load app: ${e.message}`)
+    }
+
+    if (app) {
+      context['app'] = app
+
+      // Resolve core services
+      try {
+        const core = await import('@mantiq/core')
+        const tryMake = (key: any, name: string) => {
+          try { const v = app.make(key); if (v) context[name] = v } catch {}
+        }
+        tryMake(core.RouterImpl, 'router')
+        tryMake(core.ConfigRepository, 'config')
+        tryMake(core.HashManager, 'hash')
+        tryMake(core.CacheManager, 'cache')
+        tryMake(core.SessionManager, 'session')
+        tryMake(core.AesEncrypter, 'encrypter')
+      } catch {}
+
+      // Resolve database
+      try {
+        const db = await import('@mantiq/database')
+        if (db.getManager) {
+          const manager = db.getManager()
+          context['db'] = manager
+          context['connection'] = manager.connection()
+        }
+      } catch {}
+
+      // Resolve auth
+      try {
+        const auth = await import('@mantiq/auth')
+        if (auth.auth) context['auth'] = auth.auth
+      } catch {}
+    }
+
+    // ── Auto-import models ───────────────────────────────────────────────
+    const modelsDir = `${process.cwd()}/app/Models`
+    if (existsSync(modelsDir)) {
+      const files = readdirSync(modelsDir).filter((f) => f.endsWith('.ts'))
+      for (const file of files) {
+        try {
+          const mod = await import(`${modelsDir}/${file}`)
+          const name = file.replace(/\.ts$/, '')
+          // Export the class (named export matching filename, or first export)
+          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
+    }
+
+    // ── Print banner ─────────────────────────────────────────────────────
+    this.io.heading('MantiqJS Tinker')
+    this.io.muted('  Interactive REPL — type expressions, use await for async.')
+    this.io.muted('  Type .help for commands, .exit to quit.\n')
+
+    if (Object.keys(context).length > 0) {
+      this.io.info('Available in scope:')
+      const items = Object.keys(context)
+      const perLine = 6
+      for (let i = 0; i < items.length; i += perLine) {
+        const chunk = items.slice(i, i + perLine)
+        this.io.line(`    ${chunk.map((k) => this.io.cyan(k)).join(', ')}`)
+      }
+      this.io.newLine()
+    }
+
+    // ── REPL loop ────────────────────────────────────────────────────────
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: '\x1b[35m>\x1b[0m ',
+      historySize: 200,
+    })
+
+    let multiLine = ''
+    let multiLineMode = false
+
+    const evaluate = async (input: string) => {
+      const trimmed = input.trim()
+      if (!trimmed) return
+
+      // Dot commands
+      if (trimmed === '.exit' || trimmed === '.quit') {
+        rl.close()
+        return
+      }
+      if (trimmed === '.help') {
+        this.io.line('  .exit       Exit the REPL')
+        this.io.line('  .clear      Clear the terminal')
+        this.io.line('  .models     List loaded models')
+        this.io.line('  .services   List available services')
+        this.io.line('')
+        return
+      }
+      if (trimmed === '.clear') {
+        process.stdout.write('\x1b[2J\x1b[H')
+        return
+      }
+      if (trimmed === '.models') {
+        const modelFiles = existsSync(modelsDir)
+          ? readdirSync(modelsDir).filter((f) => f.endsWith('.ts')).map((f) => f.replace(/\.ts$/, ''))
+          : []
+        if (modelFiles.length) {
+          this.io.line(`  ${modelFiles.map((m) => this.io.cyan(m)).join(', ')}`)
+        } else {
+          this.io.muted('  No models found.')
+        }
+        return
+      }
+      if (trimmed === '.services') {
+        const svcs = Object.keys(context).filter((k) => !['app'].includes(k) && typeof context[k] !== 'function' || k === 'auth')
+        this.io.line(`  ${svcs.map((s) => this.io.cyan(s)).join(', ')}`)
+        return
+      }
+
+      try {
+        // Wrap in async to support top-level await
+        const code = `(async () => { return (${trimmed}) })()`
+        const result = await eval(code)
+
+        if (result !== undefined) {
+          this.printResult(result)
+        }
+      } catch {
+        // Retry as statement (not expression)
+        try {
+          const code = `(async () => { ${trimmed} })()`
+          const result = await eval(code)
+          if (result !== undefined) {
+            this.printResult(result)
+          }
+        } catch (e2: any) {
+          this.io.error(e2.message ?? String(e2))
+        }
+      }
+    }
+
+    rl.prompt()
+
+    return new Promise<number>((resolve) => {
+      rl.on('line', async (line) => {
+        const trimmed = line.trimEnd()
+
+        // Multiline: if line ends with \, accumulate
+        if (trimmed.endsWith('\\')) {
+          multiLine += trimmed.slice(0, -1) + '\n'
+          multiLineMode = true
+          process.stdout.write('\x1b[35m…\x1b[0m ')
+          return
+        }
+
+        if (multiLineMode) {
+          multiLine += line
+          multiLineMode = false
+          await evaluate(multiLine)
+          multiLine = ''
+        } else {
+          await evaluate(line)
+        }
+
+        rl.prompt()
+      })
+
+      rl.on('close', () => {
+        this.io.newLine()
+        this.io.muted('  Goodbye.')
+        resolve(0)
+      })
+    })
+  }
+
+  private printResult(value: any): void {
+    if (value === null) {
+      this.io.line(`\x1b[90mnull\x1b[0m`)
+      return
+    }
+    if (value === undefined) return
+
+    // Model instances — show as object
+    if (value && typeof value === 'object' && typeof value.toObject === 'function') {
+      try {
+        const obj = value.toObject()
+        this.io.line(this.formatObject(obj))
+        return
+      } catch {}
+    }
+
+    // Arrays of models
+    if (Array.isArray(value) && value.length > 0 && typeof value[0]?.toObject === 'function') {
+      try {
+        const arr = value.map((v: any) => v.toObject())
+        this.io.line(this.formatObject(arr))
+        return
+      } catch {}
+    }
+
+    // Plain objects/arrays
+    if (typeof value === 'object') {
+      this.io.line(this.formatObject(value))
+      return
+    }
+
+    // Primitives
+    if (typeof value === 'string') {
+      this.io.line(`\x1b[32m'${value}'\x1b[0m`)
+    } else if (typeof value === 'number' || typeof value === 'bigint') {
+      this.io.line(`\x1b[33m${value}\x1b[0m`)
+    } else if (typeof value === 'boolean') {
+      this.io.line(`\x1b[33m${value}\x1b[0m`)
+    } else if (typeof value === 'function') {
+      this.io.line(`\x1b[36m[Function: ${value.name || 'anonymous'}]\x1b[0m`)
+    } else {
+      this.io.line(String(value))
+    }
+  }
+
+  private formatObject(obj: any, indent = 0): string {
+    try {
+      const json = JSON.stringify(obj, null, 2)
+      // Colorize JSON output
+      return json
+        .replace(/"([^"]+)":/g, `\x1b[36m"$1"\x1b[0m:`)
+        .replace(/: "([^"]*)"/g, `: \x1b[32m"$1"\x1b[0m`)
+        .replace(/: (\d+)/g, `: \x1b[33m$1\x1b[0m`)
+        .replace(/: (true|false|null)/g, `: \x1b[33m$1\x1b[0m`)
+    } catch {
+      return String(obj)
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+// @mantiq/cli — public API exports
+
+// Core
+export { Command } from './Command.ts'
+export { Kernel } from './Kernel.ts'
+export { IO } from './IO.ts'
+export { parse } from './Parser.ts'
+export type { ParsedArgs } from './Parser.ts'
+
+// Base
+export { GeneratorCommand } from './commands/GeneratorCommand.ts'
+
+// Database commands
+export { MigrateCommand } from './commands/MigrateCommand.ts'
+export { MigrateRollbackCommand } from './commands/MigrateRollbackCommand.ts'
+export { MigrateResetCommand } from './commands/MigrateResetCommand.ts'
+export { MigrateFreshCommand } from './commands/MigrateFreshCommand.ts'
+export { MigrateStatusCommand } from './commands/MigrateStatusCommand.ts'
+export { SeedCommand } from './commands/SeedCommand.ts'
+
+// Generator commands
+export { MakeCommandCommand } from './commands/MakeCommandCommand.ts'
+export { MakeControllerCommand } from './commands/MakeControllerCommand.ts'
+export { MakeEventCommand } from './commands/MakeEventCommand.ts'
+export { MakeExceptionCommand } from './commands/MakeExceptionCommand.ts'
+export { MakeFactoryCommand } from './commands/MakeFactoryCommand.ts'
+export { MakeListenerCommand } from './commands/MakeListenerCommand.ts'
+export { MakeMiddlewareCommand } from './commands/MakeMiddlewareCommand.ts'
+export { MakeMigrationCommand } from './commands/MakeMigrationCommand.ts'
+export { MakeModelCommand } from './commands/MakeModelCommand.ts'
+export { MakeObserverCommand } from './commands/MakeObserverCommand.ts'
+export { MakeProviderCommand } from './commands/MakeProviderCommand.ts'
+export { MakeRequestCommand } from './commands/MakeRequestCommand.ts'
+export { MakeRuleCommand } from './commands/MakeRuleCommand.ts'
+export { MakeSeederCommand } from './commands/MakeSeederCommand.ts'
+export { MakeTestCommand } from './commands/MakeTestCommand.ts'
+
+// Utility commands
+export { AboutCommand } from './commands/AboutCommand.ts'
+export { ServeCommand } from './commands/ServeCommand.ts'
+export { RouteListCommand } from './commands/RouteListCommand.ts'
+export { TinkerCommand } from './commands/TinkerCommand.ts'