@expressots/cli 3.0.0 → 4.0.0-preview.3

package/bin/help/main-help.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printMainHelp = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const process_1 = require("process");
+const render_1 = require("./render");
+const COMMAND_GROUPS = [
+    {
+        title: "Project",
+        entries: [
+            { name: "new", desc: "Create a new application or micro project" },
+            { name: "dev", desc: "Start the development server" },
+            { name: "build", desc: "Build the project for production" },
+            { name: "prod", desc: "Run in production mode" },
+            { name: "info", alias: "i", desc: "Display project information" },
+            { name: "scripts", desc: "Run one or more package scripts" },
+        ],
+    },
+    {
+        title: "Generate",
+        entries: [
+            {
+                name: "generate",
+                alias: "g",
+                desc: "Scaffold a resource (controller, usecase, dto, ...)",
+            },
+        ],
+    },
+    {
+        title: "Providers",
+        entries: [
+            { name: "create", desc: "Create an external provider" },
+            { name: "add", desc: "Add a provider to the project" },
+            { name: "remove", desc: "Remove a provider from the project" },
+        ],
+    },
+    {
+        title: "DevOps",
+        entries: [
+            {
+                name: "containerize",
+                alias: "ctr",
+                desc: "Generate Docker / Kubernetes / Compose configs",
+            },
+            {
+                name: "cicd",
+                alias: "ci",
+                desc: "Generate and manage CI/CD pipelines",
+            },
+            {
+                name: "migrate",
+                alias: "mig",
+                desc: "Generate migration scripts between platforms",
+            },
+            {
+                name: "profile",
+                alias: "prof",
+                desc: "Analyze and optimize container configs",
+            },
+            {
+                name: "container-dev",
+                alias: "cdev",
+                desc: "Develop inside Docker with hot reload",
+            },
+            {
+                name: "costs",
+                alias: "cost",
+                desc: "Estimate and compare cloud deployment costs",
+            },
+            {
+                name: "templates",
+                alias: "tpl",
+                desc: "Manage CI/CD, Docker, and Kubernetes templates",
+            },
+        ],
+    },
+    {
+        title: "Studio & Help",
+        entries: [
+            { name: "studio", desc: "Launch ExpressoTS Studio" },
+            {
+                name: "resources",
+                alias: "r",
+                desc: "Show full command & schematics reference",
+            },
+            { name: "completion", desc: "Generate a shell completion script" },
+        ],
+    },
+    {
+        title: "Options",
+        entries: [
+            { name: "-h, --help", desc: "Show help" },
+            { name: "-V, --version", desc: "Show version" },
+        ],
+    },
+];
+/**
+ * Print a refined, grouped, column-aligned top-level help screen.
+ *
+ * Unlike the default yargs help, this drops the repeated `expressots`
+ * prefix on every line and renders aliases inline, keeping the whole
+ * reference compact while still listing every command.
+ */
+function printMainHelp(version) {
+    const title = version
+        ? `🐎 ExpressoTS CLI v${version}`
+        : "🐎 ExpressoTS CLI";
+    const lines = [
+        "",
+        chalk_1.default.bold.green(title),
+        "",
+        `${chalk_1.default.bold("Usage:")} expressots <command> [options]`,
+        ...(0, render_1.renderHelpGroups)(COMMAND_GROUPS),
+        "",
+        chalk_1.default.dim("Run 'expressots <command> --help' for details on a command."),
+        "",
+        `🌐  ${chalk_1.default.green("https://expresso-ts.com")}     ` +
+            `💖  ${chalk_1.default.green("https://github.com/sponsors/expressots")}`,
+        "",
+    ];
+    process_1.stdout.write(`${lines.join("\n")}\n`);
+}
+exports.printMainHelp = printMainHelp;

package/bin/help/render.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A single command/option row in a help surface.
+ */
+export interface HelpEntry {
+    name: string;
+    alias?: string;
+    desc: string;
+}
+/**
+ * A titled group of entries (e.g. "Project", "DevOps").
+ */
+export interface HelpGroup {
+    title: string;
+    entries: HelpEntry[];
+}
+/**
+ * Format an alias as `(g)`, or an empty string when there is none.
+ */
+export declare function formatAlias(alias?: string): string;
+/**
+ * Render one aligned row: `  name   alias   description`.
+ */
+export declare function renderRow(entry: HelpEntry, nameWidth: number, aliasWidth: number): string;
+/**
+ * Render grouped, column-aligned rows. A single name/alias width is
+ * computed across *all* groups so every column lines up, giving every
+ * help surface (top-level help, resources reference) one cohesive look.
+ *
+ * Returns the lines (no trailing newline). Each group is preceded by a
+ * blank line and a bold cyan title.
+ */
+export declare function renderHelpGroups(groups: HelpGroup[]): string[];

package/bin/help/render.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHelpGroups = exports.renderRow = exports.formatAlias = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Format an alias as `(g)`, or an empty string when there is none.
+ */
+function formatAlias(alias) {
+    return alias ? `(${alias})` : "";
+}
+exports.formatAlias = formatAlias;
+/**
+ * Render one aligned row: `  name   alias   description`.
+ */
+function renderRow(entry, nameWidth, aliasWidth) {
+    const name = chalk_1.default.green(entry.name.padEnd(nameWidth));
+    const alias = chalk_1.default.dim(formatAlias(entry.alias).padEnd(aliasWidth));
+    return `  ${name}  ${alias}  ${entry.desc}`;
+}
+exports.renderRow = renderRow;
+/**
+ * Render grouped, column-aligned rows. A single name/alias width is
+ * computed across *all* groups so every column lines up, giving every
+ * help surface (top-level help, resources reference) one cohesive look.
+ *
+ * Returns the lines (no trailing newline). Each group is preceded by a
+ * blank line and a bold cyan title.
+ */
+function renderHelpGroups(groups) {
+    const all = groups.flatMap((g) => g.entries);
+    const nameWidth = Math.max(...all.map((e) => e.name.length));
+    const aliasWidth = Math.max(...all.map((e) => formatAlias(e.alias).length));
+    const lines = [];
+    for (const group of groups) {
+        lines.push("");
+        lines.push(chalk_1.default.bold.cyan(group.title));
+        for (const entry of group.entries) {
+            lines.push(renderRow(entry, nameWidth, aliasWidth));
+        }
+    }
+    return lines;
+}
+exports.renderHelpGroups = renderHelpGroups;

package/bin/info/cli.d.ts

@@ -1,4 +1,4 @@
 import { CommandModule } from "yargs";
-type CommandModuleArgs = {};
+type CommandModuleArgs = object;
 declare const infoProject: () => CommandModule<CommandModuleArgs, any>;
 export { infoProject };

package/bin/info/form.d.ts

@@ -1 +1 @@
-export declare const infoForm: () => void;
+export declare const infoForm: () => Promise<void>;

package/bin/info/form.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.infoForm = void 0;
-const chalk_1 = __importDefault(require("chalk"));
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
@@ -18,21 +17,22 @@ function getInfosFromPackage() {
         const packageJsonPath = path_1.default.join(absDirPath, "package.json");
         const fileContents = fs_1.default.readFileSync(packageJsonPath, "utf-8");
         const packageJson = JSON.parse(fileContents);
-        console.log(chalk_1.default.green("ExpressoTS Project:"));
-        console.log(chalk_1.default.white(`\tName: ${packageJson.name}`));
-        console.log(chalk_1.default.white(`\tDescription: ${packageJson.description}`));
-        console.log(chalk_1.default.white(`\tVersion: ${packageJson.version}`));
-        console.log(chalk_1.default.white(`\tAuthor: ${packageJson.author}`));
+        (0, cli_ui_1.printSection)("📦 Project");
+        (0, cli_ui_1.printKeyValue)("Name", `${packageJson.name}`);
+        (0, cli_ui_1.printKeyValue)("Description", `${packageJson.description}`);
+        (0, cli_ui_1.printKeyValue)("Version", `${packageJson.version}`);
+        (0, cli_ui_1.printKeyValue)("Author", `${packageJson.author}`);
     }
     catch (error) {
         (0, cli_ui_1.printError)("No project information available.", "package.json not found!");
     }
 }
-const infoForm = () => {
+const infoForm = async () => {
     getInfosFromPackage();
-    console.log(chalk_1.default.green("System information:"));
-    console.log(chalk_1.default.white(`\tOS Version: ${os_1.default.version()}`));
-    console.log(chalk_1.default.white(`\tNodeJS version: ${process.version}`));
-    (0, cli_ui_1.printSuccess)("CLI version:", cli_1.BUNDLE_VERSION);
+    (0, cli_ui_1.printSection)("💻 System");
+    (0, cli_ui_1.printKeyValue)("OS", `${os_1.default.type()} ${os_1.default.release()} (${os_1.default.arch()})`);
+    (0, cli_ui_1.printKeyValue)("Node.js", process.version);
+    (0, cli_ui_1.printKeyValue)("CLI", cli_1.BUNDLE_VERSION);
+    console.log("");
 };
 exports.infoForm = infoForm;

package/bin/migrate/analyzers/platform-detector.d.ts

@@ -0,0 +1,14 @@
+import type { MigrationSource } from "../cli";
+/**
+ * Detect the current deployment platform based on configuration files
+ */
+export declare function detectCurrentPlatform(): Promise<MigrationSource | null>;
+/**
+ * Analyze the current platform configuration
+ */
+export declare function analyzePlatformConfig(): Promise<{
+    platform: MigrationSource | null;
+    envVars: string[];
+    services: string[];
+    databases: string[];
+}>;

package/bin/migrate/analyzers/platform-detector.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePlatformConfig = exports.detectCurrentPlatform = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Detect the current deployment platform based on configuration files
+ */
+async function detectCurrentPlatform() {
+    const cwd = process.cwd();
+    // Check for platform-specific files
+    const checks = [
+        { platform: "heroku", files: ["Procfile", "app.json"] },
+        { platform: "vercel", files: ["vercel.json", ".vercel"] },
+        {
+            platform: "docker-compose",
+            files: ["docker-compose.yml", "docker-compose.yaml"],
+        },
+        {
+            platform: "aws-ecs",
+            files: ["ecs-task-definition.json", ".aws/ecs"],
+        },
+        {
+            platform: "gcp-cloudrun",
+            files: ["cloudbuild.yaml", ".gcp/cloudrun.yaml"],
+        },
+        { platform: "azure-container", files: ["azure-pipelines.yml"] },
+    ];
+    for (const check of checks) {
+        for (const file of check.files) {
+            if (fs_1.default.existsSync(path_1.default.join(cwd, file))) {
+                return check.platform;
+            }
+        }
+    }
+    // Check for platform indicators in package.json scripts
+    const packageJsonPath = path_1.default.join(cwd, "package.json");
+    if (fs_1.default.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf-8"));
+            const scripts = JSON.stringify(pkg.scripts || {});
+            if (scripts.includes("heroku"))
+                return "heroku";
+            if (scripts.includes("vercel"))
+                return "vercel";
+            if (scripts.includes("railway"))
+                return "docker-compose"; // likely uses Docker
+            if (scripts.includes("docker-compose"))
+                return "docker-compose";
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // If Dockerfile exists, assume docker-compose
+    if (fs_1.default.existsSync(path_1.default.join(cwd, "Dockerfile"))) {
+        return "docker-compose";
+    }
+    return null;
+}
+exports.detectCurrentPlatform = detectCurrentPlatform;
+/**
+ * Analyze the current platform configuration
+ */
+async function analyzePlatformConfig() {
+    const cwd = process.cwd();
+    const platform = await detectCurrentPlatform();
+    const envVars = [];
+    const services = [];
+    const databases = [];
+    // Parse .env.example for environment variables
+    const envExamplePath = path_1.default.join(cwd, ".env.example");
+    if (fs_1.default.existsSync(envExamplePath)) {
+        const content = fs_1.default.readFileSync(envExamplePath, "utf-8");
+        const lines = content.split("\n");
+        for (const line of lines) {
+            const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+            if (match) {
+                envVars.push(match[1]);
+            }
+        }
+    }
+    // Parse docker-compose for services
+    const composePath = path_1.default.join(cwd, "docker-compose.yml");
+    if (fs_1.default.existsSync(composePath)) {
+        const content = fs_1.default.readFileSync(composePath, "utf-8");
+        const serviceMatch = content.match(/services:\n([\s\S]*?)(?=\n\w|$)/);
+        if (serviceMatch) {
+            const serviceLines = serviceMatch[1].match(/^\s{2}(\w+):/gm);
+            if (serviceLines) {
+                for (const line of serviceLines) {
+                    const name = line.trim().replace(":", "");
+                    services.push(name);
+                    // Check if it's a database
+                    if (name.includes("postgres") || name.includes("pg")) {
+                        databases.push("postgresql");
+                    }
+                    else if (name.includes("mysql")) {
+                        databases.push("mysql");
+                    }
+                    else if (name.includes("mongo")) {
+                        databases.push("mongodb");
+                    }
+                    else if (name.includes("redis")) {
+                        databases.push("redis");
+                    }
+                }
+            }
+        }
+    }
+    return { platform, envVars, services, databases };
+}
+exports.analyzePlatformConfig = analyzePlatformConfig;

package/bin/migrate/cli.d.ts

@@ -0,0 +1,6 @@
+import { CommandModule } from "yargs";
+type CommandModuleArgs = Record<string, never>;
+export type MigrationSource = "heroku" | "docker-compose" | "vercel" | "aws-ecs" | "gcp-cloudrun" | "azure-container";
+export type MigrationTarget = "railway" | "render" | "fly" | "kubernetes" | "aws-ecs" | "gcp-cloudrun" | "azure-container";
+declare const migrateCommand: () => CommandModule<CommandModuleArgs, any>;
+export { migrateCommand };

package/bin/migrate/cli.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateCommand = void 0;
+const form_1 = require("./form");
+const cli_ui_1 = require("../utils/cli-ui");
+const migrateCommand = () => {
+    return {
+        command: "migrate <action> [options]",
+        describe: "Generate migration scripts between cloud platforms.",
+        aliases: ["migration", "mig"],
+        builder: (yargs) => {
+            yargs.positional("action", {
+                choices: ["init", "generate", "list", "analyze"],
+                describe: "Action to perform",
+                type: "string",
+                demandOption: true,
+            });
+            yargs.option("from", {
+                choices: [
+                    "heroku",
+                    "docker-compose",
+                    "vercel",
+                    "aws-ecs",
+                    "gcp-cloudrun",
+                    "azure-container",
+                ],
+                describe: "Source platform to migrate from",
+                type: "string",
+                alias: "f",
+            });
+            yargs.option("to", {
+                choices: [
+                    "railway",
+                    "render",
+                    "fly",
+                    "kubernetes",
+                    "aws-ecs",
+                    "gcp-cloudrun",
+                    "azure-container",
+                ],
+                describe: "Target platform to migrate to",
+                type: "string",
+                alias: "t",
+            });
+            yargs.option("include-data", {
+                describe: "Include data migration scripts",
+                type: "boolean",
+                default: false,
+            });
+            yargs.option("include-secrets", {
+                describe: "Include secrets/environment variable migration",
+                type: "boolean",
+                default: true,
+            });
+            yargs.option("dry-run", {
+                describe: "Show migration steps without generating files",
+                type: "boolean",
+                default: false,
+            });
+            yargs.option("output-dir", {
+                describe: "Output directory for migration files",
+                type: "string",
+                alias: "o",
+                default: "./migration",
+            });
+            return yargs;
+        },
+        handler: async (argv) => {
+            const { action, from, to, includeData, includeSecrets, dryRun, outputDir, } = argv;
+            const options = {
+                from: from,
+                to: to,
+                includeData,
+                includeSecrets,
+                dryRun,
+                outputDir,
+            };
+            switch (action) {
+                case "init":
+                    await (0, form_1.initMigration)(options);
+                    break;
+                case "generate":
+                    await (0, form_1.generateMigration)(options);
+                    break;
+                case "list":
+                    await (0, form_1.listMigrations)();
+                    break;
+                case "analyze":
+                    await (0, form_1.analyzeMigration)(options);
+                    break;
+                default:
+                    (0, cli_ui_1.printError)(`Unknown action: ${action}`, "migrate");
+                    process.exit(1);
+            }
+        },
+    };
+};
+exports.migrateCommand = migrateCommand;

package/bin/migrate/form.d.ts

@@ -0,0 +1,25 @@
+import type { MigrationSource, MigrationTarget } from "./cli";
+export interface MigrationOptions {
+    from?: MigrationSource;
+    to?: MigrationTarget;
+    includeData: boolean;
+    includeSecrets: boolean;
+    dryRun: boolean;
+    outputDir: string;
+}
+/**
+ * Interactive migration setup wizard
+ */
+export declare function initMigration(options: MigrationOptions): Promise<void>;
+/**
+ * Generate migration scripts
+ */
+export declare function generateMigration(options: MigrationOptions): Promise<void>;
+/**
+ * List available migrations
+ */
+export declare function listMigrations(): Promise<void>;
+/**
+ * Analyze migration complexity
+ */
+export declare function analyzeMigration(options: MigrationOptions): Promise<void>;