webspresso 0.0.97 → 0.0.99

package/bin/commands/api.js

@@ -2,7 +2,7 @@
 
 /**
  * API Command
- * Add a new API endpoint with modern Webspresso schema & handler contract
+ * Add a new API endpoint or full REST CRUD suite with modern Webspresso schema & handler contract
  * @module bin/commands/api
  */
 
@@ -18,6 +18,31 @@ const path = require('path');
 
 const VALID_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
 
+function singularize(word) {
+  if (!word) return '';
+  const lower = word.toLowerCase();
+  if (lower.endsWith('ies')) {
+    return lower.slice(0, -3) + 'y';
+  }
+  if (lower.endsWith('ses')) {
+    return lower.slice(0, -2);
+  }
+  if (lower.endsWith('s') && !lower.endsWith('ss')) {
+    return lower.slice(0, -1);
+  }
+  return lower;
+}
+
+function toPascalCase(str) {
+  if (!str) return '';
+  const clean = str.replace(/[^a-zA-Z0-9]/g, ' ');
+  return clean
+    .split(' ')
+    .filter(Boolean)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join('');
+}
+
 function parseRouteAndMethod(rawInput, optionMethod) {
   let route = String(rawInput || '').trim();
   let method = optionMethod ? String(optionMethod).toUpperCase() : null;
@@ -45,18 +70,160 @@ function parseRouteAndMethod(rawInput, optionMethod) {
   };
 }
 
+function generateCrudFiles(apiDir, route, modelName, middlewareStr) {
+  const cleanRoute = route.replace(/^\/+|\/+$/g, '');
+  const baseDir = path.join(apiDir, cleanRoute);
+  const detailDir = path.join(baseDir, '[id]');
+  fs.mkdirSync(detailDir, { recursive: true });
+
+  const files = [
+    {
+      path: path.join(apiDir, `${cleanRoute}.get.js`),
+      label: `GET /api/${cleanRoute} (List)`,
+      content: `'use strict';
+
+const { defineApi } = require('webspresso');
+
+module.exports = defineApi({
+  schema: ({ z }) => ({
+    query: z.object({
+      page: z.coerce.number().optional().default(1),
+      limit: z.coerce.number().optional().default(20),
+    }),
+  }),${middlewareStr}
+  handler: async (req, res) => {
+    const repo = req.db ? req.db.getRepository('${modelName}') : null;
+    const { page, limit } = req.input.query;
+    const items = repo ? await repo.query().paginate({ page, limit }) : [];
+    return res.json(items);
+  },
+});
+`,
+    },
+    {
+      path: path.join(apiDir, `${cleanRoute}.post.js`),
+      label: `POST /api/${cleanRoute} (Create)`,
+      content: `'use strict';
+
+const { defineApi } = require('webspresso');
+
+module.exports = defineApi({
+  schema: ({ z }) => ({
+    body: z.object({
+      title: z.string().min(1).optional(),
+    }).passthrough(),
+  }),${middlewareStr}
+  handler: async (req, res) => {
+    const repo = req.db ? req.db.getRepository('${modelName}') : null;
+    const created = repo ? await repo.create(req.input.body) : req.input.body;
+    return res.status(201).json(created);
+  },
+});
+`,
+    },
+    {
+      path: path.join(detailDir, '[id].get.js'),
+      label: `GET /api/${cleanRoute}/:id (Detail)`,
+      content: `'use strict';
+
+const { defineApi } = require('webspresso');
+
+module.exports = defineApi({
+  schema: ({ z }) => ({
+    params: z.object({
+      id: z.coerce.number().or(z.string().min(1)),
+    }),
+  }),${middlewareStr}
+  handler: async (req, res) => {
+    const repo = req.db ? req.db.getRepository('${modelName}') : null;
+    const item = repo ? await repo.findById(req.params.id) : null;
+    if (!item) {
+      return res.status(404).json({ error: '${modelName} not found' });
+    }
+    return res.json(item);
+  },
+});
+`,
+    },
+    {
+      path: path.join(detailDir, '[id].patch.js'),
+      label: `PATCH /api/${cleanRoute}/:id (Update)`,
+      content: `'use strict';
+
+const { defineApi } = require('webspresso');
+
+module.exports = defineApi({
+  schema: ({ z }) => ({
+    params: z.object({
+      id: z.coerce.number().or(z.string().min(1)),
+    }),
+    body: z.record(z.unknown()).optional(),
+  }),${middlewareStr}
+  handler: async (req, res) => {
+    const repo = req.db ? req.db.getRepository('${modelName}') : null;
+    const updated = repo ? await repo.update(req.params.id, req.input.body || {}) : null;
+    if (!updated) {
+      return res.status(404).json({ error: '${modelName} not found' });
+    }
+    return res.json(updated);
+  },
+});
+`,
+    },
+    {
+      path: path.join(detailDir, '[id].delete.js'),
+      label: `DELETE /api/${cleanRoute}/:id (Delete)`,
+      content: `'use strict';
+
+const { defineApi } = require('webspresso');
+
+module.exports = defineApi({
+  schema: ({ z }) => ({
+    params: z.object({
+      id: z.coerce.number().or(z.string().min(1)),
+    }),
+  }),${middlewareStr}
+  handler: async (req, res) => {
+    const repo = req.db ? req.db.getRepository('${modelName}') : null;
+    if (repo) {
+      await repo.delete(req.params.id);
+    }
+    return res.status(204).end();
+  },
+});
+`,
+    },
+  ];
+
+  for (const f of files) {
+    fs.writeFileSync(f.path, f.content, 'utf8');
+  }
+
+  return files;
+}
+
 function registerCommand(program) {
   program
     .command('api [route]')
+    .alias('make:api')
+    .alias('api:make')
     .description('Add a new API endpoint to pages/api/ with schema validation and handler')
     .option('-m, --method <method>', 'HTTP method (GET, POST, PUT, PATCH, DELETE)', 'GET')
+    .option('--crud', 'Generate full REST CRUD endpoints (list, create, get, update, delete)')
+    .option('--model <model>', 'Associated ORM model name for repository calls')
     .option('--auth', 'Protect with session auth middleware')
     .option('--jwt', 'Protect with JWT bearer middleware')
+    .option('--root <dir>', 'Root directory of the project', process.cwd())
     .action(async (routeArg, options) => {
-      const pagesDir = path.resolve(process.cwd(), 'pages');
+      const rootDir = path.resolve(options.root || process.cwd());
+      const pagesDir = path.join(rootDir, 'pages');
       if (!fs.existsSync(pagesDir)) {
-        console.error('❌ Not a Webspresso project! (pages/ directory not found)');
-        process.exit(1);
+        fs.mkdirSync(pagesDir, { recursive: true });
+      }
+
+      const apiDir = path.join(pagesDir, 'api');
+      if (!fs.existsSync(apiDir)) {
+        fs.mkdirSync(apiDir, { recursive: true });
       }
 
       let route;
@@ -83,17 +250,39 @@ function registerCommand(program) {
             message: 'HTTP method:',
             choices: VALID_METHODS,
             default: options.method ? options.method.toUpperCase() : 'GET',
+            when: () => !options.crud,
           },
         ]);
 
-        const parsed = parseRouteAndMethod(answers.route, answers.method);
+        const parsed = parseRouteAndMethod(answers.route, answers.method || options.method);
         route = parsed.route;
         method = parsed.method;
       }
 
+      const middlewares = [];
+      if (options.auth) middlewares.push("'auth'");
+      if (options.jwt) middlewares.push("'jwt'");
+      const middlewareStr = middlewares.length > 0 ? `\n  middleware: [${middlewares.join(', ')}],` : '';
+
+      // CRUD Generation Mode
+      if (options.crud) {
+        const lastSegment = route.split('/').filter(Boolean).pop() || route;
+        const singular = singularize(lastSegment);
+        const modelName = options.model ? String(options.model).trim() : toPascalCase(singular);
+
+        const createdFiles = generateCrudFiles(apiDir, route, modelName, middlewareStr);
+        console.log(`\n✅ Generated REST CRUD API endpoints for "${modelName}" in pages/api/${route}:`);
+        for (const cf of createdFiles) {
+          console.log(`   - ${cf.label} → ${path.relative(process.cwd(), cf.path)}`);
+        }
+        console.log('');
+        return;
+      }
+
+      // Single Route Generation Mode
       const methodUpper = String(method).toUpperCase();
       const methodLower = methodUpper.toLowerCase();
-      const routePath = path.join(pagesDir, 'api', route);
+      const routePath = path.join(apiDir, route);
       const dirPath = path.dirname(routePath);
       const fileName = path.basename(routePath);
 
@@ -101,11 +290,6 @@ function registerCommand(program) {
 
       const apiFile = path.join(dirPath, `${fileName}.${methodLower}.js`);
 
-      const middlewares = [];
-      if (options.auth) middlewares.push("'auth'");
-      if (options.jwt) middlewares.push("'jwt'");
-      const middlewareStr = middlewares.length > 0 ? `\n  middleware: [${middlewares.join(', ')}],` : '';
-
       const hasParams = route.includes('[');
       const hasBody = ['POST', 'PUT', 'PATCH'].includes(methodUpper);
 
@@ -114,10 +298,12 @@ function registerCommand(program) {
 /**
  * ${methodUpper} /api/${route}
  */
-module.exports = {
+const { defineApi } = require('webspresso');
+
+module.exports = defineApi({
   // Input validation schema (Zod)
   schema: ({ z }) => ({
-    ${hasParams ? 'params: z.object({ id: z.string().min(1) }),\n    ' : ''}${hasBody ? 'body: z.object({\n      // Define body schema here\n    }),\n    ' : ''}query: z.object({\n      // Define query params here\n    }),
+    ${hasParams ? 'params: z.object({ id: z.coerce.number().or(z.string().min(1)) }),\n    ' : ''}${hasBody ? 'body: z.object({\n      // Define body schema here\n    }).passthrough(),\n    ' : ''}query: z.object({\n      // Define query params here\n    }),
   }),${middlewareStr}
 
   // Request Handler
@@ -131,7 +317,7 @@ module.exports = {
       timestamp: new Date().toISOString(),
     });
   },
-};
+});
 `;
 
       fs.writeFileSync(apiFile, apiContent, 'utf8');
@@ -139,4 +325,10 @@ module.exports = {
     });
 }
 
-module.exports = { registerCommand, parseRouteAndMethod };
+module.exports = {
+  registerCommand,
+  parseRouteAndMethod,
+  singularize,
+  toPascalCase,
+  generateCrudFiles,
+};

package/bin/commands/build.js

@@ -0,0 +1,99 @@
+/**
+ * Build Command
+ * Build production assets (Tailwind CSS and esbuild JS bundle with manifest.json)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { buildBundle } = require('../../src/bundle');
+
+function registerCommand(program) {
+  program
+    .command('build')
+    .alias('build:assets')
+    .description('Build production assets (Tailwind CSS and esbuild JS with manifest.json)')
+    .option('--no-css', 'Skip CSS build')
+    .option('--no-js', 'Skip JS bundle build')
+    .option('--no-hash', 'Disable content hashing in asset filenames')
+    .action(async (options = {}) => {
+      const cwd = process.cwd();
+      const pkgPath = path.join(cwd, 'package.json');
+      if (!fs.existsSync(pkgPath)) {
+        console.error('❌ Not a Webspresso project! Run this command in your project directory.');
+        process.exit(1);
+      }
+
+      let packageJson = {};
+      try {
+        packageJson = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      } catch (_) {}
+
+      console.log('\n📦 Building Webspresso production assets...\n');
+
+      let cssBuilt = false;
+      let jsBuilt = false;
+
+      // 1. Build CSS (Tailwind)
+      if (options.css !== false) {
+        const hasCssScript = Boolean(packageJson.scripts && packageJson.scripts['build:css']);
+        const hasInputCss = fs.existsSync(path.join(cwd, 'src', 'input.css'));
+
+        if (hasCssScript) {
+          try {
+            console.log('🎨 Compiling Tailwind CSS...');
+            execSync('npm run build:css', { stdio: 'inherit', cwd });
+            cssBuilt = true;
+          } catch (err) {
+            console.error('❌ CSS build failed:', err.message);
+          }
+        } else if (hasInputCss) {
+          console.log('ℹ️  src/input.css found but no "build:css" script. Run "npx webspresso add tailwind" to configure.');
+        }
+      }
+
+      // 2. Build JS Bundle with manifest.json (esbuild)
+      if (options.js !== false) {
+        const hasClientEntry = fs.existsSync(path.join(cwd, 'src', 'client', 'main.js')) ||
+          fs.existsSync(path.join(cwd, 'src', 'client', 'main.ts')) ||
+          fs.existsSync(path.join(cwd, 'src', 'client', 'index.js'));
+        const hasEsbuild = Boolean(
+          (packageJson.devDependencies && packageJson.devDependencies.esbuild) ||
+          (packageJson.dependencies && packageJson.dependencies.esbuild)
+        );
+
+        if (hasClientEntry || hasEsbuild) {
+          try {
+            console.log('⚡ Bundling client JavaScript with esbuild...');
+            const result = await buildBundle({
+              cwd,
+              hash: options.hash !== false,
+              minify: true,
+              sourcemap: true,
+              outdir: path.join(cwd, 'public', 'dist'),
+            });
+            jsBuilt = true;
+            console.log(`✅ Client assets bundled and manifest created at: ${path.relative(cwd, result.manifestPath)}`);
+          } catch (err) {
+            // Fallback to npm run build:js if custom script exists
+            if (packageJson.scripts && packageJson.scripts['build:js']) {
+              try {
+                execSync('npm run build:js', { stdio: 'inherit', cwd });
+                jsBuilt = true;
+              } catch (subErr) {
+                console.error('❌ JS build failed:', subErr.message);
+              }
+            } else {
+              console.error('❌ JS bundle build failed:', err.message);
+            }
+          }
+        }
+      }
+
+      console.log('\n✨ Asset build complete!\n');
+      if (cssBuilt) console.log('  ✓ CSS: public/css/style.css');
+      if (jsBuilt) console.log('  ✓ JS: public/dist/ & manifest.json');
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/dev.js

@@ -32,6 +32,7 @@ function registerCommand(program) {
     .description('Start development server')
     .option('-p, --port <port>', 'Port number', '3000')
     .option('--no-css', 'Skip CSS watch (if Tailwind is set up)')
+    .option('--no-js', 'Skip client JS watch (if esbuild / watch:js is set up)')
     .action((options) => {
       if (!fs.existsSync('server.js')) {
         console.error('❌ server.js not found! Make sure you are in a Webspresso project.');
@@ -41,56 +42,84 @@ function registerCommand(program) {
       process.env.PORT = options.port;
       process.env.NODE_ENV = 'development';
       
-      const hasTailwind = fs.existsSync('tailwind.config.js') && fs.existsSync('src/input.css');
+      let packageJson = {};
+      if (fs.existsSync('package.json')) {
+        try {
+          packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+        } catch (_) {}
+      }
+      const hasTailwindV3 = fs.existsSync('tailwind.config.js') && fs.existsSync('src/input.css');
+      const hasTailwindV4 = fs.existsSync('src/input.css') && Boolean(
+        (packageJson.devDependencies && (packageJson.devDependencies['@tailwindcss/cli'] || packageJson.devDependencies['tailwindcss'])) ||
+        (packageJson.scripts && packageJson.scripts['watch:css'])
+      );
+      const hasTailwind = hasTailwindV3 || hasTailwindV4;
       const shouldWatchCss = hasTailwind && options.css !== false;
+
+      const hasJsWatch = Boolean(
+        (packageJson.scripts && packageJson.scripts['watch:js']) ||
+        fs.existsSync('src/client/main.js') ||
+        fs.existsSync('src/client/main.ts') ||
+        fs.existsSync('esbuild.config.js')
+      );
+      const shouldWatchJs = hasJsWatch && options.js !== false && Boolean(packageJson.scripts && packageJson.scripts['watch:js']);
       
       // Build watch arguments
       const watchArgs = buildWatchArgs();
       const watchDirs = watchArgs.filter(a => a.startsWith('--watch-path')).map(a => a.split('=')[1]);
       
+      const watchingLabels = ['server.js'];
+      if (watchDirs.length) watchingLabels.push(...watchDirs);
+      if (shouldWatchCss) watchingLabels.push('CSS');
+      if (shouldWatchJs) watchingLabels.push('JS (esbuild)');
+
+      console.log(`\n🚀 Starting development server on port ${options.port}...`);
+      console.log(`   Watching: ${watchingLabels.join(', ')}\n`);
+
+      const managedProcesses = [];
+      let isCleaningUp = false;
+
+      const cleanup = (code = 0) => {
+        if (isCleaningUp) return;
+        isCleaningUp = true;
+        for (const p of managedProcesses) {
+          try {
+            if (p && !p.killed) {
+              p.kill('SIGTERM');
+            }
+          } catch (_) {}
+        }
+        process.exit(code);
+      };
+
+      process.once('SIGINT', () => cleanup(0));
+      process.once('SIGTERM', () => cleanup(0));
+
       if (shouldWatchCss) {
-        console.log(`\n🚀 Starting development server on port ${options.port}...`);
-        console.log(`   Watching: server.js${watchDirs.length ? ', ' + watchDirs.join(', ') : ''}, CSS\n`);
-        
-        // Start CSS watch
         const cssWatch = spawn('npm', ['run', 'watch:css'], {
-          stdio: 'inherit',
-          shell: true
-        });
-        
-        // Start server with watch paths
-        const server = spawn('node', watchArgs, {
           stdio: 'inherit',
           shell: true,
-          env: { ...process.env, PORT: options.port, NODE_ENV: 'development' }
         });
-        
-        // Handle exit
-        const cleanup = () => {
-          cssWatch.kill();
-          server.kill();
-          process.exit(0);
-        };
-        
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
-        
-        cssWatch.on('exit', cleanup);
-        server.on('exit', cleanup);
-      } else {
-        console.log(`\n🚀 Starting development server on port ${options.port}...`);
-        console.log(`   Watching: server.js${watchDirs.length ? ', ' + watchDirs.join(', ') : ''}\n`);
-        
-        const child = spawn('node', watchArgs, {
+        managedProcesses.push(cssWatch);
+        cssWatch.on('exit', () => cleanup(0));
+      }
+
+      if (shouldWatchJs) {
+        const jsWatch = spawn('npm', ['run', 'watch:js'], {
           stdio: 'inherit',
           shell: true,
-          env: { ...process.env, PORT: options.port, NODE_ENV: 'development' }
-        });
-        
-        child.on('exit', (code) => {
-          process.exit(code || 0);
         });
+        managedProcesses.push(jsWatch);
+        jsWatch.on('exit', () => cleanup(0));
       }
+
+      const server = spawn('node', watchArgs, {
+        stdio: 'inherit',
+        shell: true,
+        env: { ...process.env, PORT: options.port, NODE_ENV: 'development' },
+      });
+      managedProcesses.push(server);
+      server.on('exit', (code) => cleanup(code || 0));
     });
 }
 

package/bin/commands/doctor.js

@@ -215,6 +215,32 @@ function registerCommand(program) {
         warnings += 1;
       }
 
+      console.log('\nTailwind CSS');
+      console.log('------------');
+      const inputCssPath = path.join(cwd, 'src', 'input.css');
+      if (fs.existsSync(inputCssPath)) {
+        let isV4 = false;
+        try {
+          const inputCssContent = fs.readFileSync(inputCssPath, 'utf8');
+          isV4 = inputCssContent.includes('@import "tailwindcss"') || inputCssContent.includes("@import 'tailwindcss'");
+        } catch (_) {}
+
+        if (isV4) {
+          line('✓', 'Tailwind CSS v4 detected (@import "tailwindcss" — Oxide engine, zero-config)');
+        } else {
+          line('✓', 'Tailwind CSS v3 detected (PostCSS / tailwind.config.js)');
+        }
+        const outputCss = path.join(cwd, 'public', 'css', 'style.css');
+        if (fs.existsSync(outputCss)) {
+          line('✓', 'public/css/style.css compiled output present');
+        } else {
+          line('⚠', 'public/css/style.css not found. Run "npm run build:css" to compile stylesheets.');
+          warnings += 1;
+        }
+      } else {
+        line('○', 'No src/input.css found (Tailwind CSS not configured)');
+      }
+
       console.log('\nAI Agent Guidelines');
       console.log('-------------------');
       const agentsMdPath = path.join(cwd, 'AGENTS.md');

package/bin/commands/email-prune.js

@@ -0,0 +1,47 @@
+/**
+ * Prune old email log records (CLI)
+ */
+
+'use strict';
+
+const { loadDbConfig, createDbInstance } = require('../utils/db');
+
+function registerCommand(program) {
+  program
+    .command('email:prune')
+    .description('Delete email log rows older than the given retention window')
+    .option('--days <n>', 'Delete rows older than this many days', '90')
+    .option('--table <name>', 'Table name', 'email_logs')
+    .option('-e, --env <environment>', 'Environment (development, production)', 'development')
+    .option('-c, --config <path>', 'Path to database config file')
+    .action(async (options) => {
+      const days = parseInt(options.days, 10);
+      if (Number.isNaN(days) || days < 1) {
+        console.error('❌ --days must be a positive integer');
+        process.exit(1);
+      }
+
+      const { config, path: configPath } = loadDbConfig(options.config);
+      console.log(`\n📦 Using config: ${configPath}`);
+      console.log(`   Environment: ${options.env}\n`);
+
+      const knex = await createDbInstance(config, options.env);
+      const olderThan = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+
+      try {
+        const { purgeEmailLogs } = require('../../plugins/email/purge');
+        const deleted = await purgeEmailLogs(knex, {
+          tableName: options.table,
+          olderThan,
+        });
+        console.log(`✅ Deleted ${deleted} email log row(s) with created_at before ${olderThan.toISOString()}.\n`);
+      } catch (err) {
+        console.error('❌ email:prune failed:', err.message);
+        process.exit(1);
+      } finally {
+        await knex.destroy();
+      }
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/make-job.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * Webspresso CLI - make:job Command
+ * Scaffolds a background queue job worker in jobs/<name>.js
+ * @module bin/commands/make-job
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function generateJobContent(jobName, queueName = 'default', retries = 3) {
+  return `'use strict';
+
+/**
+ * Background Job: ${jobName}
+ * Dispatched via: req.queue.dispatch('${jobName}', payload)
+ */
+module.exports = {
+  name: '${jobName}',
+  queue: '${queueName}',
+  retries: ${retries},
+  backoff: {
+    type: 'exponential',
+    delay: 1000,
+  },
+  handler: async (payload, ctx) => {
+    const { db, logger } = ctx;
+    if (logger) logger.info('[Job:${jobName}] Processing job:', payload);
+
+    // Business logic goes here:
+    // const repo = db ? db.getRepository('...') : null;
+  },
+};
+`;
+}
+
+function registerCommand(program) {
+  program
+    .command('make:job <name>')
+    .alias('job:make')
+    .description('Scaffold a background queue job worker in jobs/<name>.js')
+    .option('-q, --queue <queue>', 'Target queue name', 'default')
+    .option('-r, --retries <number>', 'Number of retries upon failure', '3')
+    .option('--root <dir>', 'Root directory of the project', process.cwd())
+    .action((nameArg, options) => {
+      const rootDir = path.resolve(options.root || process.cwd());
+      const jobsDir = path.join(rootDir, 'jobs');
+
+      if (!fs.existsSync(jobsDir)) {
+        fs.mkdirSync(jobsDir, { recursive: true });
+      }
+
+      const jobName = String(nameArg || '').trim();
+      if (!jobName) {
+        console.error('❌ Job name is required.');
+        process.exitCode = 1;
+        return;
+      }
+
+      // Support nested folders e.g. emails/welcome
+      const targetFilePath = path.join(jobsDir, `${jobName}.js`);
+      const targetDir = path.dirname(targetFilePath);
+
+      if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+      }
+
+      if (fs.existsSync(targetFilePath)) {
+        console.error(`❌ Job file already exists: jobs/${jobName}.js`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const retries = parseInt(options.retries, 10) || 3;
+      const content = generateJobContent(jobName, options.queue || 'default', retries);
+
+      fs.writeFileSync(targetFilePath, content, 'utf-8');
+      console.log(`\n✅ Created background job: jobs/${jobName}.js (queue: "${options.queue || 'default'}", retries: ${retries})\n`);
+    });
+}
+
+module.exports = {
+  registerCommand,
+  generateJobContent,
+};