@triophore/falcon-cli 1.0.1 → 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Triophore Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/auth/basic.js

@@ -1,7 +1,5 @@
 module.exports.validate = async function (request, username, password, CONTXET) {
-    // TODO: Implement your own logic here
-    // Example: Check against database or environment variables
-    if (username === process.env.ADMIN_USER && password === process.env.ADMIN_PASSWORD) {
+    if (username === 'admin' && password === 'secret') {
         return { isValid: true, credentials: { id: 1, name: 'Admin', roles: ['admin'], permissions: { admin: ['*'] } } };
     }
     return { isValid: false };

package/auth/cookie.js

@@ -1,10 +1,6 @@
 module.exports.validate = async function (request, session, CONTXET) {
-    // TODO: Implement your own logic here
-    // Example: Validate session against database or Redis
-    /*
-    if (session.valid) {
-        return { isValid: true, credentials: { id: session.userId, ... } };
+    if (username === 'admin' && password === 'secret') {
+        return { isValid: true, credentials: { id: 1, name: 'Admin', roles: ['admin'], permissions: { admin: ['*'] } } };
     }
-    */
     return { isValid: false };
 }

package/auth/jwt.js

@@ -1,9 +1,6 @@
 module.exports.validate = async function (decoded, CONTXET) {
-    // TODO: Implement your own logic here
-    // Example: Check against database or environment variables
-    // For example, check if a specific environment variable matches a decoded value
-    if (decoded.role === process.env.EXPECTED_ADMIN_ROLE && decoded.secret === process.env.EXPECTED_ADMIN_SECRET) {
-        return { isValid: true, credentials: { id: decoded.sub, name: 'Admin', roles: ['admin'] } };
+    if (username === 'admin' && password === 'secret') {
+        return { isValid: true, credentials: { id: 1, name: 'Admin', roles: ['admin'], permissions: { admin: ['*'] } } };
     }
     return { isValid: false };
 }

package/auth/openid.js

@@ -1,5 +1,6 @@
 module.exports.validate = async function (decoded, CONTXET) {
-    // TODO: Implement your own logic here
-    // Example: Validate OpenID token claims
+    if (username === 'admin' && password === 'secret') {
+        return { isValid: true, credentials: { id: 1, name: 'Admin', roles: ['admin'], permissions: { admin: ['*'] } } };
+    }
     return { isValid: false };
 }

package/index.js

@@ -227,17 +227,17 @@ async function start() {
         }
 
         mkDir.push("models/mongo")  // Fixed: falconjs expects models in models/mongo/
-        mkDir.push("routes")
+        mkDir.push("routes") 
         mkDir.push("services")
         mkDir.push("workers")
         mkDir.push("validators")
         mkDir.push("init")
         mkDir.push("logs")
-
+        
         if (enable_static) {
             mkDir.push("public")
         }
-
+        
         if (enable_templates) {
             mkDir.push("templates")
         }
@@ -332,27 +332,27 @@ async function start() {
 
         // Create example files
         await fs.promises.writeFile(
-            path.join(currentDir, "routes", "example.js"),
+            path.join(currentDir, "routes", "example.js"), 
             await fs.promises.readFile(path.join(__dirname, "templates", "example-route.js"))
         );
-
+        
         await fs.promises.writeFile(
-            path.join(currentDir, "validators", "ExamplePayload.js"),
+            path.join(currentDir, "validators", "ExamplePayload.js"), 
             await fs.promises.readFile(path.join(__dirname, "templates", "example-validator.js"))
         );
-
+        
         await fs.promises.writeFile(
-            path.join(currentDir, "services", "example.js"),
+            path.join(currentDir, "services", "example.js"), 
             await fs.promises.readFile(path.join(__dirname, "templates", "example-service.js"))
         );
-
+        
         await fs.promises.writeFile(
-            path.join(currentDir, "workers", "example.js"),
+            path.join(currentDir, "workers", "example.js"), 
             await fs.promises.readFile(path.join(__dirname, "templates", "example-worker.js"))
         );
-
+        
         await fs.promises.writeFile(
-            path.join(currentDir, "init", "post.js"),
+            path.join(currentDir, "init", "post.js"), 
             await fs.promises.readFile(path.join(__dirname, "templates", "post-init.js"))
         );
 
@@ -408,8 +408,8 @@ MODE=DEV
    2. npm install
    3. npm run dev
 
-📚 Documentation will be available at: http://localhost:[PORT]/documentation
-❤️  Health check at: http://localhost:[PORT]/health
+📚 Documentation will be available at: http://localhost:3000/documentation
+❤️  Health check at: http://localhost:3000/health
 `);
 
 
@@ -486,7 +486,7 @@ async function getProjectInfo() {
 async function create_mongoose_model() {
     mongoose_schema_builder(path.join(currentDir, "models", "mongo")) // Correct path for falconjs
 }
-// await fs.writeFileSync(model_path, JSON.stringify(res,null,2));
+    // await fs.writeFileSync(model_path, JSON.stringify(res,null,2));
 
 
 

package/lib/ProjectGenerator.js

@@ -4,124 +4,224 @@ const path = require("path");
 const { spawn } = require('child_process');
 
 const { showSuccess, runNpmInstall, createDirectory } = require('./utils');
+const ModelGenerator = require('./ModelGenerator');
+const RouteGenerator = require('./RouteGenerator');
 
 class ProjectGenerator {
-    constructor(options = {}) {
-        this.verbose = options.verbose || false;
-        this.skipInstall = options.skipInstall || false;
-        this.useDefaults = options.useDefaults || false;
+  constructor(options = {}) {
+    this.verbose = options.verbose || false;
+    this.skipInstall = options.skipInstall || false;
+    this.useDefaults = options.useDefaults || false;
+  }
+
+  async create(projectName, template = 'basic') {
+    const currentDir = process.cwd();
+
+    // Get project name if not provided
+    if (!projectName) {
+      projectName = await input({
+        message: 'Project name:',
+        validate: v => v.trim() ? true : 'Project name is required',
+      });
     }
 
-    async create(projectName, template = 'basic') {
-        const currentDir = process.cwd();
-        
-        // Get project name if not provided
-        if (!projectName) {
-            projectName = await input({
-                message: 'Project name:',
-                validate: v => v.trim() ? true : 'Project name is required',
-            });
-        }
+    // Feature prompts
+    console.log('\n⚙️  Project Configuration:\n');
 
-        const projectPath = path.join(currentDir, projectName);
-
-        // Check if directory exists
-        try {
-            await fs.access(projectPath);
-            const overwrite = await confirm({
-                message: `Directory "${projectName}" already exists. Overwrite?`,
-                default: false
-            });
-            if (!overwrite) {
-                console.log('❌ Project creation cancelled');
-                return;
-            }
-        } catch (error) {
-            // Directory doesn't exist, which is good
-        }
+    const useSwagger = await confirm({
+      message: 'Enable Swagger/OpenAPI documentation?',
+      default: true
+    });
 
-        console.log(`\n🚀 Creating Falcon.js project: ${projectName}\n`);
+    const useAuth = await confirm({
+      message: 'Include JWT Authentication setup?',
+      default: true
+    });
 
-        // Create project structure
-        await this.createProjectStructure(projectPath, projectName, template);
-        
-        // Install dependencies
-        if (!this.skipInstall) {
-            console.log('📦 Installing dependencies...');
-            await runNpmInstall(projectPath);
-        }
+    // Collect Models
+    const initialModels = []; // Array of { name, content }
+    const createModels = await confirm({
+      message: 'Would you like to create some initial database models?',
+      default: false
+    });
+
+    if (createModels) {
+      const modelGenerator = new ModelGenerator({ verbose: this.verbose });
 
-        showSuccess(projectName, this.skipInstall);
+      while (true) {
+        const modelName = await input({
+          message: 'Model name (leave empty to stop adding models):'
+        });
+
+        if (!modelName.trim()) break;
+
+        // Immediately build the model content (fields, etc.)
+        console.log(`\n📝 Defining model: ${modelName.trim()}`);
+        const content = await modelGenerator.buildModelInteractively(modelName.trim());
+
+        initialModels.push({
+          name: modelName.trim(),
+          content: content
+        });
+
+        console.log(`✅ Model definition saved for: ${modelName.trim()}\n`);
+      }
     }
 
-    async createProjectStructure(projectPath, projectName, template) {
-        // Create directories
-        const directories = [
-            'models/mongo',
-            'routes',
-            'services', 
-            'workers',
-            'validators',
-            'init',
-            'logs',
-            'public'
-        ];
-
-        for (const dir of directories) {
-            await createDirectory(path.join(projectPath, dir));
+    // Collect Routes
+    const initialRoutes = [];
+    const createRoutes = await confirm({
+      message: 'Would you like to create some initial API routes?',
+      default: false
+    });
+
+    if (createRoutes) {
+      while (true) {
+        const routeName = await input({
+          message: 'Route name (leave empty to stop adding routes):'
+        });
+        if (!routeName.trim()) break;
+        initialRoutes.push(routeName.trim());
+      }
+    }
+
+    const projectPath = path.join(currentDir, projectName);
+
+    // Check if directory exists
+    try {
+      await fs.access(projectPath);
+      const overwrite = await confirm({
+        message: `Directory "${projectName}" already exists. Overwrite?`,
+        default: false
+      });
+      if (!overwrite) {
+        console.log('❌ Project creation cancelled');
+        return;
+      }
+    } catch (error) {
+      // Directory doesn't exist, which is good
+    }
+
+    console.log(`\n🚀 Creating Falcon.js project: ${projectName}\n`);
+
+    // Create project structure
+    await this.createProjectStructure(projectPath, projectName, template, {
+      swagger: useSwagger,
+      auth: useAuth,
+      models: initialModels.map(m => m.name),
+      routes: initialRoutes
+    });
+
+    // Generate Models and Routes
+    if (initialModels.length > 0 || initialRoutes.length > 0) {
+      const originalCwd = process.cwd();
+      try {
+        process.chdir(projectPath);
+
+        if (initialModels.length > 0) {
+          console.log('\n🏗️  Generatings initial models...');
+          const modelsDir = path.join(projectPath, 'models', 'mongo');
+
+          for (const model of initialModels) {
+            const modelPath = path.join(modelsDir, `${model.name.toLowerCase()}.js`);
+            await fs.writeFile(modelPath, model.content);
+            console.log(`✅ Model file created: ${modelPath}`);
+          }
         }
 
-        // Create files
-        await this.createPackageJson(projectPath, projectName);
-        await this.createSettings(projectPath, projectName);
-        await this.createIndexJs(projectPath);
-        await this.createEnvFile(projectPath, projectName);
-        await this.createExampleFiles(projectPath);
+        if (initialRoutes.length > 0) {
+          console.log('\n🛣️  Generating initial routes...');
+          const routeGenerator = new RouteGenerator({ verbose: this.verbose });
+          for (const route of initialRoutes) {
+            await routeGenerator.generate(route);
+          }
+        }
+      } catch (err) {
+        console.error('⚠️  Failed to generate initial resources:', err.message);
+      } finally {
+        process.chdir(originalCwd);
+      }
+    }
+
+    // Install dependencies
+    if (!this.skipInstall) {
+      console.log('📦 Installing dependencies...');
+      await runNpmInstall(projectPath);
     }
 
-    async createPackageJson(projectPath, projectName) {
-        const packageJson = {
-            name: projectName,
-            version: "1.0.0",
-            description: "Falcon.js application",
-            main: "index.js",
-            scripts: {
-                start: "node index.js",
-                dev: "nodemon index.js",
-                test: "echo \"Error: no test specified\" && exit 1"
-            },
-            keywords: ["falcon", "nodejs", "api"],
-            author: "",
-            license: "ISC",
-            type: "commonjs",
-            dependencies: {
-                "falconjs": "file:../falconjs",
-                "@hapi/boom": "^10.0.1",
-                "@hapi/inert": "^7.1.0", 
-                "@hapi/vision": "^7.0.3",
-                "joi": "^17.13.3",
-                "mongoose": "^8.3.1",
-                "redis": "^4.7.0",
-                "mqtt": "^5.13.3",
-                "log4js": "^6.9.1",
-                "rate-limiter-flexible": "^2.4.2",
-                "hapi-alive": "^2.0.4",
-                "hapi-swagger": "^17.2.1",
-                "dotenv": "^16.0.0"
-            },
-            devDependencies: {
-                "nodemon": "^3.1.10"
-            }
-        };
-
-        await fs.writeFile(
-            path.join(projectPath, 'package.json'),
-            JSON.stringify(packageJson, null, 2)
-        );
+    showSuccess(projectName, this.skipInstall);
+  }
+
+  async createProjectStructure(projectPath, projectName, template, options = {}) {
+    // Create directories
+    const directories = [
+      'models/mongo',
+      'routes',
+      'services',
+      'workers',
+      'validators',
+      'init',
+      'logs',
+      'public'
+    ];
+
+    for (const dir of directories) {
+      await createDirectory(path.join(projectPath, dir));
     }
 
-    async createSettings(projectPath, projectName) {
-        const settings = `module.exports.settings = {
+    // Create files
+    await this.createPackageJson(projectPath, projectName);
+    await this.createSettings(projectPath, projectName, options);
+    await this.createIndexJs(projectPath);
+    await this.createEnvFile(projectPath, projectName);
+    await this.createExampleFiles(projectPath);
+  }
+
+  async createPackageJson(projectPath, projectName) {
+    const packageJson = {
+      name: projectName,
+      version: "1.0.0",
+      description: "Falcon.js application",
+      main: "index.js",
+      scripts: {
+        start: "node index.js",
+        dev: "nodemon index.js",
+        test: "echo \"Error: no test specified\" && exit 1"
+      },
+      keywords: ["falcon", "nodejs", "api"],
+      author: "",
+      license: "ISC",
+      type: "commonjs",
+      dependencies: {
+        "falconjs": "file:../falconjs",
+        "@hapi/boom": "^10.0.1",
+        "@hapi/inert": "^7.1.0",
+        "@hapi/vision": "^7.0.3",
+        "joi": "^17.13.3",
+        "mongoose": "^8.3.1",
+        "redis": "^4.7.0",
+        "mqtt": "^5.13.3",
+        "log4js": "^6.9.1",
+        "rate-limiter-flexible": "^2.4.2",
+        "hapi-alive": "^2.0.4",
+        "hapi-swagger": "^17.2.1",
+        "dotenv": "^16.0.0"
+      },
+      devDependencies: {
+        "nodemon": "^3.1.10"
+      }
+    };
+
+    await fs.writeFile(
+      path.join(projectPath, 'package.json'),
+      JSON.stringify(packageJson, null, 2)
+    );
+  }
+
+  async createSettings(projectPath, projectName, options = {}) {
+    const { swagger = true, auth = true, models = [], routes = [] } = options;
+
+    const settings = `module.exports.settings = {
   name: "${projectName}",
   http: {
     host: process.env.HTTP_HOST || "localhost",
@@ -156,7 +256,7 @@ class ProjectGenerator {
     }
   },
   swagger: {
-    enabled: true,
+    enabled: ${swagger},
     path: "/documentation"
   },
   auth: {
@@ -167,31 +267,31 @@ class ProjectGenerator {
         return { id: decoded.id, roles: decoded.roles };
       }
     },
-    default: "jwt"
+    default: "${auth ? 'jwt' : 'none'}"
   },
   services: [],
   workers: [],
-  models: [],
-  routes: [],
+  models: ${JSON.stringify(models.map(m => m.toLowerCase()))},
+  routes: ${JSON.stringify(routes.map(r => r.toLowerCase()))},
   crud: {
     exclude: []
   },
   postInit: "post"
 };`;
 
-        await fs.writeFile(path.join(projectPath, 'settings.js'), settings);
-    }
+    await fs.writeFile(path.join(projectPath, 'settings.js'), settings);
+  }
 
-    async createIndexJs(projectPath) {
-        const indexContent = await fs.readFile(
-            path.join(__dirname, '../templates/index.txt'),
-            'utf8'
-        );
-        await fs.writeFile(path.join(projectPath, 'index.js'), indexContent);
-    }
+  async createIndexJs(projectPath) {
+    const indexContent = await fs.readFile(
+      path.join(__dirname, '../templates/index.txt'),
+      'utf8'
+    );
+    await fs.writeFile(path.join(projectPath, 'index.js'), indexContent);
+  }
 
-    async createEnvFile(projectPath, projectName) {
-        const envContent = `# Falcon.js Environment Configuration
+  async createEnvFile(projectPath, projectName) {
+    const envContent = `# Falcon.js Environment Configuration
 # Generated by falcon-cli
 
 # Server Configuration
@@ -221,26 +321,26 @@ LOG_MAX_SIZE=10M
 MODE=DEV
 `;
 
-        await fs.writeFile(path.join(projectPath, '.env'), envContent);
-    }
+    await fs.writeFile(path.join(projectPath, '.env'), envContent);
+  }
 
-    async createExampleFiles(projectPath) {
-        const templates = [
-            { src: 'example-route.js', dest: 'routes/example.js' },
-            { src: 'example-validator.js', dest: 'validators/ExamplePayload.js' },
-            { src: 'example-service.js', dest: 'services/example.js' },
-            { src: 'example-worker.js', dest: 'workers/example.js' },
-            { src: 'post-init.js', dest: 'init/post.js' }
-        ];
-
-        for (const template of templates) {
-            const content = await fs.readFile(
-                path.join(__dirname, '../templates', template.src),
-                'utf8'
-            );
-            await fs.writeFile(path.join(projectPath, template.dest), content);
-        }
+  async createExampleFiles(projectPath) {
+    const templates = [
+      { src: 'example-route.js', dest: 'routes/example.js' },
+      { src: 'example-validator.js', dest: 'validators/ExamplePayload.js' },
+      { src: 'example-service.js', dest: 'services/example.js' },
+      { src: 'example-worker.js', dest: 'workers/example.js' },
+      { src: 'post-init.js', dest: 'init/post.js' }
+    ];
+
+    for (const template of templates) {
+      const content = await fs.readFile(
+        path.join(__dirname, '../templates', template.src),
+        'utf8'
+      );
+      await fs.writeFile(path.join(projectPath, template.dest), content);
     }
+  }
 }
 
 module.exports = ProjectGenerator;

package/lib/RouteGenerator.js

@@ -1,15 +1,15 @@
-const { input, select, confirm } = require("@inquirer/prompts");
-const fs = require("fs").promises;
-const path = require("path");
+const path = require('path');
+const fs = require('fs').promises;
+const { input } = require('@inquirer/prompts');
 
 class RouteGenerator {
     constructor(options = {}) {
         this.verbose = options.verbose || false;
-        this.type = options.type || 'route'; // 'route' or 'validator'
     }
 
     async generate(name) {
         const currentDir = process.cwd();
+        const routesDir = path.join(currentDir, 'routes');
 
         // Check if we're in a Falcon project
         try {
@@ -20,81 +20,48 @@ class RouteGenerator {
 
         if (!name) {
             name = await input({
-                message: `${this.type === 'validator' ? 'Validator' : 'Route'} name (e.g., User):`,
-                validate: v => v.trim() ? true : 'Name is required',
+                message: 'Route name (e.g., users):',
+                validate: v => v.trim() ? true : 'Route name is required',
             });
         }
 
-        if (this.type === 'validator') {
-            await this.generateValidator(currentDir, name);
-        } else {
-            await this.generateRoute(currentDir, name);
-        }
-    }
-
-    async generateRoute(projectDir, name) {
-        const routesDir = path.join(projectDir, 'routes');
-        await fs.mkdir(routesDir, { recursive: true });
-
-        // Determine path and filename
-        // If name contains /, treat as path
-        const parts = name.split('/');
-        const fileName = parts.pop();
-        const subDir = parts.join('/');
+        console.log(`\n🔧 Generating route: ${name}\n`);
 
-        const targetDir = path.join(routesDir, subDir);
-        await fs.mkdir(targetDir, { recursive: true });
-
-        const filePath = path.join(targetDir, `${fileName}.js`);
-
-        // Check if file exists
+        // Create routes directory if it doesn't exist
         try {
-            await fs.access(filePath);
-            const overwrite = await confirm({
-                message: `Route file ${filePath} already exists. Overwrite?`,
-                default: false
-            });
-            if (!overwrite) return;
-        } catch (e) {
-            // File doesn't exist, proceed
+            await fs.mkdir(routesDir, { recursive: true });
+        } catch (error) {
+            // Directory already exists
         }
 
-        // Helper to get template content
-        const templatePath = path.join(__dirname, '..', 'templates', 'example-route.js');
-        let content = await fs.readFile(templatePath, 'utf8');
+        const routeContent = this.getRouteTemplate(name);
+        const routePath = path.join(routesDir, `${name.toLowerCase()}.js`);
 
-        // Simple replacements if needed, or just use the example as a starter
-        // For now, we'll just write the template
+        await fs.writeFile(routePath, routeContent);
 
-        await fs.writeFile(filePath, content);
-        console.log(`✅ Route created: ${filePath}`);
+        console.log(`✅ Route created: ${routePath}`);
     }
 
-    async generateValidator(projectDir, name) {
-        const validatorsDir = path.join(projectDir, 'validators');
-        await fs.mkdir(validatorsDir, { recursive: true });
-
-        const filePath = path.join(validatorsDir, `${name}.js`);
-
-        // Check if file exists
-        try {
-            await fs.access(filePath);
-            const overwrite = await confirm({
-                message: `Validator file ${filePath} already exists. Overwrite?`,
-                default: false
+    getRouteTemplate(name) {
+        return `module.exports.route = async function (context) {
+            context.server.route({
+                method: 'GET',
+                path: '/${name.toLowerCase()}',
+                options: {
+                    tags: ['api', 'example'],
+                    description: 'Example GET endpoint',
+                    notes: 'Returns example data'
+                },
+                handler: async (request, h) => {
+                    return {
+                        success: true,
+                        message: 'Hello from Falcon.js!',
+                        timestamp: new Date().toISOString()
+                    };
+                }
             });
-            if (!overwrite) return;
-        } catch (e) {
-            // File doesn't exist, proceed
-        }
-
-        const templatePath = path.join(__dirname, '..', 'templates', 'example-validator.js');
-        let content = await fs.readFile(templatePath, 'utf8');
-
-        // Replace Joi with Joi (no change needed usually, but good for future)
 
-        await fs.writeFile(filePath, content);
-        console.log(`✅ Validator created: ${filePath}`);
+        };`;
     }
 }
 

package/lib/ServiceGenerator.js

@@ -1,15 +1,17 @@
-const { input, confirm } = require("@inquirer/prompts");
-const fs = require("fs").promises;
-const path = require("path");
+const path = require('path');
+const fs = require('fs').promises;
+const { input } = require('@inquirer/prompts');
 
 class ServiceGenerator {
     constructor(options = {}) {
         this.verbose = options.verbose || false;
-        this.type = options.type || 'service'; // 'service' or 'worker'
+        this.type = options.type || 'service'; // can be 'service' or 'worker'
     }
 
     async generate(name) {
         const currentDir = process.cwd();
+        const baseDir = this.type === 'worker' ? 'workers' : 'services';
+        const targetDir = path.join(currentDir, baseDir);
 
         // Check if we're in a Falcon project
         try {
@@ -20,65 +22,49 @@ class ServiceGenerator {
 
         if (!name) {
             name = await input({
-                message: `${this.type === 'worker' ? 'Worker' : 'Service'} name (e.g., Email):`,
+                message: `${this.type.charAt(0).toUpperCase() + this.type.slice(1)} name:`,
                 validate: v => v.trim() ? true : 'Name is required',
             });
         }
 
-        const dirName = this.type === 'worker' ? 'workers' : 'services';
-        const targetDir = path.join(currentDir, dirName);
-        await fs.mkdir(targetDir, { recursive: true });
+        console.log(`\n🔧 Generating ${this.type}: ${name}\n`);
 
-        const filePath = path.join(targetDir, `${name}.js`);
-
-        // Check if file exists
+        // Create directory if it doesn't exist
         try {
-            await fs.access(filePath);
-            const overwrite = await confirm({
-                message: `${this.type === 'worker' ? 'Worker' : 'Service'} file ${filePath} already exists. Overwrite?`,
-                default: false
-            });
-            if (!overwrite) return;
-        } catch (e) {
-            // File doesn't exist, proceed
+            await fs.mkdir(targetDir, { recursive: true });
+        } catch (error) {
+            // Directory already exists
         }
 
-        // Get template
-        const templateName = this.type === 'worker' ? 'example-worker.js' : 'example-service.js';
-        const templatePath = path.join(__dirname, '..', 'templates', templateName);
-        let content = await fs.readFile(templatePath, 'utf8');
+        const content = this.getTemplate(name);
+        const fileName = `${name.toLowerCase()}.js`;
+        const filePath = path.join(targetDir, fileName);
 
         await fs.writeFile(filePath, content);
-        console.log(`✅ ${this.type === 'worker' ? 'Worker' : 'Service'} created: ${filePath}`);
 
-        // Update settings.js to include the service/worker
-        await this.updateSettings(currentDir, name, dirName);
+        console.log(`✅ ${this.type.charAt(0).toUpperCase() + this.type.slice(1)} created: ${filePath}`);
     }
 
-    async updateSettings(projectDir, name, listName) {
-        const settingsPath = path.join(projectDir, 'settings.js');
-        let settingsContent = await fs.readFile(settingsPath, 'utf8');
+    getTemplate(name) {
+        if (this.type === 'worker') {
+            return `module.exports = async function (job) {
+    // Process job here
+    console.log('Processing job:', job.id);
+    return { done: true };
+};`;
+        }
 
-        // Regex to find the array:  services: [...] or workers: [...]
-        const regex = new RegExp(`${listName}:\\s*\\[(.*?)\\]`, 's');
-        const match = settingsContent.match(regex);
+        return `class ${name}Service {
+    constructor(app) {
+        this.app = app;
+    }
 
-        if (match) {
-            const listContent = match[1];
-            // Simple check if name is already there
-            if (!listContent.includes(`"${name}"`) && !listContent.includes(`'${name}'`)) {
-                const newListContent = listContent.trim()
-                    ? `${listContent.trim()}, "${name}"`
-                    : `"${name}"`;
+    async doSomething() {
+        return 'done';
+    }
+}
 
-                settingsContent = settingsContent.replace(
-                    regex,
-                    `${listName}: [${newListContent}]`
-                );
-                await fs.writeFile(settingsPath, settingsContent);
-                console.log(`✅ Added "${name}" to settings.js ${listName} array`);
-            }
-        }
+module.exports = ${name}Service;`;
     }
 }
 

package/lib/utils.js

@@ -11,6 +11,8 @@ const logo = `
 ╚═╝     ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ╚═╝  ╚═══╝
                                                     
 🚀 Falcon.js CLI - Build powerful Node.js APIs
+Powered by Triophore Technologies
+Visit us at https://triophore.com
 `;
 
 function showLogo() {
@@ -79,15 +81,15 @@ function validateProjectName(name) {
     if (!name || typeof name !== 'string') {
         return 'Project name is required';
     }
-    
+
     if (!/^[a-z0-9-_]+$/i.test(name)) {
         return 'Project name can only contain letters, numbers, hyphens, and underscores';
     }
-    
+
     if (name.length < 2) {
         return 'Project name must be at least 2 characters long';
     }
-    
+
     return true;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triophore/falcon-cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "",
   "main": "index.js",
   "scripts": {

package/readme.md

@@ -1,2 +1,62 @@
-- create project
-- create models for both mongo and sequalize
+# Falcon CLI
+
+Command-line interface for creating and managing Falcon.js applications.
+
+## Installation
+
+```bash
+npm install -g falcon-cli
+```
+
+## Usage
+
+### Create a new project
+```bash
+falcon-cli create my-app
+falcon-cli create my-app --template api
+falcon-cli create my-app --skip-install
+```
+
+### Generate components
+```bash
+# Generate a model
+falcon-cli generate model User
+falcon-cli g model Product --crud
+
+# Generate a route
+falcon-cli generate route users
+
+# Generate a service
+falcon-cli generate service email
+
+# Generate a worker
+falcon-cli generate worker image-processor
+```
+
+## Commands
+
+- `create [name]` - Create a new Falcon.js project
+- `generate <type> [name]` - Generate project components
+  - Types: `model`, `route`, `service`, `worker`, `validator`
+
+## Options
+
+- `--verbose, -V` - Run with verbose logging
+- `--help, -h` - Show help
+- `--version, -v` - Show version
+
+## Project Structure
+
+```
+my-falcon-app/
+├── index.js              # Application entry point
+├── settings.js           # Falcon configuration
+├── .env                  # Environment variables
+├── models/mongo/         # Mongoose models
+├── routes/               # API routes
+├── services/             # Background services
+├── workers/              # Job processors
+├── validators/           # Joi validation schemas
+├── init/                 # Initialization scripts
+└── logs/                 # Application logs
+```

package/templates/example-route.js

@@ -3,10 +3,10 @@
  * This file demonstrates the route structure expected by Falcon.js
  */
 
-module.exports.route = async function (server, context) {
-    
+module.exports.route = async function (context) {
+
     // Example GET route
-    server.route({
+    context.server.route({
         method: 'GET',
         path: '/api/example',
         options: {
@@ -24,7 +24,7 @@ module.exports.route = async function (server, context) {
     });
 
     // Example POST route with validation
-    server.route({
+    context.server.route({
         method: 'POST',
         path: '/api/example',
         options: {
@@ -36,7 +36,7 @@ module.exports.route = async function (server, context) {
         },
         handler: async (request, h) => {
             const { name, email } = request.payload;
-            
+
             // Example: Save to database if models are available
             if (context.models.example) {
                 const result = await context.models.example.create({
@@ -44,14 +44,14 @@ module.exports.route = async function (server, context) {
                     email,
                     createdAt: new Date()
                 });
-                
+
                 return {
                     success: true,
                     data: result,
                     message: 'Data saved successfully'
                 };
             }
-            
+
             return {
                 success: true,
                 message: 'Data received',
@@ -61,7 +61,7 @@ module.exports.route = async function (server, context) {
     });
 
     // Example route that sends job to worker
-    server.route({
+    context.server.route({
         method: 'POST',
         path: '/api/example/job',
         options: {
@@ -70,7 +70,7 @@ module.exports.route = async function (server, context) {
         },
         handler: async (request, h) => {
             const jobData = request.payload;
-            
+
             // Send job to worker via MQTT (if available)
             if (context.mqtt_client) {
                 context.mqtt_client.publish('worker_example_job', JSON.stringify({
@@ -78,13 +78,13 @@ module.exports.route = async function (server, context) {
                     data: jobData,
                     timestamp: new Date().toISOString()
                 }));
-                
+
                 return {
                     success: true,
                     message: 'Job queued for processing'
                 };
             }
-            
+
             return {
                 success: false,
                 message: 'Job queue not available'

package/templates/example-service.js

@@ -1,4 +1,4 @@
-const { FalconBaseService } = require('falconjs');
+const { FalconBaseService } = require('@triophore/falconjs');
 
 /**
  * Example service - rename and customize as needed

package/templates/example-worker.js

@@ -1,4 +1,4 @@
-const { FalconBaseWorker } = require('falconjs');
+const { FalconBaseWorker } = require('@triophore/falconjs');
 
 /**
  * Example worker - rename and customize as needed

package/templates/index.txt

@@ -2,7 +2,7 @@
  * Falcon.js Application Entry Point
  */
 require('dotenv').config();
-const { FalconServer } = require("falconjs");
+const { FalconServer } = require("@triophore/falconjs");
 
 async function main() {
     try {

package/templates/templatev1.json

@@ -8,16 +8,12 @@
     "dev": "nodemon index.js",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": [
-    "falcon",
-    "nodejs",
-    "api"
-  ],
+  "keywords": ["falcon", "nodejs", "api"],
   "author": "",
   "license": "ISC",
   "type": "commonjs",
   "dependencies": {
-    "falconjs": "@triophore/falconjs",
+    "@triophore/falconjs": "^1.0.0",
     "@hapi/boom": "^10.0.1",
     "@hapi/inert": "^7.1.0",
     "@hapi/vision": "^7.0.3",
@@ -35,4 +31,4 @@
   "devDependencies": {
     "nodemon": "^3.1.10"
   }
-}
+}