titanpl 1.0.0 → 1.4.0

package/README.md

@@ -9,8 +9,8 @@
 </p>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/@ezetgalaxy/titan">
-    <img src="https://img.shields.io/npm/v/@ezetgalaxy/titan?style=for-the-badge&logo=npm&logoColor=white" />
+  <a href="https://www.npmjs.com/package/titanpl">
+    <img src="https://img.shields.io/npm/v/titanpl?style=for-the-badge&logo=npm&logoColor=white" />
   </a>
 
   <img src="https://img.shields.io/badge/Runtime-Gravity(V8)%20%26%20Rust%20Tokio-1f2937?style=for-the-badge" />
@@ -84,8 +84,9 @@ Titan handles the integration automatically.
 * **Node.js** (v18+): Required for CLI and JS tooling.
 
 ### 2. Install CLI
+**The `titanpl` CLI is used to create and manage all your new projects and everything related to Titan.**
 ```bash
-npm install -g @ezetgalaxy/titan
+npm install -g @titanpl/cli@latest
 ```
 
 ### 3. Initialize & Run
@@ -103,29 +104,25 @@ titan init my-app
 1.  `Standard` (Pure JS/TS)
 2.  `Rust + JS/TS (Hybrid)` (High-performance native actions)
 
-This creates one of four isolated environments:
-*   **Standard JS:** Lightweight server, zero Rust overhead.
-*   **Standard TS:** Strict server, zero Rust overhead.
-*   **Hybrid JS:** Full Rust integration + JS flexibility.
-*   **Hybrid TS:** Full Rust integration + TS strictness.
-
 Inside your project:
 ```bash
 cd my-app
-titan dev
+npm run dev
 ```
 
 You'll see the Titan Dev Server spin up:
 ```
-  Titan Planet   v26.16.0   [ Dev Mode ]
+  ⏣ Titan Planet   v1.0.0   [ Dev Mode ]
 
-  Type:        Rust + TS Actions
+  Type:        TS Actions
   Hot Reload:  Enabled
-  Strict Mode: Active 🛡️
+  Env:         Loaded
+
+🚀 Starting Titan Engine...
+[Titan] 1 reply route(s) pre-computed
+Titan server running at: http://localhost:5100  (Threads: 32, Stack: 8MB, Dev Mode)
+
 
-  • Preparing runtime... Done
-  • A new orbit is ready for your app in 0.9s
-  • Your app is now orbiting Titan Planet
 ```
 
 
@@ -136,7 +133,7 @@ Titan is unique because it allows you to write endpoints in **JavaScript, TypeSc
 | Feature | Status | Notes |
 | :--- | :--- | :--- |
 | **Standard JavaScript** | ✅ Stable | Production Ready |
-| **Standard TypeScript** | 🚧 Beta | **Ready for Dev**, Production Under Testing |
+| **Standard TypeScript** | ✅ Stable | Production Ready |
 | **Rust + JS (Hybrid)** | 🧪 Experimental | **Dev Only**, Production Under Testing |
 | **Rust + TS (Hybrid)** | 🧪 Experimental | **Dev Only**, Production Under Testing |
 
@@ -144,7 +141,7 @@ Titan is unique because it allows you to write endpoints in **JavaScript, TypeSc
 Fully typed, strict, and auto-compiled.
 
 ```typescript
-import { defineAction } from "../../titan/titan";
+import { defineAction } from "@titanpl/native";
 
 interface HelloResponse {
     message: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "titanpl",
-  "version": "1.0.0",
+  "version": "1.4.0",
   "description": "Titan Planet is a JavaScript-first backend framework that embeds JS actions into a Rust + Axum server and ships as a single native binary. Routes are compiled to static metadata; only actions run in the embedded JS runtime. No Node.js. No event loop in production.",
   "license": "ISC",
   "author": "ezetgalaxy",
@@ -8,7 +8,8 @@
   "main": "index.js",
   "bin": {
     "tit": "./packages/cli/index.js",
-    "titan": "./packages/cli/index.js"
+    "titan": "./packages/cli/index.js",
+    "titanpl": "./packages/cli/index.js"
   },
   "workspaces": [
     "packages/*",
@@ -16,6 +17,7 @@
   ],
   "files": [
     "index.js",
+    "packages/",
     "templates/",
     "titanpl-sdk",
     "README.md"
@@ -69,8 +71,8 @@
     "test:all": "vitest run && vitest run --config vitest.config.e2e.ts"
   },
   "dependencies": {
-    "@titanpl/core": "26.16.0",
-    "@titanpl/node": "26.16.0",
+    "@titanpl/core": "1.4.0",
+    "@titanpl/node": "1.4.0",
     "chokidar": "^5.0.0",
     "esbuild": "^0.27.2",
     "prompts": "^2.4.2"
@@ -80,4 +82,4 @@
     "@vitest/ui": "^4.0.17",
     "vitest": "^4.0.17"
   }
-}
+}

package/packages/cli/README.md

@@ -0,0 +1,17 @@
+# @titanpl/cli
+
+The command-line interface (CLI) for Titan Planet. It provides the `titan` and `tit` commands for initializing, building, and running Titan Planet servers.
+
+## What it works (What it does)
+The CLI is responsible for bridging your JavaScript codebase with the underlying Rust/Axum engine. It handles scaffolding, compiling JS actions, generating metadata, and running the server.
+
+## How it works
+You can install this package globally or use it via your package runner (e.g., `npx`). Alternatively, you can install it as a dev dependency in your project.
+
+```bash
+npx titan help
+```
+
+It parses your application source code, coordinates with `@titanpl/packet` to build the required JS endpoints, and then spins up the pre-compiled native core engine for your OS.
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/cli/index.js

@@ -8,6 +8,7 @@ import { buildCommand } from "./src/commands/build.js";
 import { devCommand } from "./src/commands/dev.js";
 import { startCommand } from "./src/commands/start.js";
 import { migrateCommand } from "./src/commands/migrate.js";
+import { updateCommand } from "./src/commands/update.js";
 import { initCommand } from "./src/commands/init.js";
 
 /* -------------------------------------------------------
@@ -51,9 +52,11 @@ ${bold(cyan("╰─────────────────────
 
   ${bold("Commands:")}
     ${cyan("init")}      ${gray("Scaffold a new Titan project")}
+    ${cyan("create")}    ${gray("Create a new project or extension (e.g. 'titan create ext my-ext')")}
     ${cyan("build")}     ${gray("Compile actions and build production dist")}
     ${cyan("dev")}       ${gray("Start the Gravity Engine in dev/watch mode")}
     ${cyan("start")}     ${gray("Start the production Gravity Engine")}
+    ${cyan("update")}    ${gray("Update an existing project to latest Titan version")}
     ${cyan("migrate")}   ${gray("Migrate a legacy project to the new architecture")}
 
   ${bold("Options:")}
@@ -68,6 +71,7 @@ ${gray("  The Titan Planet Engine runs your JS/TS server natively without Node.j
 /* -------------------------------------------------------
  * CLI Router
  * ----------------------------------------------------- */
+process.title = "TitanPL";
 const cmd = process.argv[2];
 
 (async () => {
@@ -105,6 +109,18 @@ const cmd = process.argv[2];
         break;
       }
 
+      case "create": {
+        const type = process.argv[3];
+        const name = process.argv[4];
+        if (type === "ext" || type === "extension") {
+          await initCommand(name, "extension");
+        } else {
+          // Fallback to init behavior
+          await initCommand(type, null);
+        }
+        break;
+      }
+
       case "build":
         console.log(cyan("→ Building Titan project..."));
         await buildCommand();
@@ -120,6 +136,10 @@ const cmd = process.argv[2];
         startCommand();
         break;
 
+      case "update":
+        await updateCommand();
+        break;
+
       case "migrate":
         await migrateCommand();
         break;

package/packages/cli/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@titanpl/cli",
+  "version": "1.4.0",
+  "description": "The unified CLI for Titan Planet. Use it to create, manage, build, and deploy high-performance backend projects.",
+  "keywords": [
+    "titanpl",
+    "titan",
+    "ezetgalaxy",
+    "cli"
+  ],
+  "license": "ISC",
+  "author": "ezetgalaxy",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "bin": {
+    "titan": "./index.js",
+    "titanpl": "./index.js",
+    "tit": "./index.js"
+  },
+  "optionalDependencies": {
+    "@titanpl/engine-win32-x64": "1.4.0",
+    "@titanpl/engine-linux-x64": "1.4.0",
+    "@titanpl/engine-darwin-arm64": "1.4.0"
+  },
+  "dependencies": {
+    "@titanpl/packet": "1.4.0",
+    "prompts": "^2.4.2",
+    "commander": "^11.0.0",
+    "chalk": "^4.1.2"
+  }
+}

package/packages/cli/src/commands/build.js

@@ -0,0 +1,6 @@
+import { build } from "@titanpl/packet";
+
+export async function buildCommand() {
+  const dist = await build(process.cwd());
+  console.log("✔ Build complete →", dist);
+}

package/packages/cli/src/commands/dev.js

@@ -0,0 +1,5 @@
+import { dev } from "@titanpl/packet";
+
+export async function devCommand() {
+  await dev(process.cwd());
+}

package/packages/cli/src/commands/init.js

@@ -0,0 +1,182 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import prompts from 'prompts';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function copyDir(src, dest, excludes = []) {
+    fs.mkdirSync(dest, { recursive: true });
+
+    for (const file of fs.readdirSync(src)) {
+        if (excludes.includes(file)) continue;
+
+        const srcPath = path.join(src, file);
+        const destPath = path.join(dest, file);
+
+        if (fs.lstatSync(srcPath).isDirectory()) {
+            copyDir(srcPath, destPath, excludes);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+export async function initCommand(projectName, templateName) {
+    let projName = projectName;
+
+    if (!projName) {
+        const res = await prompts({
+            type: 'text',
+            name: 'name',
+            message: 'Project name:',
+            initial: 'my-titan-app'
+        });
+        projName = res.name;
+    }
+
+    if (!projName) {
+        console.log(chalk.red("✖ Initialization cancelled."));
+        process.exit(1);
+    }
+
+    let selectedTemplate = templateName;
+
+    if (!selectedTemplate) {
+        const langRes = await prompts({
+            type: 'select',
+            name: 'value',
+            message: 'Select language:',
+            choices: [
+                { title: 'JavaScript', value: 'js' },
+                { title: 'TypeScript', value: 'ts' },
+            ],
+            initial: 0
+        });
+
+        if (!langRes.value) {
+            console.log(chalk.red("✖ Operation cancelled."));
+            process.exit(1);
+        }
+        const lang = langRes.value;
+
+        const archRes = await prompts({
+            type: 'select',
+            name: 'value',
+            message: 'Select template:',
+            choices: [
+                {
+                    title: `Standard (${lang.toUpperCase()})`,
+                    description: `Standard Titan app with ${lang.toUpperCase()} actions`,
+                    value: 'standard'
+                },
+                {
+                    title: `Rust + ${lang.toUpperCase()} (Hybrid)`,
+                    description: `High-performance Rust actions + ${lang.toUpperCase()} flexibility`,
+                    value: 'hybrid'
+                }
+            ],
+            initial: 0
+        });
+
+        if (!archRes.value) {
+            console.log(chalk.red("✖ Operation cancelled."));
+            process.exit(1);
+        }
+        const arch = archRes.value;
+
+        if (lang === 'js') {
+            selectedTemplate = arch === 'standard' ? 'js' : 'rust-js';
+        } else {
+            selectedTemplate = arch === 'standard' ? 'ts' : 'rust-ts';
+        }
+    }
+
+    const target = path.resolve(process.cwd(), projName);
+    const templateDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', selectedTemplate);
+    const commonDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'common');
+
+    if (!fs.existsSync(templateDir) || !fs.existsSync(commonDir)) {
+        console.log(chalk.red(`✖ Error finding template paths.Are you in a valid Titan monorepo ? `));
+        process.exit(1);
+    }
+
+    if (fs.existsSync(target)) {
+        console.log(chalk.red(`✖ Directory '${projName}' already exists.`));
+        process.exit(1);
+    }
+
+    console.log(chalk.cyan(`\n→ Creating new Titan project in '${projName}'...\n`));
+
+    // 1. Copy common
+    copyDir(commonDir, target);
+
+    // 2. Copy specific template
+    copyDir(templateDir, target);
+
+    // 3. Dotfiles and Template Remapping
+    const remapping = {
+        "_gitignore": ".gitignore",
+        "_dockerignore": ".dockerignore",
+        "_titan.json": "titan.json",
+        ".env": ".env"
+    };
+    for (const [srcName, destName] of Object.entries(remapping)) {
+        const src = path.join(target, srcName);
+        const dest = path.join(target, destName);
+        if (fs.existsSync(src)) {
+            fs.renameSync(src, dest);
+        }
+    }
+
+    // Recursive template substitution
+    const substitute = (dir) => {
+        for (const file of fs.readdirSync(dir)) {
+            const fullPath = path.join(dir, file);
+            if (fs.lstatSync(fullPath).isDirectory()) {
+                if (file !== "node_modules" && file !== ".git" && file !== "target") {
+                    substitute(fullPath);
+                }
+            } else {
+                // Only process text files
+                const ext = path.extname(file).toLowerCase();
+                const textExts = ['.js', '.ts', '.json', '.md', '.txt', '.rs', '.toml', '.html', '.css', '.d.ts'];
+                if (textExts.includes(ext) || file === ".env" || file === "Dockerfile") {
+                    let content = fs.readFileSync(fullPath, 'utf8');
+                    let changed = false;
+                    if (content.includes("{{name}}")) {
+                        content = content.replace(/{{name}}/g, projName);
+                        changed = true;
+                    }
+                    if (content.includes("{{native_name}}")) {
+                        content = content.replace(/{{native_name}}/g, projName.replace(/-/g, '_'));
+                        changed = true;
+                    }
+                    if (changed) {
+                        fs.writeFileSync(fullPath, content);
+                    }
+                }
+            }
+        }
+    };
+    substitute(target);
+
+    console.log(chalk.gray(`  Installing dependencies...`));
+
+    await new Promise((resolve, reject) => {
+        const npm = spawn('npm', ['install'], {
+            cwd: target,
+            stdio: 'inherit',
+            shell: true
+        });
+        npm.on('error', reject);
+        npm.on('close', resolve);
+    });
+
+    console.log(chalk.green(`\n✔ Project '${projName}' created successfully!\n`));
+    console.log(chalk.yellow(`  cd ${projName}`));
+    console.log(chalk.yellow(`  npm run dev\n`));
+}

package/packages/cli/src/commands/migrate.js

@@ -0,0 +1,106 @@
+import fs from 'fs';
+import path from 'path';
+
+export async function migrateCommand() {
+    const root = process.cwd();
+    console.log(`\n🔍 Checking project for legacy Titan architecture...`);
+
+    const serverDir = path.join(root, 'server');
+    const titanDir = path.join(root, 'titan');
+    const pkgPath = path.join(root, 'package.json');
+
+    if (!fs.existsSync(serverDir) && !fs.existsSync(titanDir)) {
+        console.log(`✅ This project is already using the modern Titan runtime architecture.`);
+        return;
+    }
+
+    console.log(`\n⚠️ Legacy server architecture detected. Migrating to runtime-first model...`);
+
+    // 1. Delete server/
+    if (fs.existsSync(serverDir)) {
+        console.log(`   Deleting legacy server/ folder...`);
+        fs.rmSync(serverDir, { recursive: true, force: true });
+    }
+
+    // 2. Delete titan/ folder
+    if (fs.existsSync(titanDir)) {
+        console.log(`   Deleting legacy titan/ runtime folder...`);
+        fs.rmSync(titanDir, { recursive: true, force: true });
+    }
+
+    // 3. Update package.json
+    if (fs.existsSync(pkgPath)) {
+        console.log(`   Updating package.json...`);
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            let modified = false;
+
+            // Update scripts
+            if (pkg.scripts) {
+                if (pkg.scripts.build && pkg.scripts.build.includes('cd server')) {
+                    pkg.scripts.build = "titan build";
+                    modified = true;
+                }
+                if (pkg.scripts.start && pkg.scripts.start.includes('cd server')) {
+                    pkg.scripts.start = "titan start";
+                    modified = true;
+                }
+                if (pkg.scripts.dev && pkg.scripts.dev.includes('titan/dev.js')) {
+                    pkg.scripts.dev = "titan dev";
+                    modified = true;
+                }
+            }
+
+            // Add dependencies
+            pkg.dependencies = pkg.dependencies || {};
+            if (!pkg.dependencies['@titan/native']) {
+                pkg.dependencies['@titan/native'] = "latest";
+                modified = true;
+            }
+            if (!pkg.dependencies['@titan/route']) {
+                pkg.dependencies['@titan/route'] = "latest";
+                modified = true;
+            }
+
+            if (modified) {
+                fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+            }
+        } catch (e) {
+            console.log(`   ⚠️ Failed to update package.json automatically. Please do it manually.`);
+        }
+    }
+
+    // 4. Synchronize Dockerfile and other common files
+    try {
+        const commonDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'common');
+        if (fs.existsSync(commonDir)) {
+            const filesToSync = [
+                ['Dockerfile', 'Dockerfile'],
+                ['_dockerignore', '.dockerignore'],
+                ['_gitignore', '.gitignore'],
+                ['app/t.native.d.ts', 'app/t.native.d.ts'],
+                ['app/t.native.js', 'app/t.native.js']
+            ];
+
+            for (const [srcRel, destRel] of filesToSync) {
+                const src = path.join(commonDir, srcRel);
+                const dest = path.join(root, destRel);
+                if (fs.existsSync(src)) {
+                    // Create parent dir if needed
+                    const parent = path.dirname(dest);
+                    if (!fs.existsSync(parent)) {
+                        fs.mkdirSync(parent, { recursive: true });
+                    }
+                    fs.copyFileSync(src, dest);
+                }
+            }
+            console.log(`   Synchronized Dockerfiles and native definitions.`);
+        }
+    } catch (e) {
+        console.log(`   ⚠️ Failed to synchronize common template files.`);
+    }
+
+    console.log(`\n🎉 Migration complete!`);
+    console.log(`   Please run 'npm install' to fetch the new dependencies.`);
+    console.log(`   Then run 'titan dev' to start your application.\n`);
+}

package/packages/cli/src/commands/start.js

@@ -0,0 +1,5 @@
+import { startEngine } from "../engine.js";
+
+export function startCommand() {
+  startEngine(false);
+}

package/packages/cli/src/commands/update.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function updateCommand() {
+    const root = process.cwd();
+    console.log(chalk.cyan(`\n→ Updating Titan project to latest...`));
+
+    const pkgPath = path.join(root, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        console.log(chalk.red(`✖ No package.json found. Are you in a project root ? `));
+        return;
+    }
+
+    // 1. Update package.json versions
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        let modified = false;
+
+        const titanDeps = [
+            'titanpl',
+            'titanpl-sdk',
+            '@titanpl/cli',
+            '@titanpl/route',
+            '@titanpl/native',
+            '@titanpl/packet',
+            '@titanpl/core',
+            '@titanpl/node'
+        ];
+
+        if (pkg.dependencies) {
+            for (const dep of titanDeps) {
+                if (pkg.dependencies[dep]) {
+                    pkg.dependencies[dep] = "latest";
+                    modified = true;
+                }
+            }
+        }
+
+        if (pkg.devDependencies) {
+            for (const dep of titanDeps) {
+                if (pkg.devDependencies[dep]) {
+                    pkg.devDependencies[dep] = "latest";
+                    modified = true;
+                }
+            }
+        }
+
+        if (modified) {
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+            console.log(chalk.green(`  ✔ Updated Titan dependencies in package.json`));
+        }
+    } catch (e) {
+        console.log(chalk.yellow(`  ⚠️ Failed to update package.json: ${e.message}`));
+    }
+
+    // 2. Refresh Dockerfile and dotfiles from templates
+    const commonDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'common');
+    if (fs.existsSync(commonDir)) {
+        const filesToSync = [
+            ['Dockerfile', 'Dockerfile'],
+            ['_dockerignore', '.dockerignore'],
+            ['_gitignore', '.gitignore'],
+        ];
+
+        for (const [srcName, destName] of filesToSync) {
+            const src = path.join(commonDir, srcName);
+            const dest = path.join(root, destName);
+            if (fs.existsSync(src)) {
+                fs.copyFileSync(src, dest);
+                console.log(chalk.green(`  ✔ Synchronized ${destName}`));
+            }
+        }
+
+        // Also update app/t.native.d.ts if it exists
+        const nativeTypesSrc = path.join(commonDir, 'app', 't.native.d.ts');
+        const nativeTypesDest = path.join(root, 'app', 't.native.d.ts');
+        if (fs.existsSync(nativeTypesSrc) && fs.existsSync(path.join(root, 'app'))) {
+            fs.copyFileSync(nativeTypesSrc, nativeTypesDest);
+            console.log(chalk.green(`  ✔ Updated app/t.native.d.ts`));
+        }
+    }
+
+    console.log(chalk.green(`\n✔ Update complete!\n`));
+    console.log(chalk.yellow(`  Please run 'npm install' to apply changes.\n`));
+}