@salte-common/terraflow 0.1.0-alpha.1

package/dist/utils/git.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Git operations utility
+ * Provides git-related functionality for workspace derivation
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitUtils = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Git utilities for workspace derivation and VCS information
+ */
+class GitUtils {
+    /**
+     * Check if current directory is in a git repository
+     * @param cwd - Working directory to check
+     * @returns True if in a git repository
+     */
+    static isGitRepository(cwd = process.cwd()) {
+        const gitDir = path_1.default.join(cwd, '.git');
+        return fs_1.default.existsSync(gitDir) && fs_1.default.statSync(gitDir).isDirectory();
+    }
+    /**
+     * Get current git branch name
+     * @param cwd - Working directory
+     * @returns Branch name or undefined if not in git repo or not on a branch
+     */
+    static async getBranch(cwd = process.cwd()) {
+        if (!GitUtils.isGitRepository(cwd)) {
+            return undefined;
+        }
+        try {
+            const result = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+                cwd,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const branch = result.trim();
+            return branch && branch !== 'HEAD' ? branch : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Get current git tag if HEAD is on a tag
+     * @param cwd - Working directory
+     * @returns Tag name or undefined if not on a tag
+     */
+    static async getTag(cwd = process.cwd()) {
+        if (!GitUtils.isGitRepository(cwd)) {
+            return undefined;
+        }
+        try {
+            const result = (0, child_process_1.execSync)('git describe --exact-match --tags HEAD 2>/dev/null', {
+                cwd,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const tag = result.trim();
+            return tag || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Get git commit SHA (full)
+     * @param cwd - Working directory
+     * @returns Full commit SHA or undefined
+     */
+    static async getCommitSha(cwd = process.cwd()) {
+        if (!GitUtils.isGitRepository(cwd)) {
+            return undefined;
+        }
+        try {
+            const result = (0, child_process_1.execSync)('git rev-parse HEAD', {
+                cwd,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return result.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Get short git commit SHA (7 characters)
+     * @param cwd - Working directory
+     * @returns Short commit SHA or undefined
+     */
+    static async getShortSha(cwd = process.cwd()) {
+        if (!GitUtils.isGitRepository(cwd)) {
+            return undefined;
+        }
+        try {
+            const result = (0, child_process_1.execSync)('git rev-parse --short HEAD', {
+                cwd,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return result.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Check if git working directory is clean (no uncommitted changes)
+     * @param cwd - Working directory
+     * @returns True if working directory is clean
+     */
+    static async isClean(cwd = process.cwd()) {
+        if (!GitUtils.isGitRepository(cwd)) {
+            return true; // Not a git repo, consider it "clean"
+        }
+        try {
+            (0, child_process_1.execSync)('git diff-index --quiet HEAD --', {
+                cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get GitHub repository name from git remote (format: owner/repo)
+     * @param cwd - Working directory
+     * @returns Repository name in format "owner/repo" or undefined
+     */
+    static async getGithubRepository(cwd = process.cwd()) {
+        if (!GitUtils.isGitRepository(cwd)) {
+            return undefined;
+        }
+        try {
+            const result = (0, child_process_1.execSync)('git remote get-url origin', {
+                cwd,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const url = result.trim();
+            return GitUtils.parseGithubUrl(url);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Get GitLab project path from git remote
+     * @param cwd - Working directory
+     * @returns GitLab project path or undefined
+     */
+    static async getGitlabProjectPath(cwd = process.cwd()) {
+        if (!GitUtils.isGitRepository(cwd)) {
+            return undefined;
+        }
+        try {
+            const result = (0, child_process_1.execSync)('git remote get-url origin', {
+                cwd,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const url = result.trim();
+            return GitUtils.parseGitlabUrl(url);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Parse GitHub URL to extract owner/repo
+     * Supports https://, git@, and git:// formats
+     * @param url - Git remote URL
+     * @returns Repository name in format "owner/repo" or undefined
+     */
+    static parseGithubUrl(url) {
+        // Match patterns:
+        // https://github.com/owner/repo.git
+        // https://github.com/owner/repo
+        // git@github.com:owner/repo.git
+        // git@github.com:owner/repo
+        // git://github.com/owner/repo.git
+        const patterns = [
+            /github\.com[/:]([^/]+)\/([^/]+?)(?:\.git)?$/,
+            /github\.com[/:]([^/]+)\/([^/]+?)(?:\.git)?\/?$/,
+        ];
+        for (const pattern of patterns) {
+            const match = url.match(pattern);
+            if (match) {
+                return `${match[1]}/${match[2]}`;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Parse GitLab URL to extract project path
+     * Supports https:// and git@ formats
+     * @param url - Git remote URL
+     * @returns GitLab project path or undefined
+     */
+    static parseGitlabUrl(url) {
+        // Match patterns:
+        // https://gitlab.com/group/subgroup/project.git
+        // https://gitlab.com/group/subgroup/project
+        // git@gitlab.com:group/subgroup/project.git
+        // git@gitlab.com:group/subgroup/project
+        const patterns = [/gitlab\.com[/:](.+?)(?:\.git)?$/, /gitlab\.com[/:](.+?)(?:\.git)?\/?$/];
+        for (const pattern of patterns) {
+            const match = url.match(pattern);
+            if (match) {
+                return match[1];
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Check if a branch name is ephemeral (has a prefix like "feature/")
+     * Uses regex: /^[^/]+\//
+     * @param branchName - Branch name to check
+     * @returns True if branch is ephemeral
+     */
+    static isEphemeralBranch(branchName) {
+        return /^[^/]+\//.test(branchName);
+    }
+    /**
+     * Sanitize workspace name according to spec
+     * - Remove refs/heads/ or refs/tags/ prefix
+     * - Replace invalid characters (/ and spaces) with hyphens
+     * - Result must match /^[a-zA-Z0-9_-]+$/
+     * @param name - Workspace name to sanitize
+     * @returns Sanitized workspace name
+     */
+    static sanitizeWorkspaceName(name) {
+        // Remove refs/heads/ or refs/tags/ prefix
+        let sanitized = name.replace(/^refs\/(heads|tags)\//, '');
+        // Replace invalid characters (/, spaces, dots) with hyphens
+        sanitized = sanitized.replace(/[/\s.]+/g, '-');
+        // Remove any remaining invalid characters (keep only alphanumeric, underscore, hyphen)
+        sanitized = sanitized.replace(/[^a-zA-Z0-9_-]/g, '');
+        // Remove leading/trailing hyphens
+        sanitized = sanitized.replace(/^-+|-+$/g, '');
+        // Ensure it matches the required pattern
+        if (!/^[a-zA-Z0-9_-]+$/.test(sanitized)) {
+            // Fallback to safe default if sanitization fails
+            sanitized = 'default';
+        }
+        return sanitized || 'default';
+    }
+}
+exports.GitUtils = GitUtils;
+//# sourceMappingURL=git.js.map

package/dist/utils/logger.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Logging utilities
+ * Provides structured logging for Terraflow CLI
+ */
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+/**
+ * Logger class for Terraflow CLI
+ * Supports different log levels and colored output
+ */
+export declare class Logger {
+    private static level;
+    private static colorEnabled;
+    /**
+     * Set the log level
+     * @param level - Log level to use
+     */
+    static setLevel(level: LogLevel): void;
+    /**
+     * Enable or disable colored output
+     * @param enabled - Whether to enable colors
+     */
+    static setColor(enabled: boolean): void;
+    /**
+     * Check if a message should be logged at the current level
+     * @param messageLevel - Level of the message
+     * @returns Whether the message should be logged
+     */
+    private static shouldLog;
+    /**
+     * Format a message with color if enabled
+     * @param message - Message to format
+     * @param colorName - Color name (red, yellow, blue, green, gray)
+     * @returns Formatted message
+     */
+    private static format;
+    /**
+     * Log an error message
+     * @param message - Error message
+     * @param args - Additional arguments
+     */
+    static error(message: string, ...args: unknown[]): void;
+    /**
+     * Log a warning message
+     * @param message - Warning message
+     * @param args - Additional arguments
+     */
+    static warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log an info message
+     * @param message - Info message
+     * @param args - Additional arguments
+     */
+    static info(message: string, ...args: unknown[]): void;
+    /**
+     * Log a debug message
+     * @param message - Debug message
+     * @param args - Additional arguments
+     */
+    static debug(message: string, ...args: unknown[]): void;
+    /**
+     * Log a success message (info level with green color)
+     * @param message - Success message
+     * @param args - Additional arguments
+     */
+    static success(message: string, ...args: unknown[]): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Logging utilities
+ * Provides structured logging for Terraflow CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+/**
+ * ANSI color codes for terminal output
+ */
+const Colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    green: '\x1b[32m',
+    gray: '\x1b[90m',
+};
+/**
+ * Logger class for Terraflow CLI
+ * Supports different log levels and colored output
+ */
+class Logger {
+    static level = 'info';
+    static colorEnabled = true;
+    /**
+     * Set the log level
+     * @param level - Log level to use
+     */
+    static setLevel(level) {
+        Logger.level = level;
+    }
+    /**
+     * Enable or disable colored output
+     * @param enabled - Whether to enable colors
+     */
+    static setColor(enabled) {
+        Logger.colorEnabled = enabled;
+    }
+    /**
+     * Check if a message should be logged at the current level
+     * @param messageLevel - Level of the message
+     * @returns Whether the message should be logged
+     */
+    static shouldLog(messageLevel) {
+        const levels = ['error', 'warn', 'info', 'debug'];
+        const currentIndex = levels.indexOf(Logger.level);
+        const messageIndex = levels.indexOf(messageLevel);
+        return messageIndex <= currentIndex;
+    }
+    /**
+     * Format a message with color if enabled
+     * @param message - Message to format
+     * @param colorName - Color name (red, yellow, blue, green, gray)
+     * @returns Formatted message
+     */
+    static format(message, colorName) {
+        if (!Logger.colorEnabled) {
+            return message;
+        }
+        const color = Colors[colorName];
+        return `${color}${message}${Colors.reset}`;
+    }
+    /**
+     * Log an error message
+     * @param message - Error message
+     * @param args - Additional arguments
+     */
+    static error(message, ...args) {
+        if (Logger.shouldLog('error')) {
+            const formatted = Logger.format(message, 'red');
+            console.error(formatted, ...args);
+        }
+    }
+    /**
+     * Log a warning message
+     * @param message - Warning message
+     * @param args - Additional arguments
+     */
+    static warn(message, ...args) {
+        if (Logger.shouldLog('warn')) {
+            const formatted = Logger.format(message, 'yellow');
+            console.warn(formatted, ...args);
+        }
+    }
+    /**
+     * Log an info message
+     * @param message - Info message
+     * @param args - Additional arguments
+     */
+    static info(message, ...args) {
+        if (Logger.shouldLog('info')) {
+            const formatted = Logger.format(message, 'blue');
+            console.info(formatted, ...args);
+        }
+    }
+    /**
+     * Log a debug message
+     * @param message - Debug message
+     * @param args - Additional arguments
+     */
+    static debug(message, ...args) {
+        if (Logger.shouldLog('debug')) {
+            const formatted = Logger.format(message, 'gray');
+            console.debug(formatted, ...args);
+        }
+    }
+    /**
+     * Log a success message (info level with green color)
+     * @param message - Success message
+     * @param args - Additional arguments
+     */
+    static success(message, ...args) {
+        if (Logger.shouldLog('info')) {
+            const formatted = Logger.format(message, 'green');
+            console.info(formatted, ...args);
+        }
+    }
+}
+exports.Logger = Logger;
+//# sourceMappingURL=logger.js.map

package/dist/utils/scaffolding.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Scaffolding utilities for project initialization
+ * Handles template processing and file generation
+ */
+/**
+ * Template processing functions
+ */
+/**
+ * Load a template file from the templates directory
+ * @param templatePath - Path to template file relative to templates directory
+ * @returns Template content as string
+ */
+export declare function loadTemplate(templatePath: string): string;
+/**
+ * Process a template string by replacing variable placeholders
+ * @param template - Template content with placeholders
+ * @param variables - Object mapping variable names to values
+ * @returns Processed template with variables replaced
+ */
+export declare function processTemplate(template: string, variables: Record<string, string>): string;
+/**
+ * File generation functions
+ */
+/**
+ * Generate Terraform files for the project
+ * @param projectDir - Root directory of the project
+ * @param provider - Cloud provider (aws, azure, gcp)
+ * @param projectName - Name of the project
+ */
+export declare function generateTerraformFiles(projectDir: string, provider: string, projectName: string): Promise<void>;
+/**
+ * Generate application files for the project
+ * @param projectDir - Root directory of the project
+ * @param language - Programming language (javascript, typescript, python, go)
+ * @param projectName - Name of the project
+ */
+export declare function generateApplicationFiles(projectDir: string, language: string, projectName: string): Promise<void>;
+/**
+ * Generate configuration files for the project
+ * @param projectDir - Root directory of the project
+ * @param provider - Cloud provider (aws, azure, gcp)
+ * @param language - Programming language (javascript, typescript, python, go)
+ * @param projectName - Name of the project
+ */
+export declare function generateConfigFiles(projectDir: string, provider: string, language: string, projectName: string): Promise<void>;
+/**
+ * Project structure creation
+ */
+/**
+ * Create the complete project directory structure
+ * @param projectDir - Root directory of the project
+ */
+export declare function createProjectStructure(projectDir: string): Promise<void>;
+/**
+ * Validation helpers
+ */
+/**
+ * Validate project name format
+ * @param name - Project name to validate
+ * @returns true if valid, false otherwise
+ */
+export declare function validateProjectName(name: string): boolean;
+/**
+ * Validate cloud provider
+ * @param provider - Provider name to validate
+ * @returns true if valid, false otherwise
+ */
+export declare function validateProvider(provider: string): boolean;
+/**
+ * Validate programming language
+ * @param language - Language name to validate
+ * @returns true if valid, false otherwise
+ */
+export declare function validateLanguage(language: string): boolean;
+/**
+ * Check if a directory is empty
+ * @param dir - Directory path to check
+ * @returns true if directory is empty or doesn't exist, false otherwise
+ */
+export declare function isDirectoryEmpty(dir: string): Promise<boolean>;
+/**
+ * Template variable builder
+ */
+/**
+ * Build template variables object from project parameters
+ * @param projectName - Name of the project
+ * @param provider - Cloud provider (aws, azure, gcp)
+ * @param language - Programming language (javascript, typescript, python, go)
+ * @returns Object with all template variable mappings
+ */
+export declare function buildTemplateVariables(projectName: string, provider: string, _language: string): Record<string, string>;
+//# sourceMappingURL=scaffolding.d.ts.map