@expressots/cli 3.0.0 → 4.0.0-preview.2

package/bin/templates/cache.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Template cache management
+ * Stores templates locally for offline access and performance
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemplateCache = exports.TemplateCache = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const DEFAULT_CACHE_DIR = path_1.default.join(os_1.default.homedir(), ".expressots", "cache", "templates");
+const DEFAULT_TTL = 86400; // 24 hours in seconds
+class TemplateCache {
+    constructor(config) {
+        this.config = {
+            directory: config?.directory || DEFAULT_CACHE_DIR,
+            ttl: config?.ttl || DEFAULT_TTL,
+        };
+        this.ensureCacheDir();
+    }
+    /**
+     * Ensure cache directory exists
+     */
+    ensureCacheDir() {
+        if (!fs_1.default.existsSync(this.config.directory)) {
+            fs_1.default.mkdirSync(this.config.directory, { recursive: true });
+        }
+    }
+    /**
+     * Generate cache key from template identifier
+     */
+    getCacheKey(category, platform, variant) {
+        const parts = [category, platform];
+        if (variant)
+            parts.push(variant);
+        return parts.join("-") + ".cache.json";
+    }
+    /**
+     * Get cache file path
+     */
+    getCachePath(key) {
+        return path_1.default.join(this.config.directory, key);
+    }
+    /**
+     * Check if cache entry is valid (not expired)
+     */
+    isValid(entry) {
+        const now = Date.now();
+        const expiresAt = entry.timestamp + entry.ttl * 1000;
+        return now < expiresAt;
+    }
+    /**
+     * Get cached template content
+     */
+    get(category, platform, variant) {
+        const key = this.getCacheKey(category, platform, variant);
+        const cachePath = this.getCachePath(key);
+        try {
+            if (!fs_1.default.existsSync(cachePath)) {
+                return null;
+            }
+            const content = fs_1.default.readFileSync(cachePath, "utf-8");
+            const entry = JSON.parse(content);
+            if (!this.isValid(entry)) {
+                // Cache expired, remove it
+                this.delete(category, platform, variant);
+                return null;
+            }
+            return entry.data;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Set cached template content
+     */
+    set(category, platform, data, variant, ttl) {
+        const key = this.getCacheKey(category, platform, variant);
+        const cachePath = this.getCachePath(key);
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            ttl: ttl || this.config.ttl,
+        };
+        try {
+            fs_1.default.writeFileSync(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+        }
+        catch (error) {
+            // Silently fail - cache is optional
+            console.error("Failed to write cache:", error);
+        }
+    }
+    /**
+     * Delete cached template
+     */
+    delete(category, platform, variant) {
+        const key = this.getCacheKey(category, platform, variant);
+        const cachePath = this.getCachePath(key);
+        try {
+            if (fs_1.default.existsSync(cachePath)) {
+                fs_1.default.unlinkSync(cachePath);
+            }
+        }
+        catch {
+            // Ignore deletion errors
+        }
+    }
+    /**
+     * Clear all cached templates
+     */
+    clear() {
+        try {
+            const files = fs_1.default.readdirSync(this.config.directory);
+            for (const file of files) {
+                if (file.endsWith(".cache.json")) {
+                    fs_1.default.unlinkSync(path_1.default.join(this.config.directory, file));
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        let files = 0;
+        let totalSize = 0;
+        let oldestTimestamp = Infinity;
+        try {
+            const entries = fs_1.default.readdirSync(this.config.directory);
+            for (const file of entries) {
+                if (!file.endsWith(".cache.json"))
+                    continue;
+                const filePath = path_1.default.join(this.config.directory, file);
+                const stat = fs_1.default.statSync(filePath);
+                files++;
+                totalSize += stat.size;
+                try {
+                    const content = JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+                    if (content.timestamp < oldestTimestamp) {
+                        oldestTimestamp = content.timestamp;
+                    }
+                }
+                catch {
+                    // Skip invalid cache files
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or can't be read
+        }
+        return {
+            files,
+            totalSize,
+            oldestEntry: oldestTimestamp === Infinity ? null : new Date(oldestTimestamp),
+        };
+    }
+    /**
+     * Get cache directory path
+     */
+    getCacheDirectory() {
+        return this.config.directory;
+    }
+}
+exports.TemplateCache = TemplateCache;
+// Singleton instance
+let cacheInstance = null;
+function getTemplateCache(config) {
+    if (!cacheInstance) {
+        cacheInstance = new TemplateCache(config);
+    }
+    return cacheInstance;
+}
+exports.getTemplateCache = getTemplateCache;

package/bin/templates/cli.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Templates CLI command
+ * Manage template sources, cache, and configuration
+ */
+import { CommandModule } from "yargs";
+type CommandModuleArgs = Record<string, never>;
+declare const templatesCommand: () => CommandModule<CommandModuleArgs, any>;
+export { templatesCommand };

package/bin/templates/cli.js

@@ -0,0 +1,292 @@
+"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 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:
+                    console.log(chalk_1.default.red(`Unknown action: ${action}`));
+                    console.log(chalk_1.default.gray("Run 'expressots templates --help' for usage."));
+            }
+        },
+    };
+};
+exports.templatesCommand = templatesCommand;
+/**
+ * List available templates
+ */
+async function listTemplates(category, platform) {
+    console.log(chalk_1.default.cyan("\n📋 Available Templates\n"));
+    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() {
+    console.log(chalk_1.default.cyan("\n🔄 Updating Templates...\n"));
+    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() {
+    console.log(chalk_1.default.cyan("\n🗑️  Clearing Template Cache...\n"));
+    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();
+        console.log(chalk_1.default.cyan("\n📦 Template Repository Configuration\n"));
+        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;