@strav/cli 0.1.0

package/src/commands/package_install.ts

@@ -0,0 +1,161 @@
+import { readdirSync, mkdirSync, existsSync } from 'node:fs'
+import { join, dirname, resolve } from 'node:path'
+import type { Command } from 'commander'
+import chalk from 'chalk'
+
+export function register(program: Command): void {
+  program
+    .command('install <name>')
+    .aliases(['package:install', 'i'])
+    .description('Copy config and schema stubs from a @stravigor/* package into your project')
+    .option('-f, --force', 'Overwrite existing files')
+    .action(async (name: string, { force }: { force?: boolean }) => {
+      try {
+        const packageName = name.startsWith('@stravigor/') ? name : `@stravigor/${name}`
+
+        const packageRoot = await resolvePackageRoot(packageName)
+        if (!packageRoot) {
+          console.error(chalk.red(`Package "${packageName}" is not installed.`))
+          process.exit(1)
+        }
+
+        const stubsDir = join(packageRoot, 'stubs')
+        if (!dirExists(stubsDir)) {
+          console.log(chalk.yellow(`Package "${packageName}" has no stubs to install.`))
+          return
+        }
+
+        let copied = 0
+        let skipped = 0
+
+        // Copy config stubs → ./config/
+        const configStubsDir = join(stubsDir, 'config')
+        if (dirExists(configStubsDir)) {
+          const result = await copyStubs(configStubsDir, join(process.cwd(), 'config'), force)
+          copied += result.copied
+          skipped += result.skipped
+        }
+
+        // Copy schema stubs → ./database/schemas/
+        const schemaStubsDir = join(stubsDir, 'schemas')
+        if (dirExists(schemaStubsDir)) {
+          const result = await copyStubs(
+            schemaStubsDir,
+            join(process.cwd(), 'database', 'schemas'),
+            force
+          )
+          copied += result.copied
+          skipped += result.skipped
+        }
+
+        // Copy action stubs → ./actions/
+        const actionStubsDir = join(stubsDir, 'actions')
+        if (dirExists(actionStubsDir)) {
+          const result = await copyStubs(actionStubsDir, join(process.cwd(), 'actions'), force)
+          copied += result.copied
+          skipped += result.skipped
+        }
+
+        // Copy email template stubs → ./resources/views/emails/
+        const emailStubsDir = join(stubsDir, 'emails')
+        if (dirExists(emailStubsDir)) {
+          const result = await copyStubs(
+            emailStubsDir,
+            join(process.cwd(), 'resources', 'views', 'emails'),
+            force,
+            ['.strav']
+          )
+          copied += result.copied
+          skipped += result.skipped
+        }
+
+        if (copied === 0 && skipped === 0) {
+          console.log(chalk.yellow(`No stubs found in "${packageName}".`))
+        } else {
+          if (copied > 0) {
+            console.log(
+              chalk.green(`\nInstalled ${copied} file${copied > 1 ? 's' : ''} from ${packageName}.`)
+            )
+          }
+          if (skipped > 0) {
+            console.log(
+              chalk.dim(
+                `Skipped ${skipped} existing file${skipped > 1 ? 's' : ''}. Use --force to overwrite.`
+              )
+            )
+          }
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      }
+    })
+}
+
+async function resolvePackageRoot(packageName: string): Promise<string | null> {
+  // 1. Try node_modules (regular npm install)
+  const nodeModulesPath = join(process.cwd(), 'node_modules', ...packageName.split('/'))
+  if (existsSync(join(nodeModulesPath, 'package.json'))) {
+    return nodeModulesPath
+  }
+
+  // 2. Try workspace resolution (Bun workspaces / monorepo)
+  try {
+    const rootPkg = await Bun.file(resolve('package.json')).json()
+    const workspaces: string[] = rootPkg.workspaces ?? []
+    for (const ws of workspaces) {
+      const wsPath = resolve(ws)
+      const pkgPath = join(wsPath, 'package.json')
+      if (!existsSync(pkgPath)) continue
+      const wsPkg = await Bun.file(pkgPath).json()
+      if (wsPkg.name === packageName) return wsPath
+    }
+  } catch {
+    // No package.json or no workspaces
+  }
+
+  return null
+}
+
+function dirExists(path: string): boolean {
+  try {
+    readdirSync(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function copyStubs(
+  srcDir: string,
+  destDir: string,
+  force?: boolean,
+  extensions: string[] = ['.ts']
+): Promise<{ copied: number; skipped: number }> {
+  let copied = 0
+  let skipped = 0
+
+  const files = readdirSync(srcDir).filter(f => extensions.some(ext => f.endsWith(ext)))
+
+  for (const file of files) {
+    const srcPath = join(srcDir, file)
+    const destPath = join(destDir, file)
+    const destFile = Bun.file(destPath)
+
+    if ((await destFile.exists()) && !force) {
+      const relative = destPath.replace(process.cwd() + '/', '')
+      console.log(chalk.yellow(`  SKIP  ${relative} (already exists)`))
+      skipped++
+      continue
+    }
+
+    mkdirSync(destDir, { recursive: true })
+    const content = await Bun.file(srcPath).text()
+    await Bun.write(destPath, content)
+    const relative = destPath.replace(process.cwd() + '/', '')
+    console.log(chalk.green(`  CREATE  ${relative}`))
+    copied++
+  }
+
+  return { copied, skipped }
+}

package/src/commands/queue_flush.ts

@@ -0,0 +1,35 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import Queue from '@stravigor/queue/queue/queue'
+
+export function register(program: Command): void {
+  program
+    .command('queue:flush')
+    .description('Delete all jobs from a queue')
+    .option('--queue <name>', 'Queue to flush', 'default')
+    .option('--failed', 'Also flush failed jobs')
+    .action(async options => {
+      let db
+      try {
+        const { db: database, config } = await bootstrap()
+        db = database
+
+        new Queue(db, config)
+        await Queue.ensureTables()
+
+        const cleared = await Queue.clear(options.queue)
+        console.log(chalk.green(`Cleared ${cleared} pending job(s) from "${options.queue}".`))
+
+        if (options.failed) {
+          const failedCleared = await Queue.clearFailed(options.queue)
+          console.log(chalk.green(`Cleared ${failedCleared} failed job(s).`))
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}

package/src/commands/queue_retry.ts

@@ -0,0 +1,34 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import Queue from '@stravigor/queue/queue/queue'
+
+export function register(program: Command): void {
+  program
+    .command('queue:retry')
+    .description('Retry failed jobs by moving them back to the queue')
+    .option('--queue <name>', 'Only retry jobs from this queue')
+    .action(async options => {
+      let db
+      try {
+        const { db: database, config } = await bootstrap()
+        db = database
+
+        new Queue(db, config)
+        await Queue.ensureTables()
+
+        const count = await Queue.retryFailed(options.queue)
+
+        if (count === 0) {
+          console.log(chalk.green('No failed jobs to retry.'))
+        } else {
+          console.log(chalk.green(`Moved ${count} failed job(s) back to the queue.`))
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}

package/src/commands/queue_work.ts

@@ -0,0 +1,40 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import Queue from '@stravigor/queue/queue/queue'
+import Worker from '@stravigor/queue/queue/worker'
+
+export function register(program: Command): void {
+  program
+    .command('queue:work')
+    .description('Start processing queued jobs')
+    .option('--queue <name>', 'Queue to process', 'default')
+    .option('--sleep <ms>', 'Poll interval in milliseconds', '1000')
+    .action(async options => {
+      let db
+      try {
+        const { db: database, config } = await bootstrap()
+        db = database
+
+        new Queue(db, config)
+        await Queue.ensureTables()
+
+        const queue = options.queue
+        const sleep = parseInt(options.sleep)
+
+        console.log(chalk.cyan(`Worker starting on queue "${queue}"...`))
+        console.log(chalk.dim(`  poll interval: ${sleep}ms`))
+        console.log(chalk.dim('  Press Ctrl+C to stop.\n'))
+
+        const worker = new Worker({ queue, sleep })
+        await worker.start()
+
+        console.log(chalk.dim('\nWorker stopped.'))
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}

package/src/commands/scheduler_work.ts

@@ -0,0 +1,46 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import path from 'node:path'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import Scheduler from '@stravigor/queue/scheduler/scheduler'
+import SchedulerRunner from '@stravigor/queue/scheduler/runner'
+
+export function register(program: Command): void {
+  program
+    .command('schedule')
+    .alias('scheduler:work')
+    .description('Start the task scheduler')
+    .action(async () => {
+      let db
+      try {
+        const { db: database } = await bootstrap()
+        db = database
+
+        // Load user's scheduled tasks
+        const schedulesPath = path.resolve('app/schedules.ts')
+        await import(schedulesPath)
+
+        const taskCount = Scheduler.tasks.length
+        if (taskCount === 0) {
+          console.log(chalk.yellow('No tasks registered. Add tasks in app/schedules.ts'))
+          return
+        }
+
+        console.log(chalk.cyan(`Scheduler starting with ${taskCount} task(s)...`))
+        for (const task of Scheduler.tasks) {
+          console.log(chalk.dim(`  ${task.name}`))
+        }
+        console.log(chalk.dim('  Press Ctrl+C to stop.\n'))
+
+        const runner = new SchedulerRunner()
+        await runner.start()
+
+        console.log(chalk.dim('\nScheduler stopped.'))
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}

package/src/config/loader.ts

@@ -0,0 +1,39 @@
+import { join } from 'node:path'
+import type { GeneratorConfig, GeneratorPaths } from '../generators/config.ts'
+import { resolvePaths } from '../generators/config.ts'
+
+/**
+ * Load the generator configuration from the project's config/generators.ts file.
+ * Falls back to defaults if the file doesn't exist.
+ */
+export async function loadGeneratorConfig(): Promise<GeneratorConfig | undefined> {
+  try {
+    return (await import(join(process.cwd(), 'config/generators.ts'))).default
+  } catch {
+    // No config/generators.ts — use defaults
+    return undefined
+  }
+}
+
+/**
+ * Get the fully resolved database paths from the configuration.
+ * This includes the schemas and migrations paths with defaults.
+ */
+export async function getDatabasePaths(): Promise<{ schemas: string; migrations: string }> {
+  const config = await loadGeneratorConfig()
+  const paths = resolvePaths(config)
+
+  return {
+    schemas: paths.schemas,
+    migrations: paths.migrations,
+  }
+}
+
+/**
+ * Get all resolved paths from the configuration.
+ * Useful for commands that need multiple paths.
+ */
+export async function getAllPaths(scope?: string): Promise<GeneratorPaths> {
+  const config = await loadGeneratorConfig()
+  return resolvePaths(config, scope)
+}