webspresso 0.0.97 → 0.0.99

package/bin/commands/make-model.js

@@ -0,0 +1,250 @@
+'use strict';
+
+/**
+ * Webspresso CLI - make:model Command
+ * Scaffolds an ORM model in models/<Name>.js with zdb schema and optional migration
+ * @module bin/commands/make-model
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function pluralize(word) {
+  if (!word) return '';
+  const lower = word.toLowerCase();
+  if (lower.endsWith('y') && !/[aeiou]y$/.test(lower)) {
+    return lower.slice(0, -1) + 'ies';
+  }
+  if (lower.endsWith('s') || lower.endsWith('sh') || lower.endsWith('ch') || lower.endsWith('x') || lower.endsWith('z')) {
+    return lower + 'es';
+  }
+  return lower + 's';
+}
+
+function parseFields(fieldsArg) {
+  if (!fieldsArg || typeof fieldsArg !== 'string') return [];
+  const parts = fieldsArg.split(',').map((p) => p.trim()).filter(Boolean);
+  const fields = [];
+
+  for (const part of parts) {
+    const [name, type = 'string', modifier = ''] = part.split(':').map((s) => s.trim());
+    if (!name) continue;
+    fields.push({
+      name,
+      type: type.toLowerCase(),
+      isNullable: modifier.toLowerCase() === 'nullable' || modifier.toLowerCase() === 'optional' || name.endsWith('?'),
+    });
+  }
+
+  return fields;
+}
+
+function generateSchemaLines(fields, softDeletes = false) {
+  const lines = ['    id: zdb.id(),'];
+
+  for (const f of fields) {
+    if (f.name === 'id') continue;
+    let expr = 'zdb.string().min(1)';
+
+    switch (f.type) {
+      case 'text':
+        expr = 'zdb.text().optional()';
+        break;
+      case 'integer':
+      case 'int':
+        expr = f.isNullable ? 'zdb.integer().nullable().optional()' : 'zdb.integer().defaultTo(0)';
+        break;
+      case 'number':
+      case 'float':
+      case 'decimal':
+        expr = f.isNullable ? 'zdb.number().nullable().optional()' : 'zdb.number().defaultTo(0)';
+        break;
+      case 'boolean':
+      case 'bool':
+        expr = 'zdb.boolean().defaultTo(false)';
+        break;
+      case 'json':
+        expr = 'zdb.json().optional()';
+        break;
+      case 'date':
+      case 'datetime':
+        expr = 'zdb.date().optional()';
+        break;
+      case 'email':
+        expr = 'zdb.email().optional()';
+        break;
+      case 'file':
+        expr = 'zdb.file().optional()';
+        break;
+      case 'id':
+        expr = 'zdb.id()';
+        break;
+      case 'string':
+      default:
+        expr = f.isNullable ? 'zdb.string().nullable().optional()' : 'zdb.string().min(1)';
+        break;
+    }
+
+    lines.push(`    ${f.name}: ${expr},`);
+  }
+
+  if (softDeletes) {
+    lines.push('    deletedAt: zdb.softDelete().optional(),');
+  }
+
+  lines.push('    createdAt: zdb.timestamps().createdAt,');
+  lines.push('    updatedAt: zdb.timestamps().updatedAt,');
+
+  return lines.join('\n');
+}
+
+function generateModelContent(modelName, tableName, fields, softDeletes = false) {
+  const schemaCode = generateSchemaLines(fields, softDeletes);
+  const softScope = softDeletes ? `,\n  scopes: {\n    default: (q) => q.whereNull('deletedAt'),\n  }` : '';
+
+  return `'use strict';
+
+const { defineModel, zdb } = require('webspresso');
+
+module.exports = defineModel({
+  name: '${modelName}',
+  table: '${tableName}',
+  schema: {
+${schemaCode}
+  }${softScope},
+});
+`;
+}
+
+function generateMigrationContent(tableName, fields, softDeletes = false) {
+  const colLines = ['    table.increments(\'id\').primary();'];
+
+  for (const f of fields) {
+    if (f.name === 'id') continue;
+    switch (f.type) {
+      case 'text':
+        colLines.push(`    table.text('${f.name}')${f.isNullable ? '.nullable()' : ''};`);
+        break;
+      case 'integer':
+      case 'int':
+        colLines.push(`    table.integer('${f.name}')${f.isNullable ? '.nullable()' : '.defaultTo(0)'};`);
+        break;
+      case 'number':
+      case 'float':
+      case 'decimal':
+        colLines.push(`    table.float('${f.name}')${f.isNullable ? '.nullable()' : '.defaultTo(0)'};`);
+        break;
+      case 'boolean':
+      case 'bool':
+        colLines.push(`    table.boolean('${f.name}').defaultTo(false);`);
+        break;
+      case 'json':
+        colLines.push(`    table.json('${f.name}').nullable();`);
+        break;
+      case 'date':
+      case 'datetime':
+        colLines.push(`    table.datetime('${f.name}').nullable();`);
+        break;
+      default:
+        colLines.push(`    table.string('${f.name}')${f.isNullable ? '.nullable()' : '.notNullable()'};`);
+        break;
+    }
+  }
+
+  if (softDeletes) {
+    colLines.push('    table.datetime(\'deletedAt\').nullable();');
+  }
+
+  colLines.push('    table.timestamps(true, true);');
+
+  return `'use strict';
+
+/**
+ * Migration: Create ${tableName} table
+ */
+exports.up = function(knex) {
+  return knex.schema.createTable('${tableName}', (table) => {
+${colLines.join('\n')}
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('${tableName}');
+};
+`;
+}
+
+function registerCommand(program) {
+  program
+    .command('make:model <name>')
+    .alias('model:make')
+    .description('Scaffold an ORM model in models/<Name>.js with zdb schema')
+    .option('-f, --fields <fields>', 'Comma-separated fields (e.g. title:string,content:text,published:boolean)')
+    .option('-t, --table <table>', 'Custom table name (defaults to pluralized lowercase)')
+    .option('-m, --migration', 'Generate corresponding Knex migration file in migrations/')
+    .option('--soft-deletes', 'Include deletedAt column and default scope for soft delete')
+    .option('--root <dir>', 'Root directory of the project', process.cwd())
+    .action((nameArg, options) => {
+      const rootDir = path.resolve(options.root || process.cwd());
+      const modelsDir = path.join(rootDir, 'models');
+      const migrationsDir = path.join(rootDir, 'migrations');
+
+      if (!fs.existsSync(modelsDir)) {
+        fs.mkdirSync(modelsDir, { recursive: true });
+      }
+
+      // Format Model Name (PascalCase, e.g. post -> Post, blog_post -> BlogPost)
+      const cleanName = String(nameArg || '').trim();
+      const modelName = cleanName.charAt(0).toUpperCase() + cleanName.slice(1);
+      const tableName = options.table ? String(options.table).trim() : pluralize(cleanName.toLowerCase());
+
+      const modelFilePath = path.join(modelsDir, `${modelName}.js`);
+      if (fs.existsSync(modelFilePath)) {
+        console.error(`❌ Model file already exists: models/${modelName}.js`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const fields = parseFields(options.fields);
+      const modelContent = generateModelContent(modelName, tableName, fields, Boolean(options.softDeletes));
+
+      fs.writeFileSync(modelFilePath, modelContent, 'utf-8');
+      console.log(`\n✅ Created model: models/${modelName}.js (table: "${tableName}")`);
+
+      // Optional migration generation
+      if (options.migration) {
+        if (!fs.existsSync(migrationsDir)) {
+          fs.mkdirSync(migrationsDir, { recursive: true });
+        }
+
+        const now = new Date();
+        const timestamp = [
+          now.getFullYear(),
+          String(now.getMonth() + 1).padStart(2, '0'),
+          String(now.getDate()).padStart(2, '0'),
+          '_',
+          String(now.getHours()).padStart(2, '0'),
+          String(now.getMinutes()).padStart(2, '0'),
+          String(now.getSeconds()).padStart(2, '0'),
+        ].join('');
+
+        const migrationFileName = `${timestamp}_create_${tableName}_table.js`;
+        const migrationFilePath = path.join(migrationsDir, migrationFileName);
+        const migrationContent = generateMigrationContent(tableName, fields, Boolean(options.softDeletes));
+
+        fs.writeFileSync(migrationFilePath, migrationContent, 'utf-8');
+        console.log(`✅ Created migration: migrations/${migrationFileName}`);
+      }
+
+      console.log('');
+    });
+}
+
+module.exports = {
+  registerCommand,
+  pluralize,
+  parseFields,
+  generateSchemaLines,
+  generateModelContent,
+  generateMigrationContent,
+};

package/bin/commands/new.js

@@ -46,6 +46,8 @@ function registerCommand(program) {
     .description('Create a new Webspresso project')
     .option('-t, --template <template>', 'Template to use (minimal, full)', 'minimal')
     .option('--no-tailwind', 'Skip Tailwind CSS setup')
+    .option('--tailwind-v4', 'Use Tailwind CSS v4 (Oxide engine, zero-config)')
+    .option('--tailwind-version <version>', 'Tailwind version (3 or 4)', '3')
     .option('--no-agents', 'Skip AI Agent guidelines setup (.agents/, AGENTS.md, CLAUDE.md, .cursorrules)')
     .option('-i, --install', 'Auto install dependencies and build CSS')
     .option('-y, --yes', 'Non-interactive: no database, skip install unless -i/--install, skip dev server')
@@ -657,20 +659,43 @@ Visit http://localhost:3000
       
       // Add Tailwind if requested (default: true)
       if (useTailwind) {
-        console.log('\n🎨 Setting up Tailwind CSS...\n');
+        const isV4 = Boolean(options.tailwindV4 || options.tailwindVersion === '4');
+        console.log(`\n🎨 Setting up Tailwind CSS ${isV4 ? 'v4 (Oxide engine, zero-config)' : 'v3'}...\n`);
         
         // Create src directory
         fs.mkdirSync(path.join(projectPath, 'src'), { recursive: true });
         
-        // Create input.css
-        const inputCss = `@tailwind base;
+        // Create public/css directory
+        fs.mkdirSync(path.join(projectPath, 'public', 'css'), { recursive: true });
+        fs.writeFileSync(path.join(projectPath, 'public', 'css', 'style.css'), '/* Run npm run build:css */\n');
+        
+        // Update package.json
+        const updatedPackageJson = JSON.parse(fs.readFileSync(path.join(projectPath, 'package.json'), 'utf-8'));
+        updatedPackageJson.devDependencies = updatedPackageJson.devDependencies || {};
+        updatedPackageJson.scripts = updatedPackageJson.scripts || {};
+
+        if (isV4) {
+          const inputCss = `@import "tailwindcss";
+
+@source "../pages/**/*.{njk,js}";
+@source "../views/**/*.njk";
+@source "../src/**/*.js";
+`;
+          fs.writeFileSync(path.join(projectPath, 'src', 'input.css'), inputCss);
+
+          updatedPackageJson.devDependencies['@tailwindcss/cli'] = '^4.0.0';
+          updatedPackageJson.devDependencies['tailwindcss'] = '^4.0.0';
+
+          updatedPackageJson.scripts['build:css'] = '@tailwindcss/cli -i ./src/input.css -o ./public/css/style.css --minify';
+          updatedPackageJson.scripts['watch:css'] = '@tailwindcss/cli -i ./src/input.css -o ./public/css/style.css --watch';
+        } else {
+          const inputCss = `@tailwind base;
 @tailwind components;
 @tailwind utilities;
 `;
-        fs.writeFileSync(path.join(projectPath, 'src', 'input.css'), inputCss);
-        
-        // Create tailwind.config.js
-        const tailwindConfig = `/** @type {import('tailwindcss').Config} */
+          fs.writeFileSync(path.join(projectPath, 'src', 'input.css'), inputCss);
+          
+          const tailwindConfig = `/** @type {import('tailwindcss').Config} */
 module.exports = {
   content: [
     './pages/**/*.{njk,js}',
@@ -683,33 +708,25 @@ module.exports = {
   plugins: [],
 }
 `;
-        fs.writeFileSync(path.join(projectPath, 'tailwind.config.js'), tailwindConfig);
-        
-        // Create postcss.config.js
-        const postcssConfig = `module.exports = {
+          fs.writeFileSync(path.join(projectPath, 'tailwind.config.js'), tailwindConfig);
+          
+          const postcssConfig = `module.exports = {
   plugins: {
     tailwindcss: {},
     autoprefixer: {},
   },
 }
 `;
-        fs.writeFileSync(path.join(projectPath, 'postcss.config.js'), postcssConfig);
-        
-        // Create public/css directory
-        fs.mkdirSync(path.join(projectPath, 'public', 'css'), { recursive: true });
-        
-        // Create placeholder CSS (will be replaced by build)
-        fs.writeFileSync(path.join(projectPath, 'public', 'css', 'style.css'), '/* Run npm run build:css */\n');
-        
-        // Update package.json
-        const updatedPackageJson = JSON.parse(fs.readFileSync(path.join(projectPath, 'package.json'), 'utf-8'));
-        updatedPackageJson.devDependencies = updatedPackageJson.devDependencies || {};
-        updatedPackageJson.devDependencies['tailwindcss'] = '^3.4.1';
-        updatedPackageJson.devDependencies['postcss'] = '^8.4.35';
-        updatedPackageJson.devDependencies['autoprefixer'] = '^10.4.17';
+          fs.writeFileSync(path.join(projectPath, 'postcss.config.js'), postcssConfig);
+          
+          updatedPackageJson.devDependencies['tailwindcss'] = '^3.4.1';
+          updatedPackageJson.devDependencies['postcss'] = '^8.4.35';
+          updatedPackageJson.devDependencies['autoprefixer'] = '^10.4.17';
+          
+          updatedPackageJson.scripts['build:css'] = 'tailwindcss -i ./src/input.css -o ./public/css/style.css --minify';
+          updatedPackageJson.scripts['watch:css'] = 'tailwindcss -i ./src/input.css -o ./public/css/style.css --watch';
+        }
         
-        updatedPackageJson.scripts['build:css'] = 'tailwindcss -i ./src/input.css -o ./public/css/style.css --minify';
-        updatedPackageJson.scripts['watch:css'] = 'tailwindcss -i ./src/input.css -o ./public/css/style.css --watch';
         updatedPackageJson.scripts.dev = 'webspresso dev';
         updatedPackageJson.scripts.start = 'npm run build:css && NODE_ENV=production node server.js';
         
@@ -718,7 +735,7 @@ module.exports = {
           JSON.stringify(updatedPackageJson, null, 2) + '\n'
         );
         
-        console.log('✅ Tailwind CSS setup complete!');
+        console.log(`✅ Tailwind CSS ${isV4 ? 'v4' : 'v3'} setup complete!`);
       }
 
       // Scaffold AI Agent guidelines unless --no-agents is specified

package/bin/commands/openapi.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * Webspresso CLI - openapi / api:docs Command
+ * Generate and export OpenAPI 3 specification from application routes
+ * @module bin/commands/openapi
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { scanRoutes } = require('../../src/discovery/scan-routes');
+const { compileRouteTable } = require('../../src/routing/route-table');
+const { buildOpenApiDocument } = require('../../core/openapi/build-from-api-routes');
+
+function registerCommand(program) {
+  program
+    .command('openapi')
+    .alias('api:docs')
+    .description('Generate and export OpenAPI 3 specification from application routes')
+    .option('-o, --out <file>', 'Output JSON file path (e.g. openapi.json or public/openapi.json)')
+    .option('-r, --root <dir>', 'Root directory of the project', process.cwd())
+    .option('--pages <dir>', 'Pages directory relative to root', 'pages')
+    .option('--title <title>', 'OpenAPI specification title override')
+    .option('--api-version <version>', 'OpenAPI specification version override')
+    .option('--description <desc>', 'OpenAPI specification description override')
+    .option('--server <url>', 'Default server URL in spec', 'http://localhost:3000')
+    .option('--include-orm', 'Include ORM model schemas in components', false)
+    .option('--indent <spaces>', 'JSON indentation spaces', '2')
+    .option('-p, --print', 'Print specification JSON to stdout', false)
+    .action((options) => {
+      const rootDir = path.resolve(options.root || process.cwd());
+      const pagesRelDir = options.pages || 'pages';
+      const pagesDir = path.resolve(rootDir, pagesRelDir);
+      const apiDir = path.resolve(pagesDir, 'api');
+
+      if (!fs.existsSync(pagesDir) && !fs.existsSync(apiDir)) {
+        console.warn(`[webspresso] Warning: Pages directory not found at: ${pagesDir}`);
+      }
+
+      // Discover routes
+      const descriptors = scanRoutes({
+        rootDir,
+        pages: fs.existsSync(pagesDir) ? { dir: pagesRelDir } : true,
+        api: fs.existsSync(apiDir) ? { dir: path.join(pagesRelDir, 'api') } : true,
+      });
+
+      const routeTable = compileRouteTable(descriptors, { isDev: true });
+      const routes = routeTable.list();
+
+      // Read package.json metadata if available
+      let pkg = {};
+      const pkgPath = path.join(rootDir, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        try {
+          pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        } catch {
+          // ignore invalid json
+        }
+      }
+
+      const docTitle = options.title || pkg.name || 'Webspresso API';
+      const docVersion = options.apiVersion || pkg.version || '1.0.0';
+      const docDescription =
+        options.description ||
+        pkg.description ||
+        'OpenAPI 3.0 specification generated from Webspresso file-based API routes.';
+
+      const doc = buildOpenApiDocument({
+        routes,
+        pagesDir,
+        includeOrmSchemas: Boolean(options.includeOrm),
+        info: {
+          title: docTitle,
+          version: docVersion,
+          description: docDescription,
+        },
+        servers: [{ url: String(options.server).replace(/\/$/, '') }],
+      });
+
+      const indent = parseInt(options.indent, 10) || 2;
+      const formattedJson = JSON.stringify(doc, null, indent);
+
+      if (options.out) {
+        const targetPath = path.resolve(rootDir, options.out);
+        const targetDir = path.dirname(targetPath);
+        if (!fs.existsSync(targetDir)) {
+          fs.mkdirSync(targetDir, { recursive: true });
+        }
+        fs.writeFileSync(targetPath, formattedJson, 'utf8');
+
+        const relPath = path.relative(rootDir, targetPath);
+        const pathCount = Object.keys(doc.paths || {}).length;
+        console.log(`\x1b[32m✔\x1b[0m Generated OpenAPI 3 specification with ${pathCount} path(s) -> \x1b[1m${relPath}\x1b[0m`);
+      }
+
+      if (!options.out || options.print) {
+        console.log(formattedJson);
+      }
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/page.js

@@ -19,14 +19,17 @@ const path = require('path');
 function registerCommand(program) {
   program
     .command('page [route]')
+    .alias('make:page')
+    .alias('page:make')
     .description('Add a new SSR page (Nunjucks template + companion load() loader)')
     .option('--no-loader', 'Skip creating companion .js loader file')
     .option('--locales', 'Create page-level locale files')
+    .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 });
       }
 
       let route = routeArg ? String(routeArg).trim() : '';

package/bin/commands/queue-prune.js

@@ -0,0 +1,59 @@
+/**
+ * Prune old background queue jobs (CLI)
+ */
+
+'use strict';
+
+const { loadDbConfig, createDbInstance } = require('../utils/db');
+
+function registerCommand(program) {
+  program
+    .command('queue:prune')
+    .description('Delete completed or failed queue jobs older than the given retention window')
+    .option('--days <n>', 'Delete jobs older than this many days', '7')
+    .option('--status <statuses>', 'Comma-separated statuses to delete (e.g. completed, failed)', 'completed')
+    .option('--table <name>', 'Queue table name', 'webspresso_jobs')
+    .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 < 0) {
+        console.error('❌ --days must be a non-negative integer');
+        process.exit(1);
+      }
+
+      const statuses = (options.status || 'completed')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+
+      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 { DatabaseQueueAdapter } = require('../../core/queue/adapters/database');
+        const adapter = new DatabaseQueueAdapter({
+          knex,
+          tableName: options.table,
+        });
+
+        const deleted = await adapter.clean({
+          status: statuses,
+          olderThan,
+        });
+
+        console.log(`✅ Deleted ${deleted} job(s) [status: ${statuses.join(', ')}] with timestamp before ${olderThan.toISOString()}.\n`);
+      } catch (err) {
+        console.error('❌ queue:prune failed:', err.message);
+        process.exit(1);
+      } finally {
+        await knex.destroy();
+      }
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/routes.js

@@ -0,0 +1,52 @@
+'use strict';
+
+/**
+ * Webspresso CLI - routes Command
+ * Inspect and display compiled application routes
+ * @module bin/commands/routes
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { scanRoutes } = require('../../src/discovery/scan-routes');
+const { compileRouteTable } = require('../../src/routing/route-table');
+const { formatRouteTable } = require('../../src/dev/banner');
+
+function registerCommand(program) {
+  program
+    .command('routes')
+    .description('List and inspect all discovered application routes')
+    .option('-a, --api', 'Filter to only API endpoints')
+    .option('-p, --pages', 'Filter to only SSR page routes')
+    .option('-j, --json', 'Output routes as JSON')
+    .option('--root <dir>', 'Root directory of the project', process.cwd())
+    .action((options) => {
+      const rootDir = path.resolve(options.root || process.cwd());
+
+      const descriptors = scanRoutes({
+        rootDir,
+        pages: fs.existsSync(path.join(rootDir, 'pages')) ? { dir: 'pages' } : true,
+        api: fs.existsSync(path.join(rootDir, 'pages', 'api')) ? { dir: 'pages/api' } : true,
+      });
+
+      const routeTable = compileRouteTable(descriptors, { isDev: true });
+      let routes = routeTable.list();
+
+      if (options.api) {
+        routes = routes.filter((r) => r.type === 'api' || (r.path && r.path.startsWith('/api')));
+      } else if (options.pages) {
+        routes = routes.filter((r) => r.type === 'page' && (!r.path || !r.path.startsWith('/api')));
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify(routes, null, 2));
+        return;
+      }
+
+      console.log('');
+      console.log(formatRouteTable(routes, { limit: 200 }));
+      console.log('');
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/service.js

@@ -199,6 +199,7 @@ function registerCommand(program) {
     .description('Scaffold a new service in services/<domain>/<action>.js')
     .option('-t, --transaction', 'Enable ACID transaction wrapper (transaction: true)')
     .option('-a, --auth <role>', 'Require authentication or specific role')
+    .option('--root <dir>', 'Root directory of the project', process.cwd())
     .action(async (nameArg, options) => {
       const fs = require('fs');
       let serviceName = nameArg ? String(nameArg).trim() : '';
@@ -223,7 +224,8 @@ function registerCommand(program) {
       const actionName = parts.pop();
       const domainPath = parts.join(path.sep);
 
-      const servicesDir = path.resolve(process.cwd(), 'services');
+      const rootDir = path.resolve(options.root || process.cwd());
+      const servicesDir = path.resolve(rootDir, 'services');
       const targetDir = path.join(servicesDir, domainPath);
       fs.mkdirSync(targetDir, { recursive: true });
 
@@ -241,13 +243,14 @@ function registerCommand(program) {
 
       const content = `'use strict';
 
+const { defineService } = require('webspresso');
 const { z } = require('zod');
 
 /**
  * Service: ${serviceName}
  * @type {import('webspresso').ServiceDefinition}
  */
-module.exports = {
+module.exports = defineService({
   // Input validation schema (Zod)
   schema: z.object({
     // Define input properties here
@@ -262,7 +265,7 @@ module.exports = {
       data: input,
     };
   },
-};
+});
 `;
 
       fs.writeFileSync(serviceFile, content, 'utf8');