webspresso 0.0.94 → 0.0.96

package/bin/commands/page.js

@@ -1,6 +1,9 @@
+'use strict';
+
 /**
  * Page Command
- * Add a new page to the current project
+ * Add a new SSR page with Nunjucks template and companion data loader
+ * @module bin/commands/page
  */
 
 let _inquirer;
@@ -15,125 +18,108 @@ const path = require('path');
 
 function registerCommand(program) {
   program
-    .command('page')
-    .description('Add a new page to the current project')
-    .action(async () => {
-      if (!fs.existsSync('pages')) {
-        console.error('❌ Not a Webspresso project! Run this command in your project directory.');
+    .command('page [route]')
+    .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')
+    .action(async (routeArg, options) => {
+      const pagesDir = path.resolve(process.cwd(), 'pages');
+      if (!fs.existsSync(pagesDir)) {
+        console.error('❌ Not a Webspresso project! (pages/ directory not found)');
         process.exit(1);
       }
-      
-      const answers = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'route',
-          message: 'Route path (e.g., /about or /blog/post):',
-          validate: (input) => {
-            if (!input.startsWith('/')) {
-              return 'Route must start with /';
-            }
-            return true;
-          }
-        },
-        {
-          type: 'confirm',
-          name: 'hasConfig',
-          message: 'Add route config file (.js)?',
-          default: false
-        },
-        {
-          type: 'confirm',
-          name: 'hasLocales',
-          message: 'Add locale files?',
-          default: false
-        }
-      ]);
-      
-      const route = answers.route.replace(/^\//, '');
-      const routePath = path.join('pages', route);
+
+      let route = routeArg ? String(routeArg).trim() : '';
+
+      if (!route) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'route',
+            message: 'Page route path (e.g., about or blog/[slug]):',
+            validate: (input) => {
+              if (!input || !input.trim()) return 'Route path is required';
+              return true;
+            },
+          },
+        ]);
+        route = answers.route.trim();
+      }
+
+      // Normalize leading slash
+      route = route.replace(/^\/+/, '');
+      const routePath = path.join(pagesDir, route);
       const dirPath = path.dirname(routePath);
       const fileName = path.basename(routePath);
-      
-      // Create directory
+
       fs.mkdirSync(dirPath, { recursive: true });
-      
-      // Create .njk file
+
       const templateName = fileName === 'index' ? 'index' : fileName;
       const njkFile = path.join(dirPath, `${templateName}.njk`);
-      
+
       const njkContent = `{% extends "layout.njk" %}
 
 {% block content %}
-<div>
-  <h1>{{ t('title') or '${route}' }}</h1>
-  <p>{{ t('description') or 'Page content' }}</p>
-</div>
+<main class="max-w-4xl mx-auto px-4 py-8">
+  <h1 class="text-3xl font-bold tracking-tight text-gray-900 mb-4">{{ title or "${templateName}" }}</h1>
+  <p class="text-gray-600">Page content for <code>${route}</code>.</p>
+</main>
 {% endblock %}
 `;
-      
-      fs.writeFileSync(njkFile, njkContent);
-      console.log(`✅ Created ${njkFile}`);
-      
-      // Create config file if requested
-      if (answers.hasConfig) {
+
+      fs.writeFileSync(njkFile, njkContent, 'utf8');
+      console.log(`\n✅ Created template:\n   ${path.relative(process.cwd(), njkFile)}`);
+
+      // Create companion loader if requested (default: true)
+      if (options.loader !== false) {
         const jsFile = path.join(dirPath, `${templateName}.js`);
-        const jsContent = `module.exports = {
-  async load(req, ctx) {
+        const jsContent = `'use strict';
+
+/**
+ * Server-side data loader for ${templateName}.njk
+ * @type {import('webspresso').PageRouteModule}
+ */
+module.exports = {
+  // Server data loader executed before template rendering
+  async load({ req, res, db, ctx }) {
     return {
-      // Add your data here
+      title: '${templateName.charAt(0).toUpperCase() + templateName.slice(1)}',
     };
   },
-  
-  meta(req, ctx) {
+
+  // Dynamic page metadata
+  meta({ data, ctx }) {
     return {
-      title: ctx.t('meta.title') || '${route}',
-      description: ctx.t('meta.description') || ''
+      title: data.title || '${templateName}',
+      description: 'Page description for ${route}',
     };
-  }
+  },
 };
 `;
-        
-        fs.writeFileSync(jsFile, jsContent);
-        console.log(`✅ Created ${jsFile}`);
+
+        fs.writeFileSync(jsFile, jsContent, 'utf8');
+        console.log(`✅ Created companion loader:\n   ${path.relative(process.cwd(), jsFile)}`);
       }
-      
+
       // Create locales if requested
-      if (answers.hasLocales) {
+      if (options.locales) {
         const localesDir = path.join(dirPath, 'locales');
         fs.mkdirSync(localesDir, { recursive: true });
-        
+
         const enContent = {
-          title: route,
+          title: templateName,
           description: 'Page description',
-          meta: {
-            title: `${route} - Webspresso`,
-            description: 'Page description'
-          }
         };
-        
         fs.writeFileSync(
           path.join(localesDir, 'en.json'),
-          JSON.stringify(enContent, null, 2) + '\n'
+          JSON.stringify(enContent, null, 2) + '\n',
+          'utf8'
         );
-        
-        const deContent = {
-          title: route,
-          description: 'Seitenbeschreibung',
-          meta: {
-            title: `${route} - Webspresso`,
-            description: 'Seitenbeschreibung'
-          }
-        };
-        
-        fs.writeFileSync(
-          path.join(localesDir, 'de.json'),
-          JSON.stringify(deContent, null, 2) + '\n'
-        );
-        
-        console.log(`✅ Created locale files in ${localesDir}`);
+
+        console.log(`✅ Created locales in:\n   ${path.relative(process.cwd(), localesDir)}`);
       }
-      
-      console.log(`\n✅ Page created at ${route}\n`);
+
+      console.log(`\n🎉 Page ready at: /${route}\n`);
     });
 }
 

package/bin/commands/service.js

@@ -191,6 +191,83 @@ function registerCommand(program) {
         }
       }
     });
+
+  // Generator command: service:make <name>
+  program
+    .command('service:make [name]')
+    .alias('make:service')
+    .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')
+    .action(async (nameArg, options) => {
+      const fs = require('fs');
+      let serviceName = nameArg ? String(nameArg).trim() : '';
+
+      if (!serviceName) {
+        const answer = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'serviceName',
+            message: 'Service name (e.g., user.create or payment.process):',
+            validate: (input) => {
+              if (!input || !input.trim()) return 'Service name is required';
+              if (!input.includes('.')) return 'Use dot notation, e.g. domain.action (e.g. user.get)';
+              return true;
+            },
+          },
+        ]);
+        serviceName = answer.serviceName.trim();
+      }
+
+      const parts = serviceName.split('.');
+      const actionName = parts.pop();
+      const domainPath = parts.join(path.sep);
+
+      const servicesDir = path.resolve(process.cwd(), 'services');
+      const targetDir = path.join(servicesDir, domainPath);
+      fs.mkdirSync(targetDir, { recursive: true });
+
+      const serviceFile = path.join(targetDir, `${actionName}.js`);
+      if (fs.existsSync(serviceFile)) {
+        console.error(`\n❌ Error: Service file already exists at ${path.relative(process.cwd(), serviceFile)}\n`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const authLine = options.auth
+        ? `\n  auth: ${options.auth === true || options.auth === 'true' ? 'true' : `'${options.auth}'`}, // Required role or boolean`
+        : '';
+      const trxLine = options.transaction ? '\n  transaction: true, // Automatic ACID transaction propagation' : '';
+
+      const content = `'use strict';
+
+const { z } = require('zod');
+
+/**
+ * Service: ${serviceName}
+ * @type {import('webspresso').ServiceDefinition}
+ */
+module.exports = {
+  // Input validation schema (Zod)
+  schema: z.object({
+    // Define input properties here
+  }),${authLine}${trxLine}
+
+  // Business Logic Handler
+  handler: async (input, { db, service, user }) => {
+    // db.getRepository('ModelName') -> Access repositories
+    // service('other.service', payload) -> Call nested services
+    return {
+      success: true,
+      data: input,
+    };
+  },
+};
+`;
+
+      fs.writeFileSync(serviceFile, content, 'utf8');
+      console.log(`\n✅ Created service "${serviceName}":\n   ${path.relative(process.cwd(), serviceFile)}\n`);
+    });
 }
 
 module.exports = {

package/bin/webspresso.js

@@ -30,12 +30,12 @@ const { registerCommand: registerAdminPassword } = require('./commands/admin-pas
 const { registerCommand: registerFaviconGenerate } = require('./commands/favicon-generate');
 const { registerCommand: registerAuditPrune } = require('./commands/audit-prune');
 const { registerCommand: registerDoctor } = require('./commands/doctor');
-const { registerCommand: registerSkill } = require('./commands/skill');
 const { registerCommand: registerUpgrade } = require('./commands/upgrade');
 const { registerCommand: registerOrmMap } = require('./commands/orm-map');
 const { registerCommand: registerService } = require('./commands/service');
 const { registerCommand: registerMcp } = require('./commands/mcp');
 const { registerCommand: registerPolarMigrate } = require('./commands/polar-migrate');
+const { registerCommand: registerAgentsInit } = require('./commands/agents-init');
 
 registerNew(program);
 registerPage(program);
@@ -54,12 +54,12 @@ registerAdminPassword(program);
 registerFaviconGenerate(program);
 registerAuditPrune(program);
 registerDoctor(program);
-registerSkill(program);
 registerUpgrade(program);
 registerOrmMap(program);
 registerService(program);
 registerMcp(program);
 registerPolarMigrate(program);
+registerAgentsInit(program);
 
 // Parse arguments
 program.parse();

package/core/compileSchema.js

@@ -4,7 +4,7 @@
  */
 
 const { z: zForApi } = require('./validation');
-const schemaCache = require('../utils/schemaCache');
+const schemaCache = require('./schema-cache');
 
 /**
  * Compile schema from an API module

package/core/errors/middleware.js

@@ -123,11 +123,31 @@ function createCentralErrorHandler(options = {}) {
     // Log errors based on severity
     if (status >= 500) {
       if (typeof console !== 'undefined' && console.error) {
-        console.error('[webspresso] Server Error:', err);
+        if (normalized.route || normalized.source) {
+          console.error(
+            `[webspresso] 🚨 Error at ${normalized.method || req.method} ${normalized.route || req.path}` +
+              (normalized.module ? ` [module: ${normalized.module}]` : '') +
+              (normalized.requestId ? ` (reqId: ${normalized.requestId})` : '') +
+              `\n  Source: ${normalized.source || 'unknown'}` +
+              (normalized.phase ? `\n  Phase:  ${normalized.phase}` : '') +
+              `\n`,
+            err
+          );
+        } else {
+          console.error('[webspresso] Server Error:', err);
+        }
       }
     } else if (isDev && status >= 400) {
       if (typeof console !== 'undefined' && console.warn) {
-        console.warn(`[webspresso] HTTP ${status}:`, normalized.message);
+        if (normalized.route || normalized.source) {
+          console.warn(
+            `[webspresso] ⚠️  HTTP ${status} at ${normalized.method || req.method} ${normalized.route || req.path}` +
+              (normalized.module ? ` [module: ${normalized.module}]` : '') +
+              `: ${normalized.message}`
+          );
+        } else {
+          console.warn(`[webspresso] HTTP ${status}:`, normalized.message);
+        }
       }
     }
 

package/core/errors/normalize.js

@@ -79,6 +79,14 @@ function normalizeError(err, isDev = false) {
       httpErr.stack = err.stack;
     }
 
+    // Retain route trace metadata
+    if (err.route) httpErr.route = err.route;
+    if (err.method) httpErr.method = err.method;
+    if (err.source) httpErr.source = err.source;
+    if (err.module) httpErr.module = err.module;
+    if (err.phase) httpErr.phase = err.phase;
+    if (err.requestId) httpErr.requestId = err.requestId;
+
     return httpErr;
   }
 
@@ -99,12 +107,21 @@ function normalizeError(err, isDev = false) {
 
     const msg = typeof err.message === 'string' ? err.message : getStatusTitle(status);
 
-    return new HttpError(status, (status < 500 || isDev) ? msg : getStatusTitle(status), {
+    const httpErr = new HttpError(status, (status < 500 || isDev) ? msg : getStatusTitle(status), {
       code: err.code,
       details: err.details,
       headers: err.headers,
       expose: typeof err.expose === 'boolean' ? err.expose : status < 500,
     });
+
+    if (err.route) httpErr.route = err.route;
+    if (err.method) httpErr.method = err.method;
+    if (err.source) httpErr.source = err.source;
+    if (err.module) httpErr.module = err.module;
+    if (err.phase) httpErr.phase = err.phase;
+    if (err.requestId) httpErr.requestId = err.requestId;
+
+    return httpErr;
   }
 
   return new HttpError(500, 'Internal Server Error', { expose: false });
@@ -151,8 +168,18 @@ function toErrorResponseObject(error, isDev = false) {
     payload.details = error.details;
   }
 
-  // Include stack and cause strictly in development mode
+  // Include stack, cause, and trace strictly in development mode
   if (isDev) {
+    if (error.route || error.source || error.module || error.requestId || error.phase) {
+      payload.trace = {
+        route: error.route || undefined,
+        method: error.method || undefined,
+        source: error.source || undefined,
+        module: error.module || undefined,
+        phase: error.phase || undefined,
+        requestId: error.requestId || undefined,
+      };
+    }
     if (error.stack) {
       payload.stack = error.stack;
     }

package/{utils/schemaCache.js → core/schema-cache.js}

@@ -1,6 +1,7 @@
 /**
  * Schema Cache
  * Caches compiled Zod schemas per file path
+ * @module core/schema-cache
  */
 
 const cache = new Map();
@@ -54,7 +55,5 @@ module.exports = {
   set,
   has,
   clear,
-  del
+  del,
 };
-
-