@ezetgalaxy/titan 25.15.4 → 25.15.5

package/README.md

@@ -11,10 +11,10 @@
 # Notice
 
 ✅ **Production mode is ready**
-💙 **Enjoy development mode `tit dev`**
+💙 **Enjoy development mode `titan dev`**
 ✅ **No more `globalThis` required**
 💟 **Website for titan docs: https://titan-docs-ez.vercel.app/docs**
-
+🚀 **CLI: `titan` is now the canonical command. `tit` remains supported as an alias.**
 
 ---
 
@@ -94,9 +94,9 @@ npm install -g @ezetgalaxy/titan
 ### Create a new project
 
 ```bash
-tit init my-app
+titan init my-app
 cd my-app
-tit dev
+titan dev
 ```
 
 Titan will:
@@ -119,7 +119,7 @@ npm install -g @ezetgalaxy/titan@latest
 * Then 
 
 ```bash
-tit update
+titan update
 ```
 * ``tit update`` will update and add new features in your Titan project
 
@@ -179,7 +179,7 @@ This object is:
 
 ### 🔥 Developer Experience
 
-* Hot reload dev server (`tit dev`)
+* Hot reload dev server (`titan dev`)
 * Automatic rebundling of actions
 * Automatic Rust server restart
 * Colored request logs

package/index.js

@@ -8,23 +8,73 @@ import { fileURLToPath } from "url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-/* Colors */
+/* -------------------------------------------------------
+ * Colors (MUST be defined before usage)
+ * ----------------------------------------------------- */
 const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
 const green = (t) => `\x1b[32m${t}\x1b[0m`;
 const yellow = (t) => `\x1b[33m${t}\x1b[0m`;
 const red = (t) => `\x1b[31m${t}\x1b[0m`;
 const bold = (t) => `\x1b[1m${t}\x1b[0m`;
 
+/* -------------------------------------------------------
+ * Invocation detection (tit vs titan)
+ * ----------------------------------------------------- */
+function wasInvokedAsTit() {
+    // Case 1: direct binary (global / local)
+    const argv = process.argv.map(a => a.toLowerCase());
+    const direct =
+        argv[1]?.endsWith("tit") ||
+        argv[1]?.endsWith("tit.cmd") ||
+        argv[1]?.endsWith("tit.ps1");
+
+    if (direct) return true;
+
+    // Case 2: npx / npm exec
+    const npmArgvRaw = process.env.npm_config_argv;
+    if (!npmArgvRaw) return false;
+
+    try {
+        const npmArgv = JSON.parse(npmArgvRaw);
+
+        // npm stores original command here
+        return npmArgv.original?.includes("tit");
+    } catch {
+        return false;
+    }
+}
+
+const isTitAlias = wasInvokedAsTit();
+
+if (isTitAlias) {
+    console.log(
+        yellow(
+            "[Notice] `tit` is deprecated. Please use `titan` instead.\n" +
+            "        `tit` will continue to work for now."
+        )
+    );
+}
+
+
+
+
+/* -------------------------------------------------------
+ * Args
+ * ----------------------------------------------------- */
 const args = process.argv.slice(2);
 const cmd = args[0];
 
-/* Titan version (read from package.json) */
+/* -------------------------------------------------------
+ * Titan version
+ * ----------------------------------------------------- */
 const pkg = JSON.parse(
     fs.readFileSync(path.join(__dirname, "package.json"), "utf8")
 );
 const TITAN_VERSION = pkg.version;
 
-/* Safe copy directory */
+/* -------------------------------------------------------
+ * Utils
+ * ----------------------------------------------------- */
 function copyDir(src, dest) {
     fs.mkdirSync(dest, { recursive: true });
 
@@ -40,21 +90,27 @@ function copyDir(src, dest) {
     }
 }
 
-/* HELP */
+/* -------------------------------------------------------
+ * HELP
+ * ----------------------------------------------------- */
 function help() {
     console.log(`
 ${bold(cyan("Titan Planet"))}  v${TITAN_VERSION}
 
-${green("tit init <project>")}   Create new Titan project
-${green("tit dev")}              Dev mode (hot reload)
-${green("tit build")}            Build production Rust server
-${green("tit start")}            Start production binary
-${green("tit update")}           Update Titan engine
-${green("tit --version")}        Show Titan CLI version
+${green("titan init <project>")}   Create new Titan project
+${green("titan dev")}              Dev mode (hot reload)
+${green("titan build")}            Build production Rust server
+${green("titan start")}            Start production binary
+${green("titan update")}           Update Titan engine
+${green("titan --version")}        Show Titan CLI version
+
+${yellow("Note: `tit` is supported as a legacy alias.")}
 `);
 }
 
-/* INIT PROJECT */
+/* -------------------------------------------------------
+ * INIT
+ * ----------------------------------------------------- */
 function initProject(name) {
     if (!name) return console.log(red("Usage: tit init <project>"));
 
@@ -92,7 +148,9 @@ Next steps:
 `);
 }
 
-/* BUNDLER (absolute path, Railway-safe) */
+/* -------------------------------------------------------
+ * BUNDLER
+ * ----------------------------------------------------- */
 function runBundler(root) {
     const bundler = path.join(root, "titan", "bundle.js");
 
@@ -104,7 +162,9 @@ function runBundler(root) {
     execSync(`node "${bundler}"`, { stdio: "inherit" });
 }
 
-/* DEV SERVER — HOT RELOAD */
+/* -------------------------------------------------------
+ * DEV SERVER
+ * ----------------------------------------------------- */
 async function devServer() {
     const root = process.cwd();
     console.log(cyan("Titan Dev Mode — Hot Reload Enabled"));
@@ -180,8 +240,9 @@ async function devServer() {
     });
 }
 
-/* PRODUCTION BUILD */
-// BUILD RELEASE — PRODUCTION READY
+/* -------------------------------------------------------
+ * BUILD
+ * ----------------------------------------------------- */
 function buildProd() {
     console.log(cyan("Titan: Building production output..."));
 
@@ -231,9 +292,9 @@ function buildProd() {
     console.log(green("✔ Titan production build complete!"));
 }
 
-
-
-/* START PRODUCTION BINARY */
+/* -------------------------------------------------------
+ * START
+ * ----------------------------------------------------- */
 function startProd() {
     const isWin = process.platform === "win32";
     const bin = isWin ? "titan-server.exe" : "titan-server";
@@ -242,7 +303,9 @@ function startProd() {
     execSync(`"${exe}"`, { stdio: "inherit" });
 }
 
-/* UPDATE TITAN */
+/* -------------------------------------------------------
+ * UPDATE
+ * ----------------------------------------------------- */
 function updateTitan() {
     const root = process.cwd();
     const projectTitan = path.join(root, "titan");
@@ -305,36 +368,20 @@ function updateTitan() {
 
     console.log(bold(green("✔ Titan update complete")));
 }
-
-
-/* ROUTER */
+/* -------------------------------------------------------
+ * ROUTER
+ * ----------------------------------------------------- */
 switch (cmd) {
-    case "init":
-        initProject(args[1]);
-        break;
-
-    case "dev":
-        devServer();
-        break;
-
-    case "build":
-        buildProd();
-        break;
-
-    case "start":
-        startProd();
-        break;
-
-    case "update":
-        updateTitan();
-        break;
-
+    case "init": initProject(args[1]); break;
+    case "dev": devServer(); break;
+    case "build": buildProd(); break;
+    case "start": startProd(); break;
+    case "update": updateTitan(); break;
     case "--version":
     case "-v":
     case "version":
-        console.log(green(`Titan v${TITAN_VERSION}`));
+        console.log(cyan(`Titan v${TITAN_VERSION}`));
         break;
-
     default:
         help();
 }

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "25.15.4",
+  "version": "25.15.5",
   "description": "JavaScript backend framework that compiles your JS into a Rust + Axum server.",
   "license": "ISC",
   "author": "ezetgalaxy",
   "type": "module",
   "main": "index.js",
   "bin": {
-    "tit": "./index.js"
+    "tit": "./index.js",
+    "titan": "./index.js"
   },
   "files": [
     "index.js",

package/templates/Dockerfile

@@ -19,7 +19,7 @@ COPY . .
 RUN npm install
 
 # Build Titan metadata + bundle JS actions
-RUN tit build
+RUN titan build
 
 # Build Rust binary
 RUN cd server && cargo build --release

package/templates/titan/bundle.js

@@ -1,62 +0,0 @@
-import fs from "fs";
-import path from "path";
-import esbuild from "esbuild";
-
-const root = process.cwd();
-const actionsDir = path.join(root, "app", "actions");
-const outDir = path.join(root, "server", "actions");
-
-export async function bundle() {
-  console.log("[Titan] Bundling actions...");
-
-  fs.mkdirSync(outDir, { recursive: true });
-
-  // Clean old bundles
-  for (const file of fs.readdirSync(outDir)) {
-    fs.unlinkSync(path.join(outDir, file));
-  }
-
-  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith(".js"));
-
-  for (const file of files) {
-    const actionName = path.basename(file, ".js");
-
-    const entry = path.join(actionsDir, file);
-
-    // Rust runtime expects `.jsbundle` extension — consistent with previous design
-    const outfile = path.join(outDir, file.replace(".js", ".jsbundle"));
-
-    console.log(`[Titan] Bundling ${entry} → ${outfile}`);
-
-    await esbuild.build({
-      entryPoints: [entry],
-      outfile,
-      bundle: true,
-      format: "iife",
-      globalName: "__titan_exports",
-      platform: "neutral",
-      target: "es2020",
-
-      footer: {
-        js: `
-    (function () {
-      const fn =
-        __titan_exports["${actionName}"] ||
-        __titan_exports.default;
-    
-      if (typeof fn !== "function") {
-        throw new Error("[Titan] Action '${actionName}' not found or not a function");
-      }
-    
-      globalThis["${actionName}"] = fn;
-    })();
-    `
-      }
-    });
-
-
-
-  }
-
-  console.log("[Titan] Bundling finished.");
-}

package/templates/titan/dev.js

@@ -1,67 +0,0 @@
-import chokidar from "chokidar";
-import { spawn, execSync } from "child_process";
-import path from "path";
-import { fileURLToPath } from "url";
-import { bundle } from "./bundle.js";
-
-// Required for __dirname in ES modules
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-let serverProcess = null;
-
-function startRustServer() {
-    if (serverProcess) {
-        serverProcess.kill();
-    }
-
-    const serverPath = path.join(process.cwd(), "server");
-
-    serverProcess = spawn("cargo", ["run"], {
-        cwd: serverPath,
-        stdio: "inherit",
-        shell: true
-    });
-
-    serverProcess.on("close", (code) => {
-        console.log(`[Titan] Rust server exited: ${code}`);
-    });
-}
-
-async function rebuild() {
-    console.log("[Titan] Regenerating routes.json & action_map.json...");
-    execSync("node app/app.js", { stdio: "inherit" });
-
-    console.log("[Titan] Bundling JS actions...");
-    await bundle();
-}
-
-async function startDev() {
-    console.log("[Titan] Dev mode starting...");
-
-    // FIRST BUILD
-    await rebuild();
-    startRustServer();
-
-    const watcher = chokidar.watch("app", {
-        ignoreInitial: true
-    });
-
-    let timer = null;
-
-    watcher.on("all", async (event, file) => {
-        if (timer) clearTimeout(timer);
-
-        timer = setTimeout(async () => {
-            console.log(`[Titan] Change detected: ${file}`);
-
-            await rebuild();
-
-            console.log("[Titan] Restarting Rust server...");
-            startRustServer();
-
-        }, 200);
-    });
-}
-
-startDev();

package/templates/titan/titan.js

@@ -1,82 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { bundle } from "./bundle.js";
-
-const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
-const green = (t) => `\x1b[32m${t}\x1b[0m`;
-
-const routes = {};
-const dynamicRoutes = {};
-const actionMap = {};
-
-function addRoute(method, route) {
-  const key = `${method.toUpperCase()}:${route}`;
-
-
-  return {
-    reply(value) {
-      routes[key] = {
-        type: typeof value === "object" ? "json" : "text",
-        value
-      };
-    },
-
-    action(name) {
-      if (route.includes(":")) {
-        if (!dynamicRoutes[method]) dynamicRoutes[method] = [];
-        dynamicRoutes[method].push({
-          method: method.toUpperCase(),
-          pattern: route,
-          action: name
-        });
-      } else {
-        routes[key] = {
-          type: "action",
-          value: name
-        };
-        actionMap[key] = name;
-      }
-    }
-  };
-}
-
-const t = {
-  get(route) {
-    return addRoute("GET", route);
-  },
-
-  post(route) {
-    return addRoute("POST", route);
-  },
-
-  async start(port = 3000, msg = "") {
-    console.log(cyan("[Titan] Bundling actions..."));
-    await bundle();
-
-    const base = path.join(process.cwd(), "server");
-    fs.mkdirSync(base, { recursive: true });
-
-    fs.writeFileSync(
-      path.join(base, "routes.json"),
-      JSON.stringify(
-        {
-          __config: { port },
-          routes,
-          __dynamic_routes: Object.values(dynamicRoutes).flat()
-        },
-        null,
-        2
-      )
-    );
-
-    fs.writeFileSync(
-      path.join(base, "action_map.json"),
-      JSON.stringify(actionMap, null, 2)
-    );
-
-    console.log(green(`Titan: routes.json + action_map.json written -> ${base}`));
-    if (msg) console.log(cyan(msg));
-  }
-};
-
-export default t;