@expressots/cli 3.0.0 → 4.0.0-preview.3

package/bin/templates/cli.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * Templates CLI command
+ * Manage template sources, cache, and configuration
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templatesCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const manager_1 = require("./manager");
+const config_1 = require("../config");
+const cli_ui_1 = require("../utils/cli-ui");
+const templatesCommand = () => {
+    return {
+        command: "templates <action> [args...]",
+        describe: "Manage CLI templates for CI/CD, Docker, and Kubernetes.",
+        aliases: ["tpl"],
+        builder: (yargs) => {
+            yargs.positional("action", {
+                choices: [
+                    "list",
+                    "update",
+                    "clear",
+                    "info",
+                    "repo",
+                    "status",
+                ],
+                describe: "Action to perform",
+                type: "string",
+                demandOption: true,
+            });
+            yargs.positional("args", {
+                describe: "Additional arguments for the action",
+                type: "string",
+                array: true,
+            });
+            yargs.option("category", {
+                alias: "c",
+                type: "string",
+                describe: "Filter by category (cicd, docker, kubernetes, migrations)",
+            });
+            yargs.option("platform", {
+                alias: "p",
+                type: "string",
+                describe: "Filter by platform (github, gitlab, etc.)",
+            });
+            yargs.example("$0 templates list", "List all available templates");
+            yargs.example("$0 templates update", "Update template cache from remote");
+            yargs.example("$0 templates clear", "Clear local template cache");
+            yargs.example("$0 templates info cicd github", "Show template info");
+            yargs.example("$0 templates repo set https://github.com/myorg/templates", "Set custom repository");
+            yargs.example("$0 templates repo reset", "Reset to default repository");
+            yargs.example("$0 templates status", "Show template system status");
+            return yargs;
+        },
+        handler: async (argv) => {
+            const action = argv.action;
+            const args = argv.args || [];
+            switch (action) {
+                case "list":
+                    await listTemplates(argv.category, argv.platform);
+                    break;
+                case "update":
+                    await updateTemplates();
+                    break;
+                case "clear":
+                    await clearCache();
+                    break;
+                case "info":
+                    await showTemplateInfo(args[0], args[1]);
+                    break;
+                case "repo":
+                    await manageRepository(args);
+                    break;
+                case "status":
+                    await showStatus();
+                    break;
+                default:
+                    (0, cli_ui_1.printError)(`Unknown action: ${action}`, "templates");
+                    console.log(chalk_1.default.gray("Run 'expressots templates --help' for usage."));
+                    process.exit(1);
+            }
+        },
+    };
+};
+exports.templatesCommand = templatesCommand;
+/**
+ * List available templates
+ */
+async function listTemplates(category, platform) {
+    (0, cli_ui_1.printSection)("📋 Available Templates");
+    const manager = (0, manager_1.getTemplateManager)();
+    const templates = await manager.listTemplates();
+    // Show template source
+    const sourceLabel = templates.source === "remote"
+        ? chalk_1.default.green("(from remote repository)")
+        : chalk_1.default.yellow("(embedded fallback)");
+    console.log(chalk_1.default.gray(`  Source: ${sourceLabel}\n`));
+    if (Object.keys(templates.cicd).length === 0 &&
+        templates.docker.length === 0 &&
+        templates.kubernetes.length === 0) {
+        console.log(chalk_1.default.yellow("No templates available. Run 'expressots templates update' to fetch templates."));
+        return;
+    }
+    // CI/CD Templates
+    if (!category || category === "cicd") {
+        console.log(chalk_1.default.bold("CI/CD Pipelines:"));
+        if (Object.keys(templates.cicd).length === 0) {
+            console.log(chalk_1.default.gray("  No CI/CD templates available"));
+        }
+        else {
+            for (const [plat, strategies] of Object.entries(templates.cicd)) {
+                if (!platform || platform === plat) {
+                    console.log(`  ${chalk_1.default.yellow(plat)}: ${strategies.join(", ")}`);
+                }
+            }
+        }
+        console.log();
+    }
+    // Docker Templates
+    if (!category || category === "docker") {
+        console.log(chalk_1.default.bold("Docker:"));
+        if (templates.docker.length === 0) {
+            console.log(chalk_1.default.gray("  No Docker templates available"));
+        }
+        else {
+            for (const tpl of templates.docker) {
+                console.log(`  ${chalk_1.default.cyan(tpl)}`);
+            }
+        }
+        console.log();
+    }
+    // Kubernetes Templates
+    if (!category || category === "kubernetes") {
+        console.log(chalk_1.default.bold("Kubernetes:"));
+        if (templates.kubernetes.length === 0) {
+            console.log(chalk_1.default.gray("  No Kubernetes templates available"));
+        }
+        else {
+            for (const tpl of templates.kubernetes) {
+                console.log(`  ${chalk_1.default.green(tpl)}`);
+            }
+        }
+        console.log();
+    }
+    // Migration Templates
+    if (!category || category === "migrations") {
+        console.log(chalk_1.default.bold("Migrations:"));
+        if (templates.migrations.length === 0) {
+            console.log(chalk_1.default.gray("  No migration templates available"));
+        }
+        else {
+            for (const tpl of templates.migrations) {
+                console.log(`  ${chalk_1.default.magenta(tpl)}`);
+            }
+        }
+        console.log();
+    }
+}
+/**
+ * Update template cache
+ */
+async function updateTemplates() {
+    (0, cli_ui_1.printSection)("🔄 Updating Templates...");
+    const manager = (0, manager_1.getTemplateManager)();
+    const result = await manager.updateCache();
+    if (result.updated > 0) {
+        console.log(chalk_1.default.green(`✓ Updated ${result.updated} templates`));
+    }
+    if (result.errors.length > 0) {
+        console.log(chalk_1.default.yellow(`\n⚠️  ${result.errors.length} errors occurred:`));
+        for (const error of result.errors) {
+            console.log(chalk_1.default.gray(`  - ${error}`));
+        }
+    }
+    if (result.updated === 0 && result.errors.length === 0) {
+        console.log(chalk_1.default.yellow("No templates were updated. Check your network connection."));
+    }
+    console.log();
+}
+/**
+ * Clear template cache
+ */
+async function clearCache() {
+    (0, cli_ui_1.printSection)("🗑️  Clearing Template Cache...");
+    const manager = (0, manager_1.getTemplateManager)();
+    const stats = manager.getCacheStats();
+    manager.clearCache();
+    console.log(chalk_1.default.green(`✓ Cleared ${stats.files} cached templates`));
+    console.log(chalk_1.default.gray(`  Freed ${(stats.totalSize / 1024).toFixed(2)} KB`));
+    console.log();
+}
+/**
+ * Show template info
+ */
+async function showTemplateInfo(category, platform) {
+    if (!category) {
+        console.log(chalk_1.default.red("Please specify a category and platform."));
+        console.log(chalk_1.default.gray("Example: expressots templates info cicd github"));
+        return;
+    }
+    console.log(chalk_1.default.cyan(`\n📄 Template Info: ${category}${platform ? `/${platform}` : ""}\n`));
+    const manager = (0, manager_1.getTemplateManager)();
+    const manifest = await manager.getManifest();
+    if (!manifest) {
+        console.log(chalk_1.default.yellow("No manifest available. Run 'expressots templates update' first."));
+        return;
+    }
+    const categoryTemplates = manifest.templates[category];
+    if (!categoryTemplates) {
+        console.log(chalk_1.default.red(`Category '${category}' not found.`));
+        return;
+    }
+    if (platform) {
+        const platformTemplates = categoryTemplates[platform];
+        if (!platformTemplates) {
+            console.log(chalk_1.default.red(`Platform '${platform}' not found in category '${category}'.`));
+            return;
+        }
+        console.log(chalk_1.default.bold(`${category}/${platform}:`));
+        for (const [variant, info] of Object.entries(platformTemplates)) {
+            console.log(`  ${chalk_1.default.yellow(variant)}:`);
+            console.log(`    Path:    ${info.path}`);
+            console.log(`    Version: ${info.version}`);
+        }
+    }
+    else {
+        console.log(chalk_1.default.bold(`${category}:`));
+        for (const [key, value] of Object.entries(categoryTemplates)) {
+            console.log(`  ${chalk_1.default.yellow(key)}`);
+        }
+    }
+    console.log();
+}
+/**
+ * Manage template repository
+ */
+async function manageRepository(args) {
+    const configManager = (0, config_1.getConfigManager)();
+    const subAction = args[0];
+    if (!subAction) {
+        const config = configManager.getTemplateConfig();
+        (0, cli_ui_1.printSection)("📦 Template Repository Configuration");
+        console.log(`  Repository: ${chalk_1.default.yellow(config.repository)}`);
+        console.log(`  Branch:     ${chalk_1.default.cyan(config.branch)}`);
+        console.log(`  Cache TTL:  ${config.cacheTTL} seconds`);
+        console.log();
+        console.log(chalk_1.default.gray("Use 'expressots templates repo set <url>' to change."));
+        console.log(chalk_1.default.gray("Use 'expressots templates repo reset' to restore defaults."));
+        return;
+    }
+    switch (subAction) {
+        case "set": {
+            const repository = args[1];
+            const branch = args[2];
+            if (!repository) {
+                console.log(chalk_1.default.red("Please specify a repository URL."));
+                console.log(chalk_1.default.gray("Example: expressots templates repo set https://github.com/myorg/templates"));
+                return;
+            }
+            configManager.setTemplateRepository(repository, branch);
+            // Clear cache when repository changes
+            const manager = (0, manager_1.getTemplateManager)();
+            manager.clearCache();
+            manager.setRepository(repository, branch);
+            console.log(chalk_1.default.green(`\n✓ Template repository set to: ${repository}`));
+            if (branch) {
+                console.log(chalk_1.default.green(`  Branch: ${branch}`));
+            }
+            console.log(chalk_1.default.gray("\nRun 'expressots templates update' to fetch templates from the new repository."));
+            break;
+        }
+        case "reset": {
+            configManager.resetTemplateRepository();
+            const manager = (0, manager_1.getTemplateManager)();
+            manager.clearCache();
+            manager.setRepository("expressots/templates", "main");
+            console.log(chalk_1.default.green("\n✓ Template repository reset to default (expressots/templates)"));
+            break;
+        }
+        default:
+            console.log(chalk_1.default.red(`Unknown repository action: ${subAction}`));
+            console.log(chalk_1.default.gray("Use 'set' or 'reset'."));
+    }
+}
+/**
+ * Show template system status
+ */
+async function showStatus() {
+    const manager = (0, manager_1.getTemplateManager)();
+    await manager.printStatus();
+}

package/bin/templates/fetcher.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Template fetcher - fetches templates from GitHub repository
+ */
+import type { TemplateManifest, FetchResult } from "./types";
+export interface FetcherConfig {
+    repository: string;
+    branch: string;
+    timeout: number;
+}
+export declare class GitHubFetcher {
+    private config;
+    private retryCount;
+    private retryDelay;
+    constructor(config?: Partial<FetcherConfig>);
+    /**
+     * Build raw GitHub URL for a file
+     */
+    private buildUrl;
+    /**
+     * Fetch content from URL with retry logic
+     */
+    private fetchWithRetry;
+    /**
+     * Fetch template manifest
+     */
+    fetchManifest(): Promise<FetchResult<TemplateManifest>>;
+    /**
+     * Fetch template content by path
+     */
+    fetchTemplate(templatePath: string): Promise<FetchResult<string>>;
+    /**
+     * Fetch template by category, platform, and variant
+     */
+    fetchByType(category: string, platform: string, variant?: string): Promise<FetchResult<string>>;
+    /**
+     * Check if repository is accessible
+     */
+    checkConnection(): Promise<boolean>;
+    /**
+     * Update repository configuration
+     */
+    setRepository(repository: string, branch?: string): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): FetcherConfig;
+}
+export declare function getGitHubFetcher(config?: Partial<FetcherConfig>): GitHubFetcher;
+export declare function resetFetcher(): void;

package/bin/templates/fetcher.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Template fetcher - fetches templates from GitHub repository
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetFetcher = exports.getGitHubFetcher = exports.GitHubFetcher = void 0;
+const https_1 = __importDefault(require("https"));
+const DEFAULT_REPO = "expressots/templates";
+const DEFAULT_BRANCH = "main";
+const GITHUB_RAW_BASE = "https://raw.githubusercontent.com";
+const FETCH_TIMEOUT = 5000; // 5 seconds for faster fallback
+class GitHubFetcher {
+    constructor(config) {
+        this.retryCount = 1; // Single retry for faster fallback
+        this.retryDelay = 500;
+        this.config = {
+            repository: config?.repository || DEFAULT_REPO,
+            branch: config?.branch || DEFAULT_BRANCH,
+            timeout: config?.timeout || FETCH_TIMEOUT,
+        };
+    }
+    /**
+     * Build raw GitHub URL for a file
+     */
+    buildUrl(filePath) {
+        return `${GITHUB_RAW_BASE}/${this.config.repository}/${this.config.branch}/${filePath}`;
+    }
+    /**
+     * Fetch content from URL with retry logic
+     */
+    async fetchWithRetry(url, attempt = 1) {
+        return new Promise((resolve, reject) => {
+            const request = https_1.default.get(url, { timeout: this.config.timeout }, (response) => {
+                // Handle redirects
+                if (response.statusCode === 301 ||
+                    response.statusCode === 302) {
+                    const redirectUrl = response.headers.location;
+                    if (redirectUrl) {
+                        this.fetchWithRetry(redirectUrl, attempt)
+                            .then(resolve)
+                            .catch(reject);
+                        return;
+                    }
+                }
+                if (response.statusCode === 404) {
+                    reject(new Error(`Template not found: ${url}`));
+                    return;
+                }
+                if (response.statusCode === 403) {
+                    // Rate limited
+                    if (attempt < this.retryCount) {
+                        setTimeout(() => {
+                            this.fetchWithRetry(url, attempt + 1)
+                                .then(resolve)
+                                .catch(reject);
+                        }, this.retryDelay * Math.pow(2, attempt - 1));
+                        return;
+                    }
+                    reject(new Error("GitHub API rate limit exceeded"));
+                    return;
+                }
+                if (response.statusCode !== 200) {
+                    reject(new Error(`HTTP ${response.statusCode}: Failed to fetch ${url}`));
+                    return;
+                }
+                let data = "";
+                response.on("data", (chunk) => {
+                    data += chunk;
+                });
+                response.on("end", () => {
+                    resolve(data);
+                });
+            });
+            request.on("error", (error) => {
+                if (attempt < this.retryCount) {
+                    setTimeout(() => {
+                        this.fetchWithRetry(url, attempt + 1)
+                            .then(resolve)
+                            .catch(reject);
+                    }, this.retryDelay * Math.pow(2, attempt - 1));
+                }
+                else {
+                    reject(error);
+                }
+            });
+            request.on("timeout", () => {
+                request.destroy();
+                if (attempt < this.retryCount) {
+                    setTimeout(() => {
+                        this.fetchWithRetry(url, attempt + 1)
+                            .then(resolve)
+                            .catch(reject);
+                    }, this.retryDelay * Math.pow(2, attempt - 1));
+                }
+                else {
+                    reject(new Error(`Timeout fetching ${url}`));
+                }
+            });
+        });
+    }
+    /**
+     * Fetch template manifest
+     */
+    async fetchManifest() {
+        try {
+            const url = this.buildUrl("manifest.json");
+            const content = await this.fetchWithRetry(url);
+            const manifest = JSON.parse(content);
+            return { data: manifest, source: "remote" };
+        }
+        catch (error) {
+            return {
+                data: null,
+                source: "remote",
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    }
+    /**
+     * Fetch template content by path
+     */
+    async fetchTemplate(templatePath) {
+        try {
+            const url = this.buildUrl(templatePath);
+            const content = await this.fetchWithRetry(url);
+            return { data: content, source: "remote" };
+        }
+        catch (error) {
+            return {
+                data: null,
+                source: "remote",
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    }
+    /**
+     * Fetch template by category, platform, and variant
+     */
+    async fetchByType(category, platform, variant) {
+        // Build the path based on category
+        let templatePath;
+        switch (category) {
+            case "cicd":
+                templatePath = `cicd/${platform}/${variant || "basic"}.yml`;
+                break;
+            case "docker":
+                templatePath = `docker/${platform}.tpl`;
+                break;
+            case "kubernetes":
+                templatePath = `kubernetes/${platform}.yml.tpl`;
+                break;
+            case "migrations":
+                templatePath = `migrations/${platform}/${variant || "checklist"}.md.tpl`;
+                break;
+            default:
+                return {
+                    data: null,
+                    source: "remote",
+                    error: `Unknown template category: ${category}`,
+                };
+        }
+        return this.fetchTemplate(templatePath);
+    }
+    /**
+     * Check if repository is accessible
+     */
+    async checkConnection() {
+        try {
+            const result = await this.fetchManifest();
+            return result.data !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Update repository configuration
+     */
+    setRepository(repository, branch) {
+        this.config.repository = repository;
+        if (branch) {
+            this.config.branch = branch;
+        }
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+exports.GitHubFetcher = GitHubFetcher;
+// Singleton instance
+let fetcherInstance = null;
+function getGitHubFetcher(config) {
+    if (!fetcherInstance) {
+        fetcherInstance = new GitHubFetcher(config);
+    }
+    return fetcherInstance;
+}
+exports.getGitHubFetcher = getGitHubFetcher;
+function resetFetcher() {
+    fetcherInstance = null;
+}
+exports.resetFetcher = resetFetcher;

package/bin/templates/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Template system exports
+ */
+export * from "./types";
+export { TemplateCache, getTemplateCache } from "./cache";
+export { GitHubFetcher, getGitHubFetcher, resetFetcher } from "./fetcher";
+export { TemplateRenderer, getTemplateRenderer } from "./renderer";
+export { TemplateManager, getTemplateManager, resetTemplateManager, } from "./manager";
+export { templatesCommand } from "./cli";
+export type { TemplateManagerConfig } from "./manager";
+export type { FetcherConfig } from "./fetcher";

package/bin/templates/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Template system exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templatesCommand = exports.resetTemplateManager = exports.getTemplateManager = exports.TemplateManager = exports.getTemplateRenderer = exports.TemplateRenderer = exports.resetFetcher = exports.getGitHubFetcher = exports.GitHubFetcher = exports.getTemplateCache = exports.TemplateCache = void 0;
+__exportStar(require("./types"), exports);
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "TemplateCache", { enumerable: true, get: function () { return cache_1.TemplateCache; } });
+Object.defineProperty(exports, "getTemplateCache", { enumerable: true, get: function () { return cache_1.getTemplateCache; } });
+var fetcher_1 = require("./fetcher");
+Object.defineProperty(exports, "GitHubFetcher", { enumerable: true, get: function () { return fetcher_1.GitHubFetcher; } });
+Object.defineProperty(exports, "getGitHubFetcher", { enumerable: true, get: function () { return fetcher_1.getGitHubFetcher; } });
+Object.defineProperty(exports, "resetFetcher", { enumerable: true, get: function () { return fetcher_1.resetFetcher; } });
+var renderer_1 = require("./renderer");
+Object.defineProperty(exports, "TemplateRenderer", { enumerable: true, get: function () { return renderer_1.TemplateRenderer; } });
+Object.defineProperty(exports, "getTemplateRenderer", { enumerable: true, get: function () { return renderer_1.getTemplateRenderer; } });
+var manager_1 = require("./manager");
+Object.defineProperty(exports, "TemplateManager", { enumerable: true, get: function () { return manager_1.TemplateManager; } });
+Object.defineProperty(exports, "getTemplateManager", { enumerable: true, get: function () { return manager_1.getTemplateManager; } });
+Object.defineProperty(exports, "resetTemplateManager", { enumerable: true, get: function () { return manager_1.resetTemplateManager; } });
+var cli_1 = require("./cli");
+Object.defineProperty(exports, "templatesCommand", { enumerable: true, get: function () { return cli_1.templatesCommand; } });