@expressots/cli 3.0.0 → 4.0.0-preview.2

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; } });

package/bin/templates/manager.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Template Manager - orchestrates template fetching, caching, and rendering
+ */
+import type { TemplateCategory, CICDPlatform, CIStrategy, TemplateManifest, RenderOptions, FetchResult } from "./types";
+export interface TemplateManagerConfig {
+    repository?: string;
+    branch?: string;
+    cacheTTL?: number;
+    offline?: boolean;
+}
+export declare class TemplateManager {
+    private cache;
+    private fetcher;
+    private renderer;
+    private offline;
+    private manifest;
+    constructor(config?: TemplateManagerConfig);
+    /**
+     * Fetch and cache the template manifest
+     */
+    getManifest(forceRefresh?: boolean): Promise<TemplateManifest | null>;
+    /**
+     * Fetch a template by type
+     */
+    fetchTemplate(category: TemplateCategory, platform: string, variant?: string): Promise<FetchResult<string>>;
+    /**
+     * Fetch CI/CD template
+     */
+    fetchCICDTemplate(platform: CICDPlatform, strategy?: CIStrategy): Promise<FetchResult<string>>;
+    /**
+     * Fetch Docker template
+     */
+    fetchDockerTemplate(type: string): Promise<FetchResult<string>>;
+    /**
+     * Fetch Kubernetes template
+     */
+    fetchKubernetesTemplate(type: string): Promise<FetchResult<string>>;
+    /**
+     * Fetch migration template
+     */
+    fetchMigrationTemplate(from: string, to: string, file?: string): Promise<FetchResult<string>>;
+    /**
+     * Render a template with variables
+     */
+    render(template: string, options: RenderOptions): string;
+    /**
+     * Fetch and render template in one step
+     */
+    fetchAndRender(category: TemplateCategory, platform: string, variant: string | undefined, renderOptions: RenderOptions): Promise<FetchResult<string>>;
+    /**
+     * Update all cached templates
+     */
+    updateCache(): Promise<{
+        updated: number;
+        errors: string[];
+    }>;
+    /**
+     * Clear template cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        files: number;
+        totalSize: number;
+        oldestEntry: Date | null;
+    };
+    /**
+     * List available templates
+     */
+    listTemplates(): Promise<{
+        cicd: Record<string, string[]>;
+        docker: string[];
+        kubernetes: string[];
+        migrations: string[];
+        source: "remote" | "embedded";
+    }>;
+    /**
+     * Get list of embedded templates (fallback when remote unavailable)
+     */
+    private getEmbeddedTemplatesList;
+    /**
+     * Set repository for template fetching
+     */
+    setRepository(repository: string, branch?: string): void;
+    /**
+     * Set offline mode
+     */
+    setOfflineMode(offline: boolean): void;
+    /**
+     * Check if templates are available (cached or remote)
+     */
+    checkAvailability(): Promise<{
+        online: boolean;
+        cached: boolean;
+        manifest: boolean;
+    }>;
+    /**
+     * Validate a template
+     */
+    validateTemplate(template: string): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Extract variables from template
+     */
+    extractVariables(template: string): string[];
+    /**
+     * Print template status (for CLI output)
+     */
+    printStatus(): Promise<void>;
+}
+export declare function getTemplateManager(config?: TemplateManagerConfig): TemplateManager;
+export declare function resetTemplateManager(): void;

package/bin/templates/manager.js

@@ -0,0 +1,323 @@
+"use strict";
+/**
+ * Template Manager - orchestrates template fetching, caching, and rendering
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetTemplateManager = exports.getTemplateManager = exports.TemplateManager = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const cache_1 = require("./cache");
+const fetcher_1 = require("./fetcher");
+const renderer_1 = require("./renderer");
+class TemplateManager {
+    constructor(config) {
+        this.manifest = null;
+        this.cache = (0, cache_1.getTemplateCache)({ ttl: config?.cacheTTL });
+        this.fetcher = (0, fetcher_1.getGitHubFetcher)({
+            repository: config?.repository,
+            branch: config?.branch,
+        });
+        this.renderer = (0, renderer_1.getTemplateRenderer)();
+        this.offline = config?.offline ?? false;
+    }
+    /**
+     * Fetch and cache the template manifest
+     */
+    async getManifest(forceRefresh = false) {
+        // Check memory cache first
+        if (this.manifest && !forceRefresh) {
+            return this.manifest;
+        }
+        // Check disk cache
+        if (!forceRefresh) {
+            const cached = this.cache.get("manifest", "root");
+            if (cached) {
+                this.manifest = cached;
+                return cached;
+            }
+        }
+        // Fetch from remote (if not offline)
+        if (!this.offline) {
+            const result = await this.fetcher.fetchManifest();
+            if (result.data) {
+                this.manifest = result.data;
+                this.cache.set("manifest", "root", result.data);
+                return result.data;
+            }
+        }
+        return null;
+    }
+    /**
+     * Fetch a template by type
+     */
+    async fetchTemplate(category, platform, variant) {
+        const cacheKey = variant ? `${platform}-${variant}` : platform;
+        // Check cache first
+        const cached = this.cache.get(category, cacheKey);
+        if (cached) {
+            return { data: cached, source: "cache" };
+        }
+        // If offline, return null
+        if (this.offline) {
+            return {
+                data: null,
+                source: "cache",
+                error: "Offline mode - template not in cache",
+            };
+        }
+        // Fetch from remote
+        const result = await this.fetcher.fetchByType(category, platform, variant);
+        if (result.data) {
+            // Cache the template
+            this.cache.set(category, cacheKey, result.data);
+            return { data: result.data, source: "remote" };
+        }
+        return result;
+    }
+    /**
+     * Fetch CI/CD template
+     */
+    async fetchCICDTemplate(platform, strategy = "basic") {
+        return this.fetchTemplate("cicd", platform, strategy);
+    }
+    /**
+     * Fetch Docker template
+     */
+    async fetchDockerTemplate(type) {
+        return this.fetchTemplate("docker", type);
+    }
+    /**
+     * Fetch Kubernetes template
+     */
+    async fetchKubernetesTemplate(type) {
+        return this.fetchTemplate("kubernetes", type);
+    }
+    /**
+     * Fetch migration template
+     */
+    async fetchMigrationTemplate(from, to, file) {
+        const migrationPath = `${from}-to-${to}`;
+        return this.fetchTemplate("migrations", migrationPath, file);
+    }
+    /**
+     * Render a template with variables
+     */
+    render(template, options) {
+        return this.renderer.render(template, options);
+    }
+    /**
+     * Fetch and render template in one step
+     */
+    async fetchAndRender(category, platform, variant, renderOptions) {
+        const fetchResult = await this.fetchTemplate(category, platform, variant);
+        if (!fetchResult.data) {
+            return fetchResult;
+        }
+        const rendered = this.render(fetchResult.data, renderOptions);
+        return { data: rendered, source: fetchResult.source };
+    }
+    /**
+     * Update all cached templates
+     */
+    async updateCache() {
+        const errors = [];
+        let updated = 0;
+        // Fetch fresh manifest
+        const manifest = await this.getManifest(true);
+        if (!manifest) {
+            return { updated: 0, errors: ["Failed to fetch manifest"] };
+        }
+        // Update CI/CD templates
+        if (manifest.templates.cicd) {
+            for (const [platform, strategies] of Object.entries(manifest.templates.cicd)) {
+                for (const [strategy, info] of Object.entries(strategies)) {
+                    const result = await this.fetcher.fetchTemplate(info.path);
+                    if (result.data) {
+                        this.cache.set("cicd", `${platform}-${strategy}`, result.data);
+                        updated++;
+                    }
+                    else if (result.error) {
+                        errors.push(`${platform}/${strategy}: ${result.error}`);
+                    }
+                }
+            }
+        }
+        // Update Docker templates
+        if (manifest.templates.docker) {
+            for (const [type, info] of Object.entries(manifest.templates.docker)) {
+                const result = await this.fetcher.fetchTemplate(info.path);
+                if (result.data) {
+                    this.cache.set("docker", type, result.data);
+                    updated++;
+                }
+                else if (result.error) {
+                    errors.push(`docker/${type}: ${result.error}`);
+                }
+            }
+        }
+        // Update Kubernetes templates
+        if (manifest.templates.kubernetes) {
+            for (const [type, info] of Object.entries(manifest.templates.kubernetes)) {
+                const result = await this.fetcher.fetchTemplate(info.path);
+                if (result.data) {
+                    this.cache.set("kubernetes", type, result.data);
+                    updated++;
+                }
+                else if (result.error) {
+                    errors.push(`kubernetes/${type}: ${result.error}`);
+                }
+            }
+        }
+        return { updated, errors };
+    }
+    /**
+     * Clear template cache
+     */
+    clearCache() {
+        this.cache.clear();
+        this.manifest = null;
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return this.cache.getStats();
+    }
+    /**
+     * List available templates
+     */
+    async listTemplates() {
+        const manifest = await this.getManifest();
+        // If remote manifest available, use it
+        if (manifest) {
+            const result = {
+                cicd: {},
+                docker: [],
+                kubernetes: [],
+                migrations: [],
+                source: "remote",
+            };
+            // CI/CD templates
+            if (manifest.templates.cicd) {
+                for (const [platform, strategies] of Object.entries(manifest.templates.cicd)) {
+                    result.cicd[platform] = Object.keys(strategies);
+                }
+            }
+            // Docker templates
+            if (manifest.templates.docker) {
+                result.docker = Object.keys(manifest.templates.docker);
+            }
+            // Kubernetes templates
+            if (manifest.templates.kubernetes) {
+                result.kubernetes = Object.keys(manifest.templates.kubernetes);
+            }
+            // Migration templates
+            if (manifest.templates.migrations) {
+                for (const [from, targets] of Object.entries(manifest.templates.migrations)) {
+                    for (const to of Object.keys(targets)) {
+                        result.migrations.push(`${from} → ${to}`);
+                    }
+                }
+            }
+            return result;
+        }
+        // Fallback to embedded templates list
+        return this.getEmbeddedTemplatesList();
+    }
+    /**
+     * Get list of embedded templates (fallback when remote unavailable)
+     */
+    getEmbeddedTemplatesList() {
+        return {
+            cicd: {
+                github: ["basic", "comprehensive", "security-focused"],
+                gitlab: ["basic", "comprehensive", "security-focused"],
+                circleci: ["basic", "comprehensive"],
+                jenkins: ["basic"],
+                bitbucket: ["basic"],
+                azure: ["basic"],
+            },
+            docker: [
+                "production",
+                "development",
+                "compose",
+                "compose-development",
+            ],
+            kubernetes: ["deployment", "service", "configmap", "ingress"],
+            migrations: [
+                "heroku → railway",
+                "heroku → render",
+                "heroku → fly",
+                "compose → kubernetes",
+            ],
+            source: "embedded",
+        };
+    }
+    /**
+     * Set repository for template fetching
+     */
+    setRepository(repository, branch) {
+        this.fetcher.setRepository(repository, branch);
+        // Clear cache when repository changes
+        this.clearCache();
+    }
+    /**
+     * Set offline mode
+     */
+    setOfflineMode(offline) {
+        this.offline = offline;
+    }
+    /**
+     * Check if templates are available (cached or remote)
+     */
+    async checkAvailability() {
+        const online = !this.offline && (await this.fetcher.checkConnection());
+        const cached = this.cache.getStats().files > 0;
+        const manifest = (await this.getManifest()) !== null;
+        return { online, cached, manifest };
+    }
+    /**
+     * Validate a template
+     */
+    validateTemplate(template) {
+        return this.renderer.validateTemplate(template);
+    }
+    /**
+     * Extract variables from template
+     */
+    extractVariables(template) {
+        return this.renderer.extractVariables(template);
+    }
+    /**
+     * Print template status (for CLI output)
+     */
+    async printStatus() {
+        const availability = await this.checkAvailability();
+        const stats = this.getCacheStats();
+        console.log(chalk_1.default.bold("\nTemplate System Status:\n"));
+        console.log(`  Online:   ${availability.online ? chalk_1.default.green("✓") : chalk_1.default.red("✗")}`);
+        console.log(`  Cached:   ${availability.cached ? chalk_1.default.green("✓") : chalk_1.default.yellow("No templates cached")}`);
+        console.log(`  Manifest: ${availability.manifest ? chalk_1.default.green("✓") : chalk_1.default.yellow("Not loaded")}`);
+        console.log(chalk_1.default.bold("\nCache Statistics:\n"));
+        console.log(`  Files:    ${stats.files}`);
+        console.log(`  Size:     ${(stats.totalSize / 1024).toFixed(2)} KB`);
+        console.log(`  Oldest:   ${stats.oldestEntry?.toLocaleString() || "N/A"}`);
+        console.log(`  Location: ${this.cache.getCacheDirectory()}`);
+    }
+}
+exports.TemplateManager = TemplateManager;
+// Singleton instance
+let managerInstance = null;
+function getTemplateManager(config) {
+    if (!managerInstance) {
+        managerInstance = new TemplateManager(config);
+    }
+    return managerInstance;
+}
+exports.getTemplateManager = getTemplateManager;
+function resetTemplateManager() {
+    managerInstance = null;
+}
+exports.resetTemplateManager = resetTemplateManager;