@expressots/cli 3.0.0 → 4.0.0-preview.2

package/bin/containerize/generators/kubernetes-generator.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateKubernetesConfigs = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const template_loader_1 = require("./template-loader");
+async function generateKubernetesConfigs(options, analysis) {
+    const cwd = process.cwd();
+    const k8sDir = path_1.default.join(cwd, "k8s");
+    if (!fs_1.default.existsSync(k8sDir)) {
+        fs_1.default.mkdirSync(k8sDir, { recursive: true });
+    }
+    console.log(chalk_1.default.yellow(`📝 Generating Kubernetes configurations...`));
+    const vars = {
+        port: analysis?.port || 3000,
+        memory: analysis?.estimatedMemory || "256Mi",
+        cpu: analysis?.estimatedCpu || "250m",
+        replicas: 3,
+        appName: "expressots-app",
+        namespace: "default",
+        healthCheckPath: analysis?.healthCheckPaths?.[0] || "/health",
+    };
+    // Generate deployment
+    const deploymentResult = await (0, template_loader_1.loadKubernetesTemplate)("deployment", vars, () => generateDeployment(options, analysis));
+    (0, template_loader_1.logTemplateSource)("k8s/deployment", deploymentResult.source);
+    fs_1.default.writeFileSync(path_1.default.join(k8sDir, "deployment.yaml"), deploymentResult.content, "utf-8");
+    console.log(chalk_1.default.green(`  ✓ Created k8s/deployment.yaml`));
+    // Generate service
+    const serviceResult = await (0, template_loader_1.loadKubernetesTemplate)("service", vars, () => generateService(options, analysis));
+    (0, template_loader_1.logTemplateSource)("k8s/service", serviceResult.source);
+    fs_1.default.writeFileSync(path_1.default.join(k8sDir, "service.yaml"), serviceResult.content, "utf-8");
+    console.log(chalk_1.default.green(`  ✓ Created k8s/service.yaml`));
+    // Generate config map
+    const configMapResult = await (0, template_loader_1.loadKubernetesTemplate)("configmap", vars, () => generateConfigMap(options, analysis));
+    (0, template_loader_1.logTemplateSource)("k8s/configmap", configMapResult.source);
+    fs_1.default.writeFileSync(path_1.default.join(k8sDir, "configmap.yaml"), configMapResult.content, "utf-8");
+    console.log(chalk_1.default.green(`  ✓ Created k8s/configmap.yaml`));
+}
+exports.generateKubernetesConfigs = generateKubernetesConfigs;
+function generateDeployment(options, analysis) {
+    const port = analysis?.port || 3000;
+    const memory = analysis?.estimatedMemory || "256Mi";
+    const cpu = analysis?.estimatedCpu || "250m";
+    return `# Kubernetes Deployment
+# Generated by ExpressoTS CLI
+
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: expressots-app
+  labels:
+    app: expressots-app
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: expressots-app
+  template:
+    metadata:
+      labels:
+        app: expressots-app
+    spec:
+      containers:
+      - name: app
+        image: your-registry/expressots-app:latest
+        ports:
+        - containerPort: ${port}
+          name: http
+        env:
+        - name: NODE_ENV
+          value: "production"
+        - name: PORT
+          value: "${port}"
+        envFrom:
+        - configMapRef:
+            name: app-config
+        resources:
+          requests:
+            memory: "${memory}"
+            cpu: "${cpu}"
+          limits:
+            memory: "${memory === "256Mi" ? "512Mi" : memory}"
+            cpu: "${cpu === "250m" ? "500m" : cpu}"
+        livenessProbe:
+          httpGet:
+            path: /health
+            port: ${port}
+          initialDelaySeconds: 30
+          periodSeconds: 10
+        readinessProbe:
+          httpGet:
+            path: /health
+            port: ${port}
+          initialDelaySeconds: 5
+          periodSeconds: 5
+`;
+}
+function generateService(options, analysis) {
+    const port = analysis?.port || 3000;
+    return `# Kubernetes Service
+# Generated by ExpressoTS CLI
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: expressots-app
+spec:
+  type: LoadBalancer
+  selector:
+    app: expressots-app
+  ports:
+  - protocol: TCP
+    port: 80
+    targetPort: ${port}
+`;
+}
+function generateConfigMap(options, analysis) {
+    return `# Kubernetes ConfigMap
+# Generated by ExpressoTS CLI
+
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: app-config
+data:
+  NODE_ENV: "production"
+  # Add your configuration here
+`;
+}

package/bin/containerize/generators/template-loader.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Template loader for containerize generators
+ * Handles remote template fetching with fallback to embedded templates
+ */
+import type { ProjectAnalysis } from "../analyzers/project-analyzer";
+export interface DockerTemplateVars {
+    nodeVersion: string;
+    packageManager: string;
+    entryPoint: string;
+    port: number;
+    hasLocalDeps: boolean;
+    healthCheckEndpoint: string;
+    projectName: string;
+    installCommand: string;
+    buildCommand: string;
+}
+export interface TemplateResult {
+    content: string;
+    source: "remote" | "embedded";
+}
+/**
+ * Load Docker template with fallback
+ */
+export declare function loadDockerTemplate(templateType: string, variables: DockerTemplateVars, embeddedGenerator: () => string): Promise<TemplateResult>;
+/**
+ * Load Kubernetes template with fallback
+ */
+export declare function loadKubernetesTemplate(templateType: string, variables: Record<string, unknown>, embeddedGenerator: () => string): Promise<TemplateResult>;
+/**
+ * Build Docker template variables from analysis
+ */
+export declare function buildDockerVars(analysis: ProjectAnalysis | undefined, entryPoint: string, packageManager?: string): DockerTemplateVars;
+/**
+ * Log template source for debugging
+ */
+export declare function logTemplateSource(templateName: string, source: "remote" | "embedded"): void;

package/bin/containerize/generators/template-loader.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * Template loader for containerize generators
+ * Handles remote template fetching with fallback to embedded templates
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logTemplateSource = exports.buildDockerVars = exports.loadKubernetesTemplate = exports.loadDockerTemplate = void 0;
+const templates_1 = require("../../templates");
+/**
+ * Load Docker template with fallback
+ */
+async function loadDockerTemplate(templateType, variables, embeddedGenerator) {
+    const manager = (0, templates_1.getTemplateManager)();
+    try {
+        // Try to fetch from remote template repository
+        const result = await manager.fetchDockerTemplate(templateType);
+        if (result.data) {
+            // Template found, render with variables
+            const renderOptions = {
+                variables: {
+                    ...variables,
+                },
+                conditionals: {
+                    hasLocalDeps: variables.hasLocalDeps,
+                    useNpmCi: !variables.hasLocalDeps,
+                },
+            };
+            const rendered = manager.render(result.data, renderOptions);
+            return { content: rendered, source: "remote" };
+        }
+    }
+    catch {
+        // Remote fetch failed, fall back to embedded
+    }
+    // Fall back to embedded template generator
+    return {
+        content: embeddedGenerator(),
+        source: "embedded",
+    };
+}
+exports.loadDockerTemplate = loadDockerTemplate;
+/**
+ * Load Kubernetes template with fallback
+ */
+async function loadKubernetesTemplate(templateType, variables, embeddedGenerator) {
+    const manager = (0, templates_1.getTemplateManager)();
+    try {
+        // Try to fetch from remote template repository
+        const result = await manager.fetchKubernetesTemplate(templateType);
+        if (result.data) {
+            // Template found, render with variables
+            const renderOptions = {
+                variables: variables,
+            };
+            const rendered = manager.render(result.data, renderOptions);
+            return { content: rendered, source: "remote" };
+        }
+    }
+    catch {
+        // Remote fetch failed, fall back to embedded
+    }
+    // Fall back to embedded template generator
+    return {
+        content: embeddedGenerator(),
+        source: "embedded",
+    };
+}
+exports.loadKubernetesTemplate = loadKubernetesTemplate;
+/**
+ * Build Docker template variables from analysis
+ */
+function buildDockerVars(analysis, entryPoint, packageManager = "npm") {
+    return {
+        nodeVersion: analysis?.nodeVersion || "20",
+        packageManager,
+        entryPoint,
+        port: analysis?.port || 3000,
+        hasLocalDeps: analysis?.hasLocalDependencies || false,
+        healthCheckEndpoint: analysis?.healthCheckPaths?.[0] || "/health",
+        projectName: "expressots-app",
+        installCommand: getInstallCommand(packageManager, analysis?.hasLocalDependencies),
+        buildCommand: getBuildCommand(packageManager),
+    };
+}
+exports.buildDockerVars = buildDockerVars;
+/**
+ * Get install command for package manager
+ */
+function getInstallCommand(packageManager, hasLocalDeps) {
+    if (hasLocalDeps) {
+        // Use npm install when local deps exist (npm ci doesn't work well with local deps)
+        return packageManager === "pnpm"
+            ? "pnpm install"
+            : packageManager === "yarn"
+                ? "yarn install"
+                : "npm install";
+    }
+    switch (packageManager) {
+        case "pnpm":
+            return "pnpm install --frozen-lockfile";
+        case "yarn":
+            return "yarn install --frozen-lockfile";
+        default:
+            return "npm ci";
+    }
+}
+/**
+ * Get build command for package manager
+ */
+function getBuildCommand(packageManager) {
+    switch (packageManager) {
+        case "pnpm":
+            return "pnpm build";
+        case "yarn":
+            return "yarn build";
+        default:
+            return "npm run build";
+    }
+}
+/**
+ * Log template source for debugging
+ */
+function logTemplateSource(templateName, source) {
+    if (process.env.EXPRESSOTS_DEBUG) {
+        const sourceLabel = source === "remote" ? "remote template" : "embedded template";
+        console.log(`  [DEBUG] ${templateName}: Using ${sourceLabel}`);
+    }
+}
+exports.logTemplateSource = logTemplateSource;

package/bin/containerize/index.d.ts

@@ -0,0 +1,4 @@
+export { containerize } from "./cli";
+export { containerizeProject } from "./form";
+export { analyzeBootstrapConfig, shouldCopyEnvFiles, getEnvFileForEnvironment, type BootstrapConfig, type EnvFileMapping, } from "./analyzers/bootstrap-analyzer";
+export { analyzeProject, type ProjectAnalysis, } from "./analyzers/project-analyzer";

package/bin/containerize/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeProject = exports.getEnvFileForEnvironment = exports.shouldCopyEnvFiles = exports.analyzeBootstrapConfig = exports.containerizeProject = exports.containerize = void 0;
+var cli_1 = require("./cli");
+Object.defineProperty(exports, "containerize", { enumerable: true, get: function () { return cli_1.containerize; } });
+var form_1 = require("./form");
+Object.defineProperty(exports, "containerizeProject", { enumerable: true, get: function () { return form_1.containerizeProject; } });
+var bootstrap_analyzer_1 = require("./analyzers/bootstrap-analyzer");
+Object.defineProperty(exports, "analyzeBootstrapConfig", { enumerable: true, get: function () { return bootstrap_analyzer_1.analyzeBootstrapConfig; } });
+Object.defineProperty(exports, "shouldCopyEnvFiles", { enumerable: true, get: function () { return bootstrap_analyzer_1.shouldCopyEnvFiles; } });
+Object.defineProperty(exports, "getEnvFileForEnvironment", { enumerable: true, get: function () { return bootstrap_analyzer_1.getEnvFileForEnvironment; } });
+var project_analyzer_1 = require("./analyzers/project-analyzer");
+Object.defineProperty(exports, "analyzeProject", { enumerable: true, get: function () { return project_analyzer_1.analyzeProject; } });

package/bin/containerize/presets/preset-registry.d.ts

@@ -0,0 +1,20 @@
+export interface PresetConfig {
+    name: string;
+    description: string;
+    baseImage?: string;
+    multiStage?: boolean;
+    security?: {
+        enabled: boolean;
+        nonRootUser?: boolean;
+    };
+    healthCheck?: {
+        enabled: boolean;
+        interval?: string;
+    };
+    optimization?: {
+        layerCaching?: boolean;
+        minimalDependencies?: boolean;
+    };
+}
+export declare function getPresetConfig(presetName: string): PresetConfig;
+export declare function listPresets(): PresetConfig[];

package/bin/containerize/presets/preset-registry.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listPresets = exports.getPresetConfig = void 0;
+const presets = {
+    standard: {
+        name: "Standard",
+        description: "Balanced configuration for most applications",
+        multiStage: true,
+        security: {
+            enabled: false,
+        },
+        healthCheck: {
+            enabled: false,
+        },
+    },
+    minimal: {
+        name: "Minimal",
+        description: "Smallest possible image size (<100MB)",
+        baseImage: "node:22-alpine",
+        multiStage: true,
+        security: {
+            enabled: false,
+        },
+        healthCheck: {
+            enabled: false,
+        },
+        optimization: {
+            layerCaching: true,
+            minimalDependencies: true,
+        },
+    },
+    secure: {
+        name: "Secure",
+        description: "Security-hardened configuration",
+        baseImage: "node:22-alpine",
+        multiStage: true,
+        security: {
+            enabled: true,
+            nonRootUser: true,
+        },
+        healthCheck: {
+            enabled: true,
+            interval: "30s",
+        },
+        optimization: {
+            layerCaching: true,
+        },
+    },
+    "fast-startup": {
+        name: "Fast Startup",
+        description: "Optimized for quick cold starts",
+        baseImage: "node:22-alpine",
+        multiStage: true,
+        security: {
+            enabled: false,
+        },
+        healthCheck: {
+            enabled: true,
+        },
+        optimization: {
+            layerCaching: true,
+            minimalDependencies: true,
+        },
+    },
+    dev: {
+        name: "Development",
+        description: "Development environment with hot reload",
+        baseImage: "node:22",
+        multiStage: false,
+        security: {
+            enabled: false,
+        },
+        healthCheck: {
+            enabled: false,
+        },
+    },
+    "multi-arch": {
+        name: "Multi-Architecture",
+        description: "Supports both ARM64 and x86_64",
+        baseImage: "node:22-alpine",
+        multiStage: true,
+        security: {
+            enabled: true,
+        },
+        healthCheck: {
+            enabled: true,
+        },
+    },
+};
+function getPresetConfig(presetName) {
+    const preset = presets[presetName];
+    if (!preset) {
+        console.warn(`Warning: Preset "${presetName}" not found. Using "standard" preset.`);
+        return presets.standard;
+    }
+    return preset;
+}
+exports.getPresetConfig = getPresetConfig;
+function listPresets() {
+    return Object.values(presets);
+}
+exports.listPresets = listPresets;

package/bin/costs/cli.d.ts

@@ -0,0 +1,5 @@
+import { CommandModule } from "yargs";
+type CommandModuleArgs = {};
+export type CloudProvider = "aws" | "gcp" | "azure" | "railway" | "render" | "fly" | "digitalocean" | "heroku";
+declare const costsCommand: () => CommandModule<CommandModuleArgs, any>;
+export { costsCommand };

package/bin/costs/cli.js

@@ -0,0 +1,183 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.costsCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const form_1 = require("./form");
+const pricing_manager_1 = require("./pricing-manager");
+const costsCommand = () => {
+    return {
+        command: "costs <action>",
+        describe: "Estimate and compare cloud deployment costs.",
+        aliases: ["cost", "pricing"],
+        builder: (yargs) => {
+            yargs.positional("action", {
+                choices: [
+                    "estimate",
+                    "compare",
+                    "optimize",
+                    "pricing",
+                    "update",
+                    "info",
+                ],
+                describe: "Action to perform",
+                type: "string",
+                demandOption: true,
+            });
+            yargs.option("provider", {
+                choices: [
+                    "aws",
+                    "gcp",
+                    "azure",
+                    "railway",
+                    "render",
+                    "fly",
+                    "digitalocean",
+                    "heroku",
+                ],
+                describe: "Cloud provider",
+                type: "string",
+                alias: "p",
+            });
+            yargs.option("service", {
+                choices: [
+                    "ecs",
+                    "eks",
+                    "lambda",
+                    "cloudrun",
+                    "gke",
+                    "aci",
+                    "aks",
+                    "web-service",
+                ],
+                describe: "Specific service type",
+                type: "string",
+                alias: "s",
+            });
+            yargs.option("instances", {
+                describe: "Number of instances/replicas",
+                type: "number",
+                alias: "i",
+                default: 1,
+            });
+            yargs.option("cpu", {
+                describe: "CPU cores/vCPUs per instance",
+                type: "number",
+                alias: "c",
+                default: 1,
+            });
+            yargs.option("memory", {
+                describe: "Memory in GB per instance",
+                type: "number",
+                alias: "m",
+                default: 1,
+            });
+            yargs.option("storage", {
+                describe: "Storage in GB",
+                type: "number",
+                default: 10,
+            });
+            yargs.option("bandwidth", {
+                describe: "Expected bandwidth in GB/month",
+                type: "number",
+                default: 100,
+            });
+            yargs.option("region", {
+                describe: "Cloud region",
+                type: "string",
+                alias: "r",
+                default: "us-east-1",
+            });
+            yargs.option("hours", {
+                describe: "Expected running hours per month",
+                type: "number",
+                default: 720, // 24 * 30
+            });
+            yargs.option("format", {
+                choices: ["text", "json", "markdown"],
+                describe: "Output format",
+                type: "string",
+                default: "text",
+            });
+            yargs.option("output", {
+                describe: "Output file",
+                type: "string",
+                alias: "o",
+            });
+            return yargs;
+        },
+        handler: async (argv) => {
+            const { action, provider, service, instances, cpu, memory, storage, bandwidth, region, hours, format, output, } = argv;
+            const options = {
+                provider: provider,
+                service,
+                instances,
+                cpu,
+                memory,
+                storage,
+                bandwidth,
+                region,
+                hours,
+                format: format,
+                output,
+            };
+            switch (action) {
+                case "estimate":
+                    await (0, form_1.estimateCosts)(options);
+                    break;
+                case "compare":
+                    await (0, form_1.compareCosts)(options);
+                    break;
+                case "optimize":
+                    await (0, form_1.optimizeCosts)(options);
+                    break;
+                case "pricing":
+                    await (0, form_1.showPricing)(options);
+                    break;
+                case "update":
+                    await updatePricingData();
+                    break;
+                case "info":
+                    await showPricingInfo();
+                    break;
+                default:
+                    console.log(`Unknown action: ${action}`);
+            }
+        },
+    };
+};
+exports.costsCommand = costsCommand;
+/**
+ * Update pricing data from remote sources
+ */
+async function updatePricingData() {
+    console.log(chalk_1.default.cyan("\n🔄 Updating Pricing Data...\n"));
+    const manager = (0, pricing_manager_1.getPricingManager)();
+    manager.clearCache();
+    const success = await manager.updateCache();
+    if (success) {
+        const source = manager.getLastSource();
+        console.log(chalk_1.default.green(`✓ Pricing data updated`));
+        console.log(chalk_1.default.gray(`  Source: ${source}`));
+    }
+    else {
+        console.log(chalk_1.default.red("✗ Failed to update pricing data"));
+        console.log(chalk_1.default.gray("  Check your network connection and try again."));
+    }
+    console.log();
+}
+/**
+ * Show pricing system info
+ */
+async function showPricingInfo() {
+    const manager = (0, pricing_manager_1.getPricingManager)();
+    await manager.printStatus();
+    const providers = await manager.getAvailableProviders();
+    if (providers.length > 0) {
+        console.log(chalk_1.default.bold("\nAvailable Providers:"));
+        console.log(`  ${providers.join(", ")}`);
+    }
+    console.log();
+}

package/bin/costs/form.d.ts

@@ -0,0 +1,44 @@
+import type { CloudProvider } from "./cli";
+export interface CostOptions {
+    provider?: CloudProvider;
+    service?: string;
+    instances: number;
+    cpu: number;
+    memory: number;
+    storage: number;
+    bandwidth: number;
+    region: string;
+    hours: number;
+    format: "text" | "json" | "markdown";
+    output?: string;
+}
+export interface CostEstimate {
+    provider: string;
+    service: string;
+    monthlyCost: number;
+    breakdown: CostBreakdown;
+    currency: string;
+}
+export interface CostBreakdown {
+    compute: number;
+    memory?: number;
+    storage: number;
+    bandwidth: number;
+    other: number;
+}
+/**
+ * Estimate costs for a specific provider
+ */
+export declare function estimateCosts(options: CostOptions): Promise<void>;
+/**
+ * Compare costs across all providers
+ */
+export declare function compareCosts(options: CostOptions): Promise<void>;
+/**
+ * Suggest cost optimizations
+ */
+export declare function optimizeCosts(options: CostOptions): Promise<void>;
+/**
+ * Show pricing information for a provider
+ */
+export declare function showPricing(options: CostOptions): Promise<void>;