@mantiq/cli 0.0.1

package/README.md

@@ -0,0 +1,19 @@
+# @mantiq/cli
+
+Command kernel, code generators, database commands, REPL, and route listing for MantiqJS.
+
+Part of [MantiqJS](https://github.com/abdullahkhan/mantiq) — a batteries-included TypeScript web framework for Bun.
+
+## Installation
+
+```bash
+bun add @mantiq/cli
+```
+
+## Documentation
+
+See the [MantiqJS repository](https://github.com/abdullahkhan/mantiq) for full documentation.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@mantiq/cli",
+  "version": "0.0.1",
+  "description": "Command runner, code generators, dev server",
+  "type": "module",
+  "license": "MIT",
+  "author": "Abdullah Khan",
+  "homepage": "https://github.com/abdullahkhan/mantiq/tree/main/packages/cli",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/abdullahkhan/mantiq.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/abdullahkhan/mantiq/issues"
+  },
+  "keywords": [
+    "mantiq",
+    "mantiqjs",
+    "bun",
+    "typescript",
+    "framework",
+    "cli"
+  ],
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "bin": {
+    "mantiq": "./src/bin.ts"
+  },
+  "files": [
+    "src/",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@mantiq/core": "workspace:*",
+    "@mantiq/database": "workspace:*"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "typescript": "^5.7.0"
+  }
+}

package/src/Command.ts

@@ -0,0 +1,24 @@
+import { IO } from './IO.ts'
+import type { ParsedArgs } from './Parser.ts'
+
+/**
+ * Base class for all CLI commands.
+ */
+export abstract class Command {
+  /** Command name, e.g. 'migrate', 'make:model' */
+  abstract name: string
+
+  /** Short description shown in help */
+  abstract description: string
+
+  /** Usage hint, e.g. 'make:model <name> [--migration]' */
+  usage?: string
+
+  protected io = new IO()
+
+  /**
+   * Execute the command.
+   * @returns exit code (0 = success)
+   */
+  abstract handle(args: ParsedArgs): Promise<number>
+}

package/src/IO.ts

@@ -0,0 +1,96 @@
+/**
+ * Terminal output helpers with ANSI colors.
+ * Zero dependencies — uses escape codes directly.
+ */
+
+const ESC = '\x1b['
+const RESET = `${ESC}0m`
+const BOLD = `${ESC}1m`
+const DIM = `${ESC}2m`
+
+const FG = {
+  red: `${ESC}31m`,
+  green: `${ESC}32m`,
+  yellow: `${ESC}33m`,
+  blue: `${ESC}34m`,
+  magenta: `${ESC}35m`,
+  cyan: `${ESC}36m`,
+  white: `${ESC}37m`,
+  gray: `${ESC}90m`,
+} as const
+
+export class IO {
+  info(msg: string): void {
+    console.log(`${FG.blue}  INFO${RESET}  ${msg}`)
+  }
+
+  success(msg: string): void {
+    console.log(`${FG.green}  DONE${RESET}  ${msg}`)
+  }
+
+  error(msg: string): void {
+    console.error(`${FG.red}  ERROR${RESET} ${msg}`)
+  }
+
+  warn(msg: string): void {
+    console.log(`${FG.yellow}  WARN${RESET}  ${msg}`)
+  }
+
+  line(msg = ''): void {
+    console.log(msg)
+  }
+
+  newLine(): void {
+    console.log()
+  }
+
+  /** Bold heading */
+  heading(msg: string): void {
+    console.log(`\n${BOLD}${msg}${RESET}`)
+  }
+
+  /** Dim/muted text */
+  muted(msg: string): void {
+    console.log(`${DIM}${msg}${RESET}`)
+  }
+
+  /** Colorize inline text */
+  green(msg: string): string { return `${FG.green}${msg}${RESET}` }
+  red(msg: string): string { return `${FG.red}${msg}${RESET}` }
+  yellow(msg: string): string { return `${FG.yellow}${msg}${RESET}` }
+  cyan(msg: string): string { return `${FG.cyan}${msg}${RESET}` }
+  gray(msg: string): string { return `${FG.gray}${msg}${RESET}` }
+  bold(msg: string): string { return `${BOLD}${msg}${RESET}` }
+
+  /** Print a table with aligned columns */
+  table(headers: string[], rows: string[][]): void {
+    // Strip ANSI codes for width calculation
+    const strip = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, '')
+
+    const widths = headers.map((h, i) =>
+      Math.max(strip(h).length, ...rows.map((r) => strip(r[i] ?? '').length)),
+    )
+
+    const sep = widths.map((w) => '-'.repeat(w + 2)).join('+')
+    const formatRow = (row: string[]) =>
+      row.map((cell, i) => {
+        const pad = widths[i]! - strip(cell).length
+        return ` ${cell}${' '.repeat(Math.max(0, pad))} `
+      }).join('|')
+
+    this.line(`  ${FG.gray}${sep}${RESET}`)
+    this.line(`  ${BOLD}${formatRow(headers)}${RESET}`)
+    this.line(`  ${FG.gray}${sep}${RESET}`)
+    for (const row of rows) {
+      this.line(`  ${formatRow(row)}`)
+    }
+    this.line(`  ${FG.gray}${sep}${RESET}`)
+  }
+
+  /** Simple two-column display like Laravel */
+  twoColumn(label: string, value: string, width = 30): void {
+    this.line(`  ${label.padEnd(width)} ${FG.gray}${value}${RESET}`)
+  }
+}
+
+export const io = new IO()

package/src/Kernel.ts

@@ -0,0 +1,84 @@
+import type { Command } from './Command.ts'
+import { parse, type ParsedArgs } from './Parser.ts'
+import { IO } from './IO.ts'
+
+/**
+ * The CLI Kernel — registers commands and dispatches to the right one.
+ */
+export class Kernel {
+  private commands = new Map<string, Command>()
+  private io = new IO()
+
+  constructor(public readonly app: any = null) {}
+
+  register(command: Command): this {
+    this.commands.set(command.name, command)
+    return this
+  }
+
+  registerAll(commands: Command[]): this {
+    for (const cmd of commands) this.register(cmd)
+    return this
+  }
+
+  async run(argv: string[] = process.argv): Promise<number> {
+    const parsed = parse(argv)
+
+    if (parsed.command === 'help' || parsed.command === '--help' || parsed.command === '-h' || parsed.flags['help'] || parsed.flags['h']) {
+      this.showHelp(parsed)
+      return 0
+    }
+
+    const command = this.commands.get(parsed.command)
+    if (!command) {
+      this.io.error(`Command "${parsed.command}" not found.`)
+      this.io.newLine()
+      this.showHelp(parsed)
+      return 1
+    }
+
+    try {
+      return await command.handle(parsed)
+    } catch (e: any) {
+      this.io.error(e.message ?? String(e))
+      if (process.env['APP_DEBUG'] === 'true') {
+        this.io.line(e.stack ?? '')
+      }
+      return 1
+    }
+  }
+
+  private showHelp(_parsed: ParsedArgs): void {
+    this.io.heading('MantiqJS CLI')
+    this.io.newLine()
+    this.io.line('  Usage: mantiq <command> [arguments] [options]')
+    this.io.newLine()
+
+    // Group commands by prefix
+    const groups = new Map<string, Command[]>()
+    for (const cmd of this.commands.values()) {
+      const prefix = cmd.name.includes(':') ? cmd.name.split(':')[0]! : ''
+      if (!groups.has(prefix)) groups.set(prefix, [])
+      groups.get(prefix)!.push(cmd)
+    }
+
+    // Sort groups: top-level first, then alphabetical
+    const sortedGroups = [...groups.entries()].sort((a, b) => {
+      if (a[0] === '' && b[0] !== '') return -1
+      if (a[0] !== '' && b[0] === '') return 1
+      return a[0].localeCompare(b[0])
+    })
+
+    for (const [prefix, cmds] of sortedGroups) {
+      if (prefix) {
+        this.io.line(`  ${this.io.yellow(prefix)}`)
+      }
+      const sorted = cmds.sort((a, b) => a.name.localeCompare(b.name))
+      for (const cmd of sorted) {
+        this.io.twoColumn(`    ${this.io.green(cmd.name)}`, cmd.description, 30)
+      }
+    }
+
+    this.io.newLine()
+  }
+}

package/src/Parser.ts

@@ -0,0 +1,62 @@
+/**
+ * Lightweight argument parser for CLI commands.
+ * Parses process.argv into command name, positional args, and flags.
+ *
+ * @example
+ *   // bun mantiq make:model User -m --table=users
+ *   parse(['make:model', 'User', '-m', '--table=users'])
+ *   // => { command: 'make:model', args: ['User'], flags: { m: true, table: 'users' } }
+ */
+
+export interface ParsedArgs {
+  /** The command name (e.g. 'migrate', 'make:model') */
+  command: string
+  /** Positional arguments after the command */
+  args: string[]
+  /** Named flags — boolean for switches, string for --key=value */
+  flags: Record<string, string | boolean>
+}
+
+export function parse(argv: string[]): ParsedArgs {
+  // Skip bun/node executable and script path
+  const raw = argv.slice(2)
+
+  const command = raw[0] ?? 'help'
+  const args: string[] = []
+  const flags: Record<string, string | boolean> = {}
+
+  for (let i = 1; i < raw.length; i++) {
+    const arg = raw[i]!
+
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=')
+      if (eqIdx !== -1) {
+        flags[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1)
+      } else {
+        // Check if next arg is the value (not another flag)
+        const key = arg.slice(2)
+        const next = raw[i + 1]
+        if (next && !next.startsWith('-')) {
+          flags[key] = next
+          i++
+        } else {
+          flags[key] = true
+        }
+      }
+    } else if (arg.startsWith('-') && arg.length === 2) {
+      // Short flag: -m, -f, -p 8080, etc.
+      const key = arg[1]!
+      const next = raw[i + 1]
+      if (next && !next.startsWith('-')) {
+        flags[key] = next
+        i++
+      } else {
+        flags[key] = true
+      }
+    } else {
+      args.push(arg)
+    }
+  }
+
+  return { command, args, flags }
+}

package/src/bin.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+import { Kernel } from './Kernel.ts'
+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'
+import { MakeControllerCommand } from './commands/MakeControllerCommand.ts'
+import { MakeModelCommand } from './commands/MakeModelCommand.ts'
+import { MakeMigrationCommand } from './commands/MakeMigrationCommand.ts'
+import { MakeSeederCommand } from './commands/MakeSeederCommand.ts'
+import { MakeFactoryCommand } from './commands/MakeFactoryCommand.ts'
+import { MakeMiddlewareCommand } from './commands/MakeMiddlewareCommand.ts'
+import { MakeRequestCommand } from './commands/MakeRequestCommand.ts'
+import { ServeCommand } from './commands/ServeCommand.ts'
+import { RouteListCommand } from './commands/RouteListCommand.ts'
+import { TinkerCommand } from './commands/TinkerCommand.ts'
+
+async function main() {
+  // Try to bootstrap the application if an index.ts exists
+  let app: any = null
+  try {
+    const entryPath = `${process.cwd()}/index.ts`
+    const mod = await import(entryPath)
+    app = mod.default ?? mod.app ?? null
+  } catch {
+    // No app entry — that's fine for make:* commands
+  }
+
+  const kernel = new Kernel(app)
+
+  kernel.registerAll([
+    // Database
+    new MigrateCommand(),
+    new MigrateRollbackCommand(),
+    new MigrateResetCommand(),
+    new MigrateFreshCommand(),
+    new MigrateStatusCommand(),
+    new SeedCommand(),
+
+    // Generators
+    new MakeControllerCommand(),
+    new MakeModelCommand(),
+    new MakeMigrationCommand(),
+    new MakeSeederCommand(),
+    new MakeFactoryCommand(),
+    new MakeMiddlewareCommand(),
+    new MakeRequestCommand(),
+
+    // Utility
+    new ServeCommand(),
+    new RouteListCommand(),
+    new TinkerCommand(),
+  ])
+
+  const code = await kernel.run()
+  process.exit(code)
+}
+
+main()

package/src/commands/AboutCommand.ts

@@ -0,0 +1,73 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class AboutCommand extends Command {
+  override name = 'about'
+  override description = 'Display information about the framework'
+
+  override async handle(_args: ParsedArgs): Promise<number> {
+    const env = process.env
+
+    this.io.heading('MantiqJS Framework')
+    this.io.line('')
+
+    // Environment
+    this.io.info('  Environment')
+    this.io.line('')
+    this.printRow('Application Name', env.APP_NAME || 'MantiqJS')
+    this.printRow('Environment', env.APP_ENV || 'production')
+    this.printRow('Debug Mode', env.APP_DEBUG === 'true' ? this.io.yellow('ENABLED') : 'disabled')
+    this.printRow('URL', env.APP_URL || 'http://localhost:3000')
+    this.printRow('Port', env.APP_PORT || '3000')
+    this.io.line('')
+
+    // Runtime
+    this.io.info('  Runtime')
+    this.io.line('')
+    this.printRow('Bun', Bun.version)
+    this.printRow('TypeScript', 'ESNext')
+    this.printRow('Platform', `${process.platform} ${process.arch}`)
+    this.printRow('PID', String(process.pid))
+    this.printRow('Memory', `${Math.round(process.memoryUsage.rss() / 1024 / 1024)} MB RSS`)
+    this.io.line('')
+
+    // Database
+    this.io.info('  Database')
+    this.io.line('')
+    this.printRow('Connection', env.DB_CONNECTION || 'sqlite')
+    this.printRow('Database', env.DB_DATABASE || 'database/database.sqlite')
+    this.io.line('')
+
+    // Services
+    this.io.info('  Services')
+    this.io.line('')
+    this.printRow('Cache', env.CACHE_DRIVER || 'memory')
+    this.printRow('Queue', env.QUEUE_CONNECTION || 'sync')
+    this.printRow('Logging', env.LOG_CHANNEL || 'stack')
+    this.printRow('Session', env.SESSION_DRIVER || 'cookie')
+    this.io.line('')
+
+    // Packages
+    this.io.info('  Installed Packages')
+    this.io.line('')
+    const packages = [
+      'core', 'database', 'auth', 'cli', 'validation', 'helpers',
+      'filesystem', 'logging', 'events', 'queue', 'realtime', 'heartbeat', 'vite',
+    ]
+    for (const pkg of packages) {
+      try {
+        require.resolve(`@mantiq/${pkg}`)
+        this.io.line(`    ${this.io.green('●')} @mantiq/${pkg}`)
+      } catch {
+        this.io.line(`    ${this.io.gray('○')} @mantiq/${pkg}`)
+      }
+    }
+    this.io.line('')
+
+    return 0
+  }
+
+  private printRow(label: string, value: string): void {
+    this.io.line(`    ${this.io.gray(label.padEnd(22))} ${value}`)
+  }
+}

package/src/commands/GeneratorCommand.ts

@@ -0,0 +1,58 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { existsSync, mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+/**
+ * Base class for make:* generators.
+ * Subclasses provide the target directory, file suffix, and stub content.
+ */
+export abstract class GeneratorCommand extends Command {
+  /** Directory relative to project root, e.g. 'app/Http/Controllers' */
+  abstract directory(): string
+
+  /** File suffix, e.g. 'Controller' — will be appended to the name */
+  abstract suffix(): string
+
+  /** Generate the file content */
+  abstract stub(name: string, args: ParsedArgs): string
+
+  override async handle(args: ParsedArgs): Promise<number> {
+    const rawName = args.args[0]
+    if (!rawName) {
+      this.io.error(`Please provide a name. Usage: ${this.name} <name>`)
+      return 1
+    }
+
+    const className = this.toClassName(rawName)
+    const fileName = `${className}${this.suffix()}.ts`
+    const dir = `${process.cwd()}/${this.directory()}`
+    const filePath = `${dir}/${fileName}`
+
+    if (existsSync(filePath)) {
+      this.io.error(`${fileName} already exists.`)
+      return 1
+    }
+
+    // Ensure directory exists
+    mkdirSync(dirname(filePath), { recursive: true })
+
+    const content = this.stub(className, args)
+    await Bun.write(filePath, content)
+
+    this.io.success(`Created ${this.directory()}/${fileName}`)
+    return 0
+  }
+
+  protected toClassName(name: string): string {
+    // Remove suffix if already present
+    const sfx = this.suffix()
+    if (sfx && name.endsWith(sfx)) {
+      name = name.slice(0, -sfx.length)
+    }
+    // PascalCase: foo_bar -> FooBar, foo-bar -> FooBar
+    return name
+      .replace(/[-_]+(.)/g, (_, c) => c.toUpperCase())
+      .replace(/^(.)/, (_, c) => c.toUpperCase())
+  }
+}

package/src/commands/MakeCommandCommand.ts

@@ -0,0 +1,39 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeCommandCommand extends GeneratorCommand {
+  override name = 'make:command'
+  override description = 'Create a new CLI command class'
+  override usage = 'make:command <name>'
+
+  override directory() { return 'app/Console/Commands' }
+  override suffix() { return 'Command' }
+
+  override stub(name: string, _args: ParsedArgs): string {
+    const className = `${name}Command`
+    const cmdName = this.toCommandName(name)
+    return `import { Command } from '@mantiq/cli'
+import type { ParsedArgs } from '@mantiq/cli'
+
+export class ${className} extends Command {
+  override name = '${cmdName}'
+  override description = ''
+  override usage = '${cmdName}'
+
+  override async handle(args: ParsedArgs): Promise<number> {
+    // TODO: implement command
+    return 0
+  }
+}
+`
+  }
+
+  /** Convert PascalCase to kebab-case command name, e.g. SendEmails → app:send-emails */
+  private toCommandName(name: string): string {
+    const kebab = name
+      .replace(/([A-Z])/g, '-$1')
+      .toLowerCase()
+      .replace(/^-/, '')
+    return `app:${kebab}`
+  }
+}

package/src/commands/MakeControllerCommand.ts

@@ -0,0 +1,58 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeControllerCommand extends GeneratorCommand {
+  override name = 'make:controller'
+  override description = 'Create a new controller class'
+  override usage = 'make:controller <name> [--resource]'
+
+  override directory() { return 'app/Http/Controllers' }
+  override suffix() { return 'Controller' }
+
+  override stub(name: string, args: ParsedArgs): string {
+    const className = `${name}Controller`
+    const isResource = !!args.flags['resource'] || !!args.flags['r']
+
+    if (isResource) {
+      return `import type { MantiqRequest } from '@mantiq/core'
+import { MantiqResponse } from '@mantiq/core'
+
+export class ${className} {
+  async index(request: MantiqRequest): Promise<Response> {
+    return MantiqResponse.json({ data: [] })
+  }
+
+  async show(request: MantiqRequest): Promise<Response> {
+    const id = request.param('id')
+    return MantiqResponse.json({ data: { id } })
+  }
+
+  async store(request: MantiqRequest): Promise<Response> {
+    const body = await request.input()
+    return MantiqResponse.json({ data: body }, 201)
+  }
+
+  async update(request: MantiqRequest): Promise<Response> {
+    const id = request.param('id')
+    const body = await request.input()
+    return MantiqResponse.json({ data: { id, ...body } })
+  }
+
+  async destroy(request: MantiqRequest): Promise<Response> {
+    return MantiqResponse.noContent()
+  }
+}
+`
+    }
+
+    return `import type { MantiqRequest } from '@mantiq/core'
+import { MantiqResponse } from '@mantiq/core'
+
+export class ${className} {
+  async index(request: MantiqRequest): Promise<Response> {
+    return MantiqResponse.json({ data: [] })
+  }
+}
+`
+  }
+}

package/src/commands/MakeEventCommand.ts

@@ -0,0 +1,30 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeEventCommand extends GeneratorCommand {
+  override name = 'make:event'
+  override description = 'Create a new event class'
+  override usage = 'make:event <name>'
+
+  override directory() { return 'app/Events' }
+  override suffix() { return '' }
+
+  override stub(name: string, _args: ParsedArgs): string {
+    return `export class ${name} {
+  constructor(
+    public readonly data: Record<string, unknown> = {},
+  ) {}
+
+  /** Channels this event should broadcast on (return empty to skip broadcasting) */
+  broadcastOn(): string[] {
+    return []
+  }
+
+  /** The broadcast event name */
+  broadcastAs(): string {
+    return '${name}'
+  }
+}
+`
+  }
+}