@salte-common/terraflow 0.1.0-alpha.1

package/dist/core/backend-state.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Backend state management
+ * Stores previous backend configuration to detect migrations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBackendState = loadBackendState;
+exports.saveBackendState = saveBackendState;
+exports.detectBackendMigration = detectBackendMigration;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Get the backend state file path
+ * @param workingDir - Working directory
+ * @returns Path to state file
+ */
+function getStateFilePath(workingDir) {
+    const stateDir = (0, path_1.join)(workingDir, '.terraflow');
+    if (!(0, fs_1.existsSync)(stateDir)) {
+        (0, fs_1.mkdirSync)(stateDir, { recursive: true });
+    }
+    return (0, path_1.join)(stateDir, 'state.json');
+}
+/**
+ * Load previous backend state
+ * @param workingDir - Working directory
+ * @returns Previous backend configuration or null
+ */
+function loadBackendState(workingDir) {
+    const statePath = getStateFilePath(workingDir);
+    if (!(0, fs_1.existsSync)(statePath)) {
+        return null;
+    }
+    try {
+        const stateContent = (0, fs_1.readFileSync)(statePath, 'utf8');
+        const state = JSON.parse(stateContent);
+        return state.backend || null;
+    }
+    catch (error) {
+        // If state file is invalid, treat as no previous state
+        return null;
+    }
+}
+/**
+ * Save backend state
+ * @param workingDir - Working directory
+ * @param backend - Backend configuration to save
+ */
+function saveBackendState(workingDir, backend) {
+    const statePath = getStateFilePath(workingDir);
+    const state = {
+        backend,
+        lastUpdated: new Date().toISOString(),
+    };
+    (0, fs_1.writeFileSync)(statePath, JSON.stringify(state, null, 2), 'utf8');
+}
+/**
+ * Detect if backend has changed
+ * @param workingDir - Working directory
+ * @param currentBackend - Current backend configuration
+ * @returns Previous backend type if changed, null otherwise
+ */
+function detectBackendMigration(workingDir, currentBackend) {
+    const previousBackend = loadBackendState(workingDir);
+    if (!previousBackend) {
+        // No previous state, this is first run
+        return null;
+    }
+    // Compare backend types
+    if (previousBackend.type !== currentBackend.type) {
+        return previousBackend.type;
+    }
+    // Backend types are the same, but config might have changed
+    // For now, we only detect type changes
+    return null;
+}
+//# sourceMappingURL=backend-state.js.map

package/dist/core/config.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Configuration manager
+ * Loads and merges configuration from multiple sources
+ * Hierarchy: CLI > Env > Config File > Computed Defaults > Hard-coded Defaults
+ */
+import type { TerraflowConfig } from '../types/config';
+export interface CliOptions {
+    config?: string;
+    workspace?: string;
+    backend?: string;
+    secrets?: string;
+    skipCommitCheck?: boolean;
+    workingDir?: string;
+    assumeRole?: string;
+    verbose?: boolean;
+    debug?: boolean;
+    dryRun?: boolean;
+    noColor?: boolean;
+}
+/**
+ * Configuration manager for Terraflow
+ * Handles loading and merging configuration from multiple sources
+ */
+export declare class ConfigManager {
+    /**
+     * Load and merge configuration from CLI args, env vars, and config file
+     * @param cliOptions - Command line options
+     * @param cwd - Current working directory
+     * @returns Merged configuration
+     */
+    static load(cliOptions?: CliOptions, cwd?: string): Promise<TerraflowConfig>;
+    /**
+     * Get the config file path
+     * @param cliOptions - CLI options
+     * @param cwd - Current working directory
+     * @returns Path to config file
+     */
+    private static getConfigFilePath;
+    /**
+     * Load configuration from file
+     * @param configPath - Path to config file
+     * @returns Configuration object or empty object if file doesn't exist
+     */
+    private static loadConfigFile;
+    /**
+     * Load configuration from environment variables
+     * @returns Configuration from environment
+     */
+    private static loadFromEnvironment;
+    /**
+     * Convert CLI options to configuration format
+     * @param cliOptions - CLI options
+     * @returns Configuration object
+     */
+    private static cliOptionsToConfig;
+    /**
+     * Parse boolean from string
+     * @param value - String value to parse
+     * @returns Boolean value
+     */
+    private static parseBoolean;
+    /**
+     * Deep merge configuration objects
+     * Later objects override earlier ones
+     * @param configs - Configuration objects to merge (in priority order)
+     * @returns Merged configuration
+     */
+    private static mergeConfigs;
+    /**
+     * Get resolved workspace name from configuration
+     * @param config - Configuration object
+     * @returns Workspace name or undefined
+     */
+    static getWorkspace(config: TerraflowConfig): string | undefined;
+    /**
+     * Get working directory path
+     * @param config - Configuration object
+     * @param cwd - Current working directory
+     * @returns Absolute path to working directory
+     */
+    static getWorkingDir(config: TerraflowConfig, cwd?: string): string;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.js

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * Configuration manager
+ * Loads and merges configuration from multiple sources
+ * Hierarchy: CLI > Env > Config File > Computed Defaults > Hard-coded Defaults
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const logger_1 = require("../utils/logger");
+/**
+ * Configuration manager for Terraflow
+ * Handles loading and merging configuration from multiple sources
+ */
+class ConfigManager {
+    /**
+     * Load and merge configuration from CLI args, env vars, and config file
+     * @param cliOptions - Command line options
+     * @param cwd - Current working directory
+     * @returns Merged configuration
+     */
+    static async load(cliOptions = {}, cwd = process.cwd()) {
+        // Start with hard-coded defaults (lowest priority)
+        const defaults = {
+            workspace: undefined,
+            'working-dir': './terraform',
+            'skip-commit-check': false,
+            backend: {
+                type: 'local',
+            },
+            logging: {
+                level: 'info',
+                terraform_log: false,
+                terraform_log_level: 'TRACE',
+            },
+        };
+        // Load config file (higher priority than defaults)
+        const configFile = ConfigManager.getConfigFilePath(cliOptions, cwd);
+        const fileConfig = ConfigManager.loadConfigFile(configFile);
+        // Load environment variables (higher priority than config file)
+        const envConfig = ConfigManager.loadFromEnvironment();
+        // Merge: defaults < fileConfig < envConfig < cliOptions
+        const merged = ConfigManager.mergeConfigs(defaults, fileConfig, envConfig, ConfigManager.cliOptionsToConfig(cliOptions));
+        return merged;
+    }
+    /**
+     * Get the config file path
+     * @param cliOptions - CLI options
+     * @param cwd - Current working directory
+     * @returns Path to config file
+     */
+    static getConfigFilePath(cliOptions, cwd) {
+        if (cliOptions.config) {
+            return path_1.default.isAbsolute(cliOptions.config)
+                ? cliOptions.config
+                : path_1.default.join(cwd, cliOptions.config);
+        }
+        const envConfig = process.env.TERRAFLOW_CONFIG;
+        if (envConfig) {
+            return path_1.default.isAbsolute(envConfig) ? envConfig : path_1.default.join(cwd, envConfig);
+        }
+        // Default: .tfwconfig.yml in working directory
+        return path_1.default.join(cwd, '.tfwconfig.yml');
+    }
+    /**
+     * Load configuration from file
+     * @param configPath - Path to config file
+     * @returns Configuration object or empty object if file doesn't exist
+     */
+    static loadConfigFile(configPath) {
+        if (!fs_1.default.existsSync(configPath)) {
+            return {};
+        }
+        try {
+            const content = fs_1.default.readFileSync(configPath, 'utf8');
+            const config = js_yaml_1.default.load(content);
+            logger_1.Logger.debug(`Loaded configuration from ${configPath}`);
+            return config || {};
+        }
+        catch (error) {
+            logger_1.Logger.warn(`Failed to load config file ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+            return {};
+        }
+    }
+    /**
+     * Load configuration from environment variables
+     * @returns Configuration from environment
+     */
+    static loadFromEnvironment() {
+        const envConfig = {};
+        if (process.env.TERRAFLOW_WORKSPACE) {
+            envConfig.workspace = process.env.TERRAFLOW_WORKSPACE;
+        }
+        if (process.env.TERRAFLOW_WORKING_DIR) {
+            envConfig['working-dir'] = process.env.TERRAFLOW_WORKING_DIR;
+        }
+        if (process.env.TERRAFLOW_SKIP_COMMIT_CHECK) {
+            envConfig['skip-commit-check'] = ConfigManager.parseBoolean(process.env.TERRAFLOW_SKIP_COMMIT_CHECK);
+        }
+        if (process.env.TERRAFLOW_BACKEND) {
+            envConfig.backend = {
+                type: process.env.TERRAFLOW_BACKEND,
+            };
+        }
+        if (process.env.TERRAFLOW_SECRETS) {
+            envConfig.secrets = {
+                provider: process.env.TERRAFLOW_SECRETS,
+            };
+        }
+        if (process.env.TERRAFLOW_ASSUME_ROLE) {
+            envConfig.auth = {
+                assume_role: {
+                    role_arn: process.env.TERRAFLOW_ASSUME_ROLE,
+                },
+            };
+        }
+        return envConfig;
+    }
+    /**
+     * Convert CLI options to configuration format
+     * @param cliOptions - CLI options
+     * @returns Configuration object
+     */
+    static cliOptionsToConfig(cliOptions) {
+        const config = {};
+        if (cliOptions.workspace !== undefined) {
+            config.workspace = cliOptions.workspace;
+        }
+        if (cliOptions.workingDir !== undefined) {
+            config['working-dir'] = cliOptions.workingDir;
+        }
+        if (cliOptions.skipCommitCheck !== undefined) {
+            config['skip-commit-check'] = cliOptions.skipCommitCheck;
+        }
+        if (cliOptions.backend !== undefined) {
+            config.backend = {
+                type: cliOptions.backend,
+            };
+        }
+        if (cliOptions.secrets !== undefined) {
+            config.secrets = {
+                provider: cliOptions.secrets,
+            };
+        }
+        if (cliOptions.assumeRole !== undefined) {
+            config.auth = {
+                assume_role: {
+                    role_arn: cliOptions.assumeRole,
+                },
+            };
+        }
+        if (cliOptions.verbose || cliOptions.debug) {
+            config.logging = {
+                level: cliOptions.debug ? 'debug' : 'info',
+            };
+        }
+        if (cliOptions.noColor !== undefined) {
+            // no-color is handled by Logger, not config
+        }
+        return config;
+    }
+    /**
+     * Parse boolean from string
+     * @param value - String value to parse
+     * @returns Boolean value
+     */
+    static parseBoolean(value) {
+        const normalized = value.toLowerCase().trim();
+        return normalized === 'true' || normalized === '1' || normalized === 'yes';
+    }
+    /**
+     * Deep merge configuration objects
+     * Later objects override earlier ones
+     * @param configs - Configuration objects to merge (in priority order)
+     * @returns Merged configuration
+     */
+    static mergeConfigs(...configs) {
+        const result = {};
+        for (const config of configs) {
+            if (!config || typeof config !== 'object') {
+                continue;
+            }
+            // Merge workspace
+            if (config.workspace !== undefined) {
+                result.workspace = config.workspace;
+            }
+            // Merge working-dir
+            if (config['working-dir'] !== undefined) {
+                result['working-dir'] = config['working-dir'];
+            }
+            // Merge skip-commit-check
+            if (config['skip-commit-check'] !== undefined) {
+                result['skip-commit-check'] = config['skip-commit-check'];
+            }
+            // Merge backend
+            if (config.backend) {
+                result.backend = {
+                    ...(result.backend || {}),
+                    ...config.backend,
+                    config: {
+                        ...(result.backend?.config || {}),
+                        ...(config.backend.config || {}),
+                    },
+                };
+            }
+            // Merge secrets
+            if (config.secrets) {
+                result.secrets = {
+                    ...(result.secrets || {}),
+                    ...config.secrets,
+                    config: {
+                        ...(result.secrets?.config || {}),
+                        ...(config.secrets.config || {}),
+                    },
+                };
+            }
+            // Merge auth
+            if (config.auth) {
+                result.auth = {
+                    ...(result.auth || {}),
+                    ...config.auth,
+                    assume_role: config.auth.assume_role
+                        ? {
+                            ...(result.auth?.assume_role || {}),
+                            ...config.auth.assume_role,
+                        }
+                        : result.auth?.assume_role,
+                    service_principal: config.auth.service_principal
+                        ? {
+                            ...(result.auth?.service_principal || {}),
+                            ...config.auth.service_principal,
+                        }
+                        : result.auth?.service_principal,
+                    service_account: config.auth.service_account
+                        ? {
+                            ...(result.auth?.service_account || {}),
+                            ...config.auth.service_account,
+                        }
+                        : result.auth?.service_account,
+                };
+            }
+            // Merge variables
+            if (config.variables) {
+                result.variables = {
+                    ...(result.variables || {}),
+                    ...config.variables,
+                };
+            }
+            // Merge validations
+            if (config.validations) {
+                result.validations = {
+                    ...(result.validations || {}),
+                    ...config.validations,
+                };
+            }
+            // Merge logging
+            if (config.logging) {
+                result.logging = {
+                    ...(result.logging || {}),
+                    ...config.logging,
+                };
+            }
+            // Merge workspace_strategy
+            if (config.workspace_strategy) {
+                result.workspace_strategy = config.workspace_strategy;
+            }
+        }
+        return result;
+    }
+    /**
+     * Get resolved workspace name from configuration
+     * @param config - Configuration object
+     * @returns Workspace name or undefined
+     */
+    static getWorkspace(config) {
+        return config.workspace;
+    }
+    /**
+     * Get working directory path
+     * @param config - Configuration object
+     * @param cwd - Current working directory
+     * @returns Absolute path to working directory
+     */
+    static getWorkingDir(config, cwd = process.cwd()) {
+        const workingDir = config['working-dir'] || './terraform';
+        return path_1.default.isAbsolute(workingDir) ? workingDir : path_1.default.join(cwd, workingDir);
+    }
+}
+exports.ConfigManager = ConfigManager;
+//# sourceMappingURL=config.js.map

package/dist/core/context.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Execution context builder
+ * Builds execution context from environment and configuration
+ */
+import type { ExecutionContext } from '../types/context';
+import type { TerraflowConfig } from '../types/config';
+/**
+ * Execution context builder for Terraflow
+ * Collects runtime state for command execution
+ */
+export declare class ContextBuilder {
+    /**
+     * Build execution context from configuration and environment
+     * @param config - Terraflow configuration
+     * @param cwd - Current working directory
+     * @returns Execution context
+     */
+    static build(config: TerraflowConfig, cwd?: string): Promise<ExecutionContext>;
+    /**
+     * Derive workspace name following priority strategy:
+     * 1. CLI parameter (--workspace)
+     * 2. Environment variable (TERRAFLOW_WORKSPACE)
+     * 3. Git tag (if on a tag)
+     * 4. Git branch (if not ephemeral)
+     * 5. Hostname
+     * @param config - Terraflow configuration
+     * @param cwd - Current working directory
+     * @returns Derived workspace name
+     */
+    private static deriveWorkspace;
+    /**
+     * Build cloud provider information
+     * @returns Cloud information
+     */
+    private static buildCloudInfo;
+    /**
+     * Build VCS information
+     * @param cwd - Current working directory
+     * @returns VCS information
+     */
+    private static buildVcsInfo;
+    /**
+     * Build template variables for config resolution
+     * @param cloud - Cloud information
+     * @param vcs - VCS information
+     * @param hostname - Machine hostname
+     * @param workspace - Workspace name
+     * @returns Template variables
+     */
+    private static buildTemplateVars;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/core/context.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Execution context builder
+ * Builds execution context from environment and configuration
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextBuilder = void 0;
+const os_1 = __importDefault(require("os"));
+const config_1 = require("./config");
+const git_1 = require("../utils/git");
+/**
+ * Execution context builder for Terraflow
+ * Collects runtime state for command execution
+ */
+class ContextBuilder {
+    /**
+     * Build execution context from configuration and environment
+     * @param config - Terraflow configuration
+     * @param cwd - Current working directory
+     * @returns Execution context
+     */
+    static async build(config, cwd = process.cwd()) {
+        const workspace = await ContextBuilder.deriveWorkspace(config, cwd);
+        const workingDir = config_1.ConfigManager.getWorkingDir(config, cwd);
+        const cloud = await ContextBuilder.buildCloudInfo();
+        const vcs = await ContextBuilder.buildVcsInfo(cwd);
+        const hostname = os_1.default.hostname();
+        // Build template variables from environment and context
+        const templateVars = ContextBuilder.buildTemplateVars(cloud, vcs, hostname, workspace);
+        // Build environment variables (sanitized, no secrets)
+        const env = {};
+        for (const key in process.env) {
+            if (Object.prototype.hasOwnProperty.call(process.env, key)) {
+                const value = process.env[key];
+                if (value !== undefined) {
+                    env[key] = value;
+                }
+            }
+        }
+        return {
+            workspace,
+            workingDir,
+            cloud,
+            vcs,
+            hostname,
+            env,
+            templateVars,
+        };
+    }
+    /**
+     * Derive workspace name following priority strategy:
+     * 1. CLI parameter (--workspace)
+     * 2. Environment variable (TERRAFLOW_WORKSPACE)
+     * 3. Git tag (if on a tag)
+     * 4. Git branch (if not ephemeral)
+     * 5. Hostname
+     * @param config - Terraflow configuration
+     * @param cwd - Current working directory
+     * @returns Derived workspace name
+     */
+    static async deriveWorkspace(config, cwd) {
+        // 1. CLI parameter (highest priority) - already in config via ConfigManager
+        const cliWorkspace = config_1.ConfigManager.getWorkspace(config);
+        if (cliWorkspace) {
+            return git_1.GitUtils.sanitizeWorkspaceName(cliWorkspace);
+        }
+        // 2. Environment variable
+        const envWorkspace = process.env.TERRAFLOW_WORKSPACE;
+        if (envWorkspace) {
+            return git_1.GitUtils.sanitizeWorkspaceName(envWorkspace);
+        }
+        // Check if workspace_strategy is specified in config
+        const strategy = config.workspace_strategy || ['cli', 'env', 'tag', 'branch', 'hostname'];
+        // 3. Git tag (if on a tag)
+        if (strategy.includes('tag')) {
+            const tag = await git_1.GitUtils.getTag(cwd);
+            if (tag) {
+                return git_1.GitUtils.sanitizeWorkspaceName(tag);
+            }
+        }
+        // 4. Git branch (if not ephemeral)
+        if (strategy.includes('branch')) {
+            const branch = await git_1.GitUtils.getBranch(cwd);
+            if (branch && !git_1.GitUtils.isEphemeralBranch(branch)) {
+                return git_1.GitUtils.sanitizeWorkspaceName(branch);
+            }
+        }
+        // 5. Hostname (fallback)
+        if (strategy.includes('hostname')) {
+            const hostname = os_1.default.hostname();
+            return git_1.GitUtils.sanitizeWorkspaceName(hostname);
+        }
+        // Final fallback
+        return 'default';
+    }
+    /**
+     * Build cloud provider information
+     * @returns Cloud information
+     */
+    static async buildCloudInfo() {
+        // TODO: Implement cloud detection (AWS, Azure, GCP)
+        // For now, return default
+        return {
+            provider: 'none',
+        };
+    }
+    /**
+     * Build VCS information
+     * @param cwd - Current working directory
+     * @returns VCS information
+     */
+    static async buildVcsInfo(cwd = process.cwd()) {
+        if (!git_1.GitUtils.isGitRepository(cwd)) {
+            return {};
+        }
+        const branch = await git_1.GitUtils.getBranch(cwd);
+        const tag = await git_1.GitUtils.getTag(cwd);
+        const commitSha = await git_1.GitUtils.getCommitSha(cwd);
+        const shortSha = commitSha ? commitSha.substring(0, 7) : await git_1.GitUtils.getShortSha(cwd);
+        const isClean = await git_1.GitUtils.isClean(cwd);
+        const githubRepository = await git_1.GitUtils.getGithubRepository(cwd);
+        const gitlabProjectPath = await git_1.GitUtils.getGitlabProjectPath(cwd);
+        return {
+            branch,
+            tag,
+            commitSha,
+            shortSha,
+            isClean,
+            githubRepository,
+            gitlabProjectPath,
+        };
+    }
+    /**
+     * Build template variables for config resolution
+     * @param cloud - Cloud information
+     * @param vcs - VCS information
+     * @param hostname - Machine hostname
+     * @param workspace - Workspace name
+     * @returns Template variables
+     */
+    static buildTemplateVars(cloud, vcs, hostname, workspace) {
+        const vars = {
+            HOSTNAME: hostname,
+            WORKSPACE: workspace,
+        };
+        // Add all environment variables
+        for (const key in process.env) {
+            if (Object.prototype.hasOwnProperty.call(process.env, key)) {
+                const value = process.env[key];
+                if (value !== undefined) {
+                    vars[key] = value;
+                }
+            }
+        }
+        // Add cloud-specific variables
+        if (cloud.awsAccountId) {
+            vars.AWS_ACCOUNT_ID = cloud.awsAccountId;
+        }
+        if (cloud.awsRegion) {
+            vars.AWS_REGION = cloud.awsRegion;
+        }
+        if (cloud.azureSubscriptionId) {
+            vars.AZURE_SUBSCRIPTION_ID = cloud.azureSubscriptionId;
+        }
+        if (cloud.gcpProjectId) {
+            vars.GCP_PROJECT_ID = cloud.gcpProjectId;
+        }
+        // Add VCS-specific variables
+        if (vcs.branch) {
+            vars.GIT_BRANCH = vcs.branch;
+        }
+        if (vcs.tag) {
+            vars.GIT_TAG = vcs.tag;
+        }
+        if (vcs.commitSha) {
+            vars.GIT_COMMIT_SHA = vcs.commitSha;
+            vars.GIT_SHORT_SHA = vcs.shortSha || vcs.commitSha.substring(0, 7);
+        }
+        if (vcs.githubRepository) {
+            vars.GITHUB_REPOSITORY = vcs.githubRepository;
+        }
+        if (vcs.gitlabProjectPath) {
+            vars.GITLAB_PROJECT_PATH = vcs.gitlabProjectPath;
+        }
+        return vars;
+    }
+}
+exports.ContextBuilder = ContextBuilder;
+//# sourceMappingURL=context.js.map