@expressots/cli 3.0.0 → 4.0.0-preview.3

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;

package/bin/templates/renderer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Template renderer - processes templates with variable substitution
+ * Uses Mustache-like syntax: {{variable}}, {{#condition}}...{{/condition}}
+ */
+import type { RenderOptions } from "./types";
+export declare class TemplateRenderer {
+    /**
+     * Render template with variable substitution
+     */
+    render(template: string, options: RenderOptions): string;
+    /**
+     * Process conditional blocks {{#condition}}...{{/condition}}
+     */
+    private processConditionals;
+    /**
+     * Process negative conditional blocks {{^condition}}...{{/condition}}
+     */
+    private processNegativeConditionals;
+    /**
+     * Process loop blocks for arrays
+     */
+    private processLoops;
+    /**
+     * Process simple variable substitution {{variable}}
+     */
+    private processVariables;
+    /**
+     * Get nested value from object using dot notation. Falls back to a
+     * flat-key lookup so callers can provide either
+     * `{ app: { version: "1.0.0" } }` or `{ "app.version": "1.0.0" }`.
+     */
+    private getNestedValue;
+    /**
+     * Check if value is truthy for conditional evaluation
+     */
+    private isTruthy;
+    /**
+     * Validate template syntax
+     */
+    validateTemplate(template: string): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Extract variable names from template
+     */
+    extractVariables(template: string): string[];
+}
+export declare function getTemplateRenderer(): TemplateRenderer;

package/bin/templates/renderer.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * Template renderer - processes templates with variable substitution
+ * Uses Mustache-like syntax: {{variable}}, {{#condition}}...{{/condition}}
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemplateRenderer = exports.TemplateRenderer = void 0;
+class TemplateRenderer {
+    /**
+     * Render template with variable substitution
+     */
+    render(template, options) {
+        let result = template;
+        // Process conditionals first: {{#condition}}content{{/condition}}
+        result = this.processConditionals(result, options);
+        // Process negative conditionals: {{^condition}}content{{/condition}}
+        result = this.processNegativeConditionals(result, options);
+        // Process loops: {{#items}}{{.}}{{/items}}
+        result = this.processLoops(result, options);
+        // Process simple variable substitution: {{variable}}
+        result = this.processVariables(result, options);
+        return result;
+    }
+    /**
+     * Process conditional blocks {{#condition}}...{{/condition}}
+     */
+    processConditionals(template, options) {
+        const pattern = /\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g;
+        return template.replace(pattern, (match, condition, content) => {
+            const value = options.conditionals?.[condition] ??
+                options.variables[condition];
+            // Check if value is truthy
+            if (this.isTruthy(value)) {
+                // Recursively process the content
+                return this.render(content, options);
+            }
+            return "";
+        });
+    }
+    /**
+     * Process negative conditional blocks {{^condition}}...{{/condition}}
+     */
+    processNegativeConditionals(template, options) {
+        const pattern = /\{\{\^(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g;
+        return template.replace(pattern, (match, condition, content) => {
+            const value = options.conditionals?.[condition] ??
+                options.variables[condition];
+            // Check if value is falsy
+            if (!this.isTruthy(value)) {
+                return this.render(content, options);
+            }
+            return "";
+        });
+    }
+    /**
+     * Process loop blocks for arrays
+     */
+    processLoops(template, options) {
+        const pattern = /\{\{#each\s+(\w+)\}\}([\s\S]*?)\{\{\/each\}\}/g;
+        return template.replace(pattern, (match, arrayName, content) => {
+            const array = options.variables[arrayName];
+            if (!Array.isArray(array)) {
+                return "";
+            }
+            return array
+                .map((item, index) => {
+                // Create new options with item context
+                const itemOptions = {
+                    ...options,
+                    variables: {
+                        ...options.variables,
+                        ".": String(item),
+                        "@index": index,
+                        "@first": index === 0,
+                        "@last": index === array.length - 1,
+                        ...(typeof item === "object" ? item : {}),
+                    },
+                };
+                return this.render(content, itemOptions);
+            })
+                .join("");
+        });
+    }
+    /**
+     * Process simple variable substitution {{variable}}
+     */
+    processVariables(template, options) {
+        // Match {{variable}} but not {{#variable}} or {{/variable}} or {{^variable}}
+        const pattern = /\{\{([^#/^}][^}]*?)\}\}/g;
+        return template.replace(pattern, (match, variable) => {
+            const trimmedVar = variable.trim();
+            // Handle dot notation for nested variables
+            const value = this.getNestedValue(options.variables, trimmedVar);
+            if (value === undefined || value === null) {
+                // Keep the placeholder if variable not found (for debugging)
+                return "";
+            }
+            return String(value);
+        });
+    }
+    /**
+     * Get nested value from object using dot notation. Falls back to a
+     * flat-key lookup so callers can provide either
+     * `{ app: { version: "1.0.0" } }` or `{ "app.version": "1.0.0" }`.
+     */
+    getNestedValue(obj, path) {
+        if (Object.prototype.hasOwnProperty.call(obj, path)) {
+            return obj[path];
+        }
+        const parts = path.split(".");
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            if (typeof current !== "object") {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    /**
+     * Check if value is truthy for conditional evaluation
+     */
+    isTruthy(value) {
+        if (value === undefined || value === null)
+            return false;
+        if (typeof value === "boolean")
+            return value;
+        if (typeof value === "number")
+            return value !== 0;
+        if (typeof value === "string")
+            return value.length > 0;
+        if (Array.isArray(value))
+            return value.length > 0;
+        if (typeof value === "object")
+            return Object.keys(value).length > 0;
+        return Boolean(value);
+    }
+    /**
+     * Validate template syntax
+     */
+    validateTemplate(template) {
+        const errors = [];
+        // Check for unclosed conditionals
+        const openConditionals = template.match(/\{\{#(\w+)\}\}/g) || [];
+        const closeConditionals = template.match(/\{\{\/(\w+)\}\}/g) || [];
+        for (const open of openConditionals) {
+            const name = open.match(/\{\{#(\w+)\}\}/)?.[1];
+            if (name) {
+                const closePattern = new RegExp(`\\{\\{\\/${name}\\}\\}`);
+                if (!closePattern.test(template)) {
+                    errors.push(`Unclosed conditional block: {{#${name}}}`);
+                }
+            }
+        }
+        // Check for orphaned closing tags
+        for (const close of closeConditionals) {
+            const name = close.match(/\{\{\/(\w+)\}\}/)?.[1];
+            if (name) {
+                const openPattern = new RegExp(`\\{\\{[#\\^]${name}\\}\\}`);
+                if (!openPattern.test(template)) {
+                    errors.push(`Orphaned closing tag: {{/${name}}}`);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Extract variable names from template
+     */
+    extractVariables(template) {
+        const variables = new Set();
+        // Match simple variables
+        const simplePattern = /\{\{([^#/^}][^}]*?)\}\}/g;
+        let match;
+        while ((match = simplePattern.exec(template)) !== null) {
+            const variable = match[1].trim();
+            if (!variable.startsWith(".") && !variable.startsWith("@")) {
+                variables.add(variable.split(".")[0]); // Get root variable
+            }
+        }
+        // Match conditional variables
+        const conditionalPattern = /\{\{[#^](\w+)\}\}/g;
+        while ((match = conditionalPattern.exec(template)) !== null) {
+            variables.add(match[1]);
+        }
+        return Array.from(variables);
+    }
+}
+exports.TemplateRenderer = TemplateRenderer;
+// Singleton instance
+let rendererInstance = null;
+function getTemplateRenderer() {
+    if (!rendererInstance) {
+        rendererInstance = new TemplateRenderer();
+    }
+    return rendererInstance;
+}
+exports.getTemplateRenderer = getTemplateRenderer;