kaelum 1.7.0 → 1.8.0

package/cli/create.js

@@ -18,11 +18,10 @@ function runInstall(cwd) {
     const cmd = "npm";
     const args = lockExists ? ["ci"] : ["install"];
 
-    // Spawn child process and inherit stdio so user sees progress
     const child = spawn(cmd, args, {
       cwd,
       stdio: "inherit",
-      shell: process.platform === "win32", // improves compatibility on Windows
+      shell: process.platform === "win32",
     });
 
     child.on("error", (err) => {
@@ -38,103 +37,149 @@ function runInstall(cwd) {
 
 /**
  * createProject - create project from template
- * @param {Object} defaults - optional { projectName, template, autoInstall }
+ * @param {Object} defaults - optional { projectName, language, template, autoInstall }
  */
 async function createProject(defaults = {}) {
-  console.log("🚀 Bem-vindo ao Kaelum CLI!");
+  console.log("🚀 Welcome to Kaelum CLI!\n");
 
   try {
-    // ensure templates dir exists
+    // Ensure templates dir exists
     const templatesExists = await fs.pathExists(templatesDir);
     if (!templatesExists) {
-      console.error("❌ Diretório de templates não encontrado no CLI.");
+      console.error("❌ Templates directory not found in CLI.");
       return;
     }
 
-    // gather answers (use defaults when present)
-    const answers = await inq.prompt([
-      {
+    // Gather answers (use defaults when present)
+    const questions = [];
+
+    // Project name
+    if (!defaults.projectName) {
+      questions.push({
         type: "input",
         name: "projectName",
-        message: "Qual será o nome do seu projeto?",
-        default: defaults.projectName || "",
-        validate: (input) => (input ? true : "O nome não pode ser vazio."),
-      },
-      {
+        message: "What is your project name?",
+        validate: (input) => (input ? true : "Project name cannot be empty."),
+      });
+    }
+
+    // Language selection
+    if (!defaults.language) {
+      questions.push({
+        type: "list",
+        name: "language",
+        message: "Choose your language:",
+        choices: [
+          { name: "JavaScript", value: "js" },
+          { name: "TypeScript", value: "ts" },
+        ],
+        default: "js",
+      });
+    }
+
+    // Template selection
+    if (!defaults.template) {
+      questions.push({
         type: "list",
         name: "template",
-        message: "Qual template você deseja usar?",
-        choices: async () => {
-          // list available template folders
-          try {
-            const items = await fs.readdir(templatesDir, {
-              withFileTypes: true,
-            });
-            return items.filter((i) => i.isDirectory()).map((i) => i.name);
-          } catch (e) {
-            return ["web", "api"];
-          }
-        },
-        default: defaults.template || "web",
-      },
-      {
-        type: "confirm",
-        name: "autoInstall",
-        message:
-          "Deseja que eu execute 'npm install' agora (recomendado)?",
-        default:
-          typeof defaults.autoInstall === "boolean"
-            ? defaults.autoInstall
-            : true,
-      },
-    ]);
-
-    const { projectName, template, autoInstall } = answers;
+        message: "Choose your template:",
+        choices: [
+          { name: "web — MVC with views & static files", value: "web" },
+          { name: "api — REST API ready", value: "api" },
+        ],
+        default: "web",
+      });
+    }
+
+    // Auto install
+    questions.push({
+      type: "confirm",
+      name: "autoInstall",
+      message: "Install dependencies now? (recommended)",
+      default:
+        typeof defaults.autoInstall === "boolean"
+          ? defaults.autoInstall
+          : true,
+    });
+
+    const answers = await inq.prompt(questions);
+
+    // Merge defaults with answers
+    const projectName = defaults.projectName || answers.projectName;
+    const language = defaults.language || answers.language;
+    const template = defaults.template || answers.template;
+    const autoInstall = answers.autoInstall;
+
     const targetDir = path.resolve(process.cwd(), projectName);
-    const templateDir = path.join(templatesDir, template);
+    const templateDir = path.join(templatesDir, language, template);
 
-    // template existence check
+    // Template existence check
     const templateExists = await fs.pathExists(templateDir);
     if (!templateExists) {
-      console.error(`\n❌ Template "${template}" não encontrado.`);
+      console.error(`\n❌ Template "${language}/${template}" not found.`);
       return;
     }
 
     if (await fs.pathExists(targetDir)) {
       console.error(
-        `\n❌ A pasta "${projectName}" já existe. Escolha outro nome ou apague a pasta existente.`
+        `\n❌ Folder "${projectName}" already exists. Choose a different name or delete the existing folder.`
       );
       return;
     }
 
-    // copy + update package.json
-    const result = await copyTemplate(templateDir, targetDir, projectName);
+    // Copy template, update package.json, generate .env and .gitignore
+    const isTypeScript = language === "ts";
+    const result = await copyTemplate(templateDir, targetDir, projectName, {
+      isTypeScript,
+    });
     if (!result.ok) {
-      console.error(`\n❌ Erro ao copiar o template: ${result.error}`);
+      console.error(`\n❌ Error copying template: ${result.error}`);
       return;
     }
 
-    console.log(`\n✅ Projeto "${projectName}" criado com sucesso!`);
-    console.log(`➡️  Acesse a pasta: cd ${projectName}`);
+    // Post-creation summary
+    const langLabel = language === "ts" ? "TypeScript" : "JavaScript";
+    console.log(`\n✅ Project "${projectName}" created successfully!`);
+    console.log(`   Language: ${langLabel}`);
+    console.log(`   Template: ${template}`);
+    console.log(`\n📁 cd ${projectName}`);
 
     if (autoInstall) {
-      console.log("⬇️  Instalando dependências (npm)... (isso pode levar alguns minutos)");
+      console.log("📦 Installing dependencies... (this may take a few minutes)\n");
       try {
         await runInstall(targetDir);
-        console.log("\n✅ Dependências instaladas com sucesso!");
-        console.log("➡️  Para iniciar o projeto, execute: npm start\n");
+        console.log("\n✅ Dependencies installed successfully!");
+        if (isTypeScript) {
+          console.log("\n📌 Next steps:");
+          console.log(`   npm run dev     Start development server (tsx watch)`);
+          console.log(`   npm run build   Compile TypeScript to JavaScript`);
+          console.log(`   npm start       Run compiled output\n`);
+        } else {
+          console.log("\n📌 Next steps:");
+          console.log(`   npm start       Start the server`);
+          console.log(`   npm run dev     Start with file watching\n`);
+        }
       } catch (installErr) {
         console.error(
-          "\n❌ Falha ao instalar dependências automaticamente:",
+          "\n❌ Failed to install dependencies automatically:",
           installErr.message || installErr
         );
-        console.log(`➡️  Tente manualmente: cd ${projectName} && npm install`);
+        console.log(`➡️  Try manually: cd ${projectName} && npm install`);
       }
     } else {
-      console.log(`➡️  Inicie o projeto com: cd ${projectName} && npm install && npm start\n`);
+      if (isTypeScript) {
+        console.log(`\n📌 Next steps:`);
+        console.log(`   cd ${projectName} && npm install`);
+        console.log(`   npm run dev     Start development server (tsx watch)`);
+        console.log(`   npm run build   Compile TypeScript to JavaScript`);
+        console.log(`   npm start       Run compiled output\n`);
+      } else {
+        console.log(`\n📌 Next steps:`);
+        console.log(`   cd ${projectName} && npm install && npm start\n`);
+      }
     }
   } catch (err) {
-    console.error("❌ Erro inesperado:", err.message || err);
+    console.error("❌ Unexpected error:", err.message || err);
   }
 }
 

package/cli/index.js

@@ -1,20 +1,91 @@
 #!/usr/bin/env node
 const { createProject } = require("./create");
+const path = require("path");
 const argv = process.argv.slice(2);
 
+function getVersion() {
+  const pkg = require(path.join(__dirname, "..", "package.json"));
+  return pkg.version;
+}
+
+function printVersion() {
+  console.log(`kaelum v${getVersion()}`);
+}
+
+function printInfo() {
+  const os = require("os");
+  console.log(`Kaelum CLI`);
+  console.log(`  Kaelum:   v${getVersion()}`);
+  console.log(`  Node.js:  ${process.version}`);
+  console.log(`  OS:       ${os.type()} ${os.release()} (${os.arch()})`);
+  console.log(`  Platform: ${os.platform()}`);
+}
+
 function printHelp() {
-  console.log(`Kaelum CLI
+  console.log(`
+Kaelum CLI v${getVersion()}
+
 Usage:
-  kaelum create             # interactive
-  kaelum create <name>      # create using interactive template choice
-  kaelum create <name> --template web|api   # non-interactive (name provided, template preselected)
-  kaelum help
+  kaelum create                                  Interactive mode
+  kaelum create <name>                           Interactive template choice
+  kaelum create <name> --template <template>     Non-interactive
+
+Templates:
+  js-web     JavaScript + MVC with views & static files
+  js-api     JavaScript + REST API
+  ts-web     TypeScript + MVC with views & static files
+  ts-api     TypeScript + REST API
+  web        Alias for js-web
+  api        Alias for js-api
+
+Commands:
+  kaelum help              Show this help message
+  kaelum --version, -v     Show installed version
+  kaelum info              Show environment information
+
+Examples:
+  kaelum create my-app --template ts-web
+  kaelum create my-api --template js-api
 `);
 }
 
+/**
+ * Resolve legacy template aliases for backward compatibility.
+ * "web" -> "js-web", "api" -> "js-api"
+ */
+function resolveTemplateAlias(template) {
+  const aliases = { web: "js-web", api: "js-api" };
+  return aliases[template] || template;
+}
+
+/**
+ * Parse a combined template value like "js-web" into { language, template }.
+ * Returns null if invalid.
+ */
+function parseTemplate(value) {
+  const resolved = resolveTemplateAlias(value);
+  const valid = {
+    "js-web": { language: "js", template: "web" },
+    "js-api": { language: "js", template: "api" },
+    "ts-web": { language: "ts", template: "web" },
+    "ts-api": { language: "ts", template: "api" },
+  };
+  return valid[resolved] || null;
+}
+
 async function main() {
   const [command, maybeName, maybeFlag, maybeTemplate] = argv;
 
+  // Version flag
+  if (
+    command === "--version" ||
+    command === "-v"
+  ) {
+    printVersion();
+    return;
+  }
+
+  // Help or no command
   if (
     !command ||
     command === "help" ||
@@ -25,25 +96,41 @@ async function main() {
     return;
   }
 
+  // Info command
+  if (command === "info") {
+    printInfo();
+    return;
+  }
+
   if (command === "create") {
-    // non-interactive shorthand: kaelum create my-app --template web
+    // Non-interactive shorthand: kaelum create my-app --template ts-web
     if (maybeName && maybeFlag === "--template" && maybeTemplate) {
-      await createProject({ projectName: maybeName, template: maybeTemplate });
+      const parsed = parseTemplate(maybeTemplate);
+      if (!parsed) {
+        console.log(`Unknown template: "${maybeTemplate}"`);
+        console.log(`Available templates: js-web, js-api, ts-web, ts-api (or aliases: web, api)`);
+        return;
+      }
+      await createProject({
+        projectName: maybeName,
+        language: parsed.language,
+        template: parsed.template,
+      });
       return;
     }
 
-    // non-interactive shorthand: kaelum create my-app  (will still ask template)
+    // Semi-interactive: kaelum create my-app (will ask language + template)
     if (maybeName && !maybeFlag) {
       await createProject({ projectName: maybeName });
       return;
     }
 
-    // otherwise interactive flow
+    // Fully interactive
     await createProject();
     return;
   }
 
-  console.log(`Comando não reconhecido: ${command}`);
+  console.log(`Unknown command: "${command}"`);
   printHelp();
 }
 

package/cli/templates/js/api/app.js

@@ -0,0 +1,30 @@
+const kaelum = require("kaelum");
+
+const app = kaelum();
+
+// Configure security and logging
+app.setConfig({
+  cors: true,
+  helmet: true,
+  logs: true,
+  bodyParser: true,
+});
+
+// Mount routes
+const routes = require("./routes");
+routes(app);
+
+// Health check endpoint
+app.healthCheck("/health");
+
+// Graceful shutdown hook
+app.onShutdown(() => {
+  console.log("Cleaning up resources...");
+});
+
+// Error handler (JSON responses)
+app.useErrorHandler({ exposeStack: false });
+
+// Start server
+const PORT = process.env.PORT || 4000;
+app.start(PORT);

package/cli/templates/{api → js/api}/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kaelum-api-app",
   "version": "0.1.0",
-  "description": "Exemplo de app API gerado pela CLI Kaelum",
+  "description": "REST API application generated by Kaelum CLI (api template)",
   "scripts": {
     "start": "node app.js",
     "dev": "node --watch app.js"
@@ -13,10 +13,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "kaelum": "^1.4.2",
-    "cors": "^2.8.5",
-    "helmet": "^6.0.0",
-    "morgan": "^1.10.0"
+    "kaelum": "^1.8.0"
   },
   "devDependencies": {}
 }

package/cli/templates/{api → js/api}/routes.js

@@ -5,29 +5,29 @@ const auth = require("./middlewares/authMock");
 module.exports = (app) => {
   // Global middleware for /users path
   app.setMiddleware("/users", (req, res, next) => {
-    // Simple method check
+    // Require auth on POST requests
     if (req.method === "POST") return auth(req, res, next);
     next();
   });
 
-  // Recursive Nested Routing Example
+  // RESTful nested routing example
   app.apiRoute("users", {
-    get: users.list,   // GET /users
-    post: users.create, // POST /users (protected by middleware above)
+    get: users.list,
+    post: users.create,
 
     // Nested parameter: /users/:id
     "/:id": {
-      get: users.get, // GET /users/:id
+      get: users.get,
 
       // Nested resource: /users/:id/posts
       "/posts": {
-        get: users.posts, // GET /users/:id/posts
+        get: users.posts,
       },
     },
   });
 
   // Metadata endpoint
   app.addRoute("/meta", {
-    get: (req, res) => res.json({ version: "1.4.2", framework: "Kaelum" }),
+    get: (req, res) => res.json({ version: "1.8.0", framework: "Kaelum" }),
   });
 };

package/cli/templates/js/web/app.js

@@ -0,0 +1,30 @@
+const kaelum = require("kaelum");
+
+const app = kaelum();
+
+// Configure security, static files, and body parsing
+app.setConfig({
+  cors: true,
+  helmet: true,
+  static: "public",
+  bodyParser: true,
+});
+
+// Register routes
+const routes = require("./routes");
+routes(app);
+
+// Health check endpoint
+app.healthCheck("/health");
+
+// Graceful shutdown hook
+app.onShutdown(() => {
+  console.log("Cleaning up resources...");
+});
+
+// Error handler (returns JSON on errors)
+app.useErrorHandler({ exposeStack: false });
+
+// Start server
+const PORT = process.env.PORT || 3000;
+app.start(PORT);

package/cli/templates/{web → js/web}/controllers/pagesController.js

@@ -8,11 +8,11 @@ exports.home = (req, res) => {
 };
 
 exports.about = (req, res) => {
-  res.send("<h1>About Kaelum</h1><p>A minimalist framework.</p>");
+  res.send("<h1>About Kaelum</h1><p>A minimalist Node.js framework.</p>");
 };
 
 exports.team = (req, res) => {
-  res.send("<h1>Our Team</h1><p>Built by open source contributors.</p>");
+  res.send("<h1>Our Team</h1><p>Built by open-source contributors.</p>");
 };
 
 exports.dashboard = (req, res) => {

package/cli/templates/{web → js/web}/middlewares/logger.js

@@ -1,4 +1,5 @@
-// example middleware: simple request logger
+// middlewares/logger.js
+// Simple request logger middleware
 module.exports = function (req, res, next) {
   const now = new Date();
   console.log(`[${now.toISOString()}] ${req.method} ${req.originalUrl}`);

package/cli/templates/{web → js/web}/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kaelum-web-app",
   "version": "0.1.0",
-  "description": "Exemplo de app gerado pela CLI Kaelum (web template)",
+  "description": "Web application generated by Kaelum CLI (web template)",
   "scripts": {
     "start": "node app.js",
     "dev": "node --watch app.js"
@@ -13,9 +13,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "kaelum": "^1.4.2",
-    "cors": "^2.8.5",
-    "helmet": "^6.0.0"
+    "kaelum": "^1.8.0"
   },
   "devDependencies": {}
 }

package/cli/templates/{web → js/web}/public/style.css

@@ -44,6 +44,7 @@ header h1 {
   display: flex;
   gap: 16px;
   margin-top: 12px;
+  flex-wrap: wrap;
 }
 
 .card {
@@ -52,6 +53,7 @@ header h1 {
   padding: 16px;
   box-shadow: 0 6px 18px rgba(37, 57, 99, 0.06);
   flex: 1;
+  min-width: 200px;
 }
 
 .small {

package/cli/templates/{web → js/web}/routes.js

@@ -4,16 +4,15 @@ const logger = require("./middlewares/logger");
 
 // Mock auth middleware
 const auth = (req, res, next) => {
-  // Simulate auth check
-  req.user = "Admin"; 
+  req.user = "Admin";
   next();
 };
 
 module.exports = (app) => {
-  // Home
+  // Home page
   app.addRoute("/", pages.home);
 
-  // Nested Route Example: /about and /about/team
+  // Nested route example: /about and /about/team
   app.addRoute("/about", {
     get: pages.about,
     "/team": {
@@ -21,7 +20,7 @@ module.exports = (app) => {
     },
   });
 
-  // Middleware Chain Example
+  // Middleware chain example
   const secureSection = [logger, auth];
 
   // Dashboard with nested settings, protected by middleware chain

package/cli/templates/{web → js/web}/views/index.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html lang="pt-BR">
+<html lang="en">
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width,initial-scale=1" />
@@ -11,33 +11,37 @@
       <header>
         <h1>Kaelum.js</h1>
         <p class="subtitle">
-          Framework simplificada para Web e APIs — Template de demonstração
+          Minimalist framework for Web Apps &amp; APIs — Demo Template
         </p>
       </header>
 
       <section class="content">
-        <h2>Bem-vindo(a) 👋</h2>
+        <h2>Welcome 👋</h2>
         <p>
-          Este é um template gerado automaticamente pela CLI do
-          <strong>Kaelum</strong>.
+          This template was automatically generated by the
+          <strong>Kaelum</strong> CLI.
         </p>
 
         <div class="cards">
           <div class="card">
-            <h3>Rotas</h3>
+            <h3>Routes</h3>
             <p>
-              Veja as rotas: <code>/</code>, <code>/about</code>, <code>/about/team</code>,
+              Available routes: <code>/</code>, <code>/about</code>, <code>/about/team</code>,
               <code>/dashboard</code>, <code>/dashboard/settings</code>.
             </p>
           </div>
           <div class="card">
-            <h3>Segurança</h3>
-            <p>CORS e Helmet foram ativados via <code>app.setConfig</code>.</p>
+            <h3>Security</h3>
+            <p>CORS and Helmet are enabled via <code>app.setConfig</code>.</p>
+          </div>
+          <div class="card">
+            <h3>Health Check</h3>
+            <p>Built-in health endpoint at <code>/health</code>.</p>
           </div>
         </div>
 
         <p class="small">
-          Gerado pela Kaelum CLI • Versão do template para Kaelum v1.4.2
+          Generated by Kaelum CLI &bull; Kaelum v1.8.0
         </p>
       </section>
     </main>

package/cli/templates/ts/api/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "kaelum-api-app",
+  "version": "0.1.0",
+  "description": "REST API application generated by Kaelum CLI (TypeScript api template)",
+  "scripts": {
+    "start": "node dist/app.js",
+    "dev": "tsx watch src/app.ts",
+    "build": "tsc"
+  },
+  "keywords": [
+    "kaelum",
+    "api",
+    "typescript"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "kaelum": "^1.8.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.0",
+    "tsx": "^4.19.0"
+  }
+}