@titanpl/cli 26.16.5 → 26.16.8

package/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:")}
@@ -105,6 +108,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 +135,10 @@ const cmd = process.argv[2];
         startCommand();
         break;
 
+      case "update":
+        await updateCommand();
+        break;
+
       case "migrate":
         await migrateCommand();
         break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/cli",
-  "version": "26.16.5",
+  "version": "26.16.8",
   "description": "The unified CLI for Titan Planet. Use it to create, manage, build, and deploy high-performance backend projects.",
   "keywords": [
     "titanpl",
@@ -19,12 +19,12 @@
     "titan": "./index.js"
   },
   "optionalDependencies": {
-    "@titanpl/engine-win32-x64": "26.16.5",
-    "@titanpl/engine-linux-x64": "26.16.5",
-    "@titanpl/engine-darwin-arm64": "26.16.5"
+    "@titanpl/engine-win32-x64": "26.16.8",
+    "@titanpl/engine-linux-x64": "26.16.8",
+    "@titanpl/engine-darwin-arm64": "26.16.8"
   },
   "dependencies": {
-    "@titanpl/packet": "26.16.5",
+    "@titanpl/packet": "26.16.8",
     "prompts": "^2.4.2",
     "commander": "^11.0.0",
     "chalk": "^4.1.2"

package/src/commands/init.js

@@ -117,17 +117,31 @@ export async function initCommand(projectName, templateName) {
     // 2. Copy specific template
     copyDir(templateDir, target, ["_gitignore", "_dockerignore"]);
 
-    // 3. Dotfiles
-    const dotfiles = {
+    // 3. Dotfiles and Template Remapping
+    const remapping = {
         "_gitignore": ".gitignore",
         "_dockerignore": ".dockerignore",
+        "_titan.json": "titan.json",
         ".env": ".env"
     };
-    for (const [srcName, destName] of Object.entries(dotfiles)) {
-        const src = path.join(commonDir, srcName);
+    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.copyFileSync(src, dest);
+            fs.renameSync(src, dest);
+        }
+    }
+
+    // Replace {{name}} in package.json and titan.json
+    const filesToSub = ['package.json', 'titan.json', 'README.md', 'index.js', 'app/app.js', 'app/app.ts'];
+    for (const f of filesToSub) {
+        const p = path.join(target, f);
+        if (fs.existsSync(p)) {
+            let content = fs.readFileSync(p, 'utf8');
+            content = content.replace(/{{name}}/g, projName);
+            // Also replace native_name (underscore version)
+            content = content.replace(/{{native_name}}/g, projName.replace(/-/g, '_'));
+            fs.writeFileSync(p, content);
         }
     }
 

package/src/commands/migrate.js

@@ -70,6 +70,36 @@ export async function migrateCommand() {
         }
     }
 
+    // 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/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`));
+}