strata-cli 0.1.0.beta

data/lib/strata/cli/utils/deployment_monitor.rb

@@ -0,0 +1,445 @@
+# frozen_string_literal: true
+
+require_relative "../helpers/color_helper"
+require_relative "../terminal"
+require "tty-spinner"
+require "pastel"
+
+module Strata
+  module CLI
+    module Utils
+      # Monitors deployment progress by polling the API and displaying stage updates
+      # with animated spinners that transition to checkmarks as stages complete.
+
+      class DeploymentMonitor
+        include Terminal
+
+        # Terminal statuses that indicate deployment is complete
+        TERMINAL_STATUSES = ["succeeded", "failed"].freeze
+        NOT_STARTED_STAGE = "not_started"
+        DEFAULT_POLL_INTERVAL = 0.5 # seconds
+        DEFAULT_TIMEOUT = 600 # seconds (10 minutes)
+        TEST_WAIT_TIMEOUT = 5 # seconds
+        STAGES = [
+          :not_started,
+          :preparing,
+          :pre_migrations,
+          :project_configuration,
+          :processing_datasources,
+          :processing_models,
+          :removing_deleted_models,
+          :processing_relationships,
+          :forming_universes,
+          :creating_blend_paths,
+          :validating_references,
+          :post_migrations,
+          :cleaning_up,
+          :finished
+        ].freeze
+        TESTING_STAGE = :running_tests
+
+        # Initialize a new DeploymentMonitor
+        #
+        # @param client [API::Client] The API client for fetching deployment status
+        # @param project_id [String] The project identifier
+        # @param branch_id [String] The branch identifier
+        # @param deployment_id [String, Integer] The deployment identifier
+        # @param has_tests [Boolean, nil] Whether tests exist for this deployment
+        # @raise [ArgumentError] if required parameters are nil or empty
+        def initialize(client, project_id, branch_id, deployment_id, has_tests: nil)
+          validate_initialization_params(client, project_id, branch_id, deployment_id)
+
+          @client = client
+          @project_id = project_id
+          @branch_id = branch_id
+          @deployment_id = deployment_id
+          @has_tests = has_tests
+          @spinners = {}
+          @completed_stages = Set.new
+          @seen_stages = []
+          @last_stage = nil
+          @tests_running = false
+          @deployment_completed = false
+        end
+
+        # Start monitoring deployment progress by polling the API
+        #
+        # @param poll_interval [Integer] Seconds between API polls (default: 2)
+        # @param timeout [Integer] Maximum seconds to monitor before timing out (default: 600)
+        # @param skip_initial_display [Boolean] Skip initial status messages (used when called after display_status)
+        # @return [Hash, nil] The final deployment hash, or nil if interrupted/errored
+        def start(poll_interval: DEFAULT_POLL_INTERVAL, timeout: DEFAULT_TIMEOUT, skip_initial_display: false)
+          unless skip_initial_display
+            display_initial_status
+            display_exit_instruction
+          end
+
+          start_time = Time.now
+
+          loop do
+            deployment = fetch_deployment_status
+
+            break if deployment.nil?
+
+            status = deployment_value(deployment, "status")
+            stage = deployment_value(deployment, "stage")
+
+            unless terminal_status?(status)
+              if @last_stage.nil? && stage
+                process_deployment_state(deployment)
+              elsif stage && stage != @last_stage
+                handle_stage_change(stage, status)
+              end
+            end
+
+            if terminal_status?(status) && !@deployment_completed
+              result = handle_deployment_completion(deployment, status, stage)
+              @deployment_completed = true
+              return result if result
+            end
+
+            if @deployment_completed && status == "succeeded" && stage == "finished"
+              latest_test_run = deployment_value(deployment, "latest_test_run")
+
+              if @has_tests == true && latest_test_run.nil?
+                start_stage_spinner(TESTING_STAGE) unless @tests_running
+                @tests_running = true
+              elsif latest_test_run
+                complete_stage(TESTING_STAGE) if @tests_running
+                @tests_running = false
+                test_results = deployment_value(latest_test_run, "test_results")
+                display_test_results(test_results) if test_results
+                return deployment
+              else
+                return deployment
+              end
+            end
+
+            if Time.now - start_time > timeout
+              complete_stage(TESTING_STAGE) if @tests_running
+              say "\n  Monitoring timeout reached (#{timeout}s)", ColorHelper.warning
+              say "   Deployment may still be in progress. Check server for status.\n", ColorHelper.info
+              return deployment
+            end
+
+            sleep(poll_interval)
+          end
+        rescue Interrupt
+          stop_all_spinners
+          say "\n\n  Monitoring interrupted. Deployment continues in background.", ColorHelper.warning
+          say "   Check server for deployment status.\n", ColorHelper.info
+          nil
+        rescue => e
+          stop_all_spinners
+          say "\n Error monitoring deployment: #{e.message}", ColorHelper.error
+          say "   Check server for deployment status.\n", ColorHelper.info
+          nil
+        end
+
+        def display_status
+          deployment = fetch_deployment_status
+          return nil if deployment.nil?
+
+          display_initial_status
+          display_exit_instruction
+
+          process_deployment_state(deployment)
+
+          if terminal_status?(deployment_value(deployment, "status"))
+            display_final_status(deployment)
+          end
+
+          deployment
+        rescue Interrupt
+          stop_all_spinners
+          say "\n\n  Exiting status view.\n", ColorHelper.info
+          nil
+        rescue => e
+          stop_all_spinners
+          say "\n Error fetching deployment status: #{e.message}", ColorHelper.error
+          nil
+        end
+
+        def process_deployment_state(deployment)
+          status = deployment_value(deployment, "status")
+          stage = deployment_value(deployment, "stage")
+
+          return unless stage && stage != NOT_STARTED_STAGE
+
+          process_stage(stage, status, track_seen: false)
+        end
+
+        private
+
+        def say(message, color_helper_result = nil)
+          return $stdout.puts(message) unless color_helper_result
+
+          colored_message = case color_helper_result
+          when Array
+            ColorHelper.pastel.decorate(message, *color_helper_result)
+          when Symbol
+            theme = ColorHelper::THEME[color_helper_result]
+            if theme
+              ColorHelper.pastel.decorate(message, *Array(theme))
+            else
+              begin
+                ColorHelper.pastel.send(color_helper_result, message)
+              rescue NoMethodError
+                message
+              end
+            end
+          else
+            message
+          end
+
+          $stdout.puts(colored_message)
+        end
+
+        def display_initial_status
+          say "\n Monitoring deployment progress...\n", ColorHelper.title
+        end
+
+        def display_exit_instruction
+          say "  Press Ctrl+C to exit monitoring.\n", ColorHelper.dim
+        end
+
+        def fetch_deployment_status
+          @client.get_deployment(@project_id, @branch_id, @deployment_id)
+        rescue Strata::CommandError => e
+          say "\n  Could not fetch deployment status: #{e.message}", ColorHelper.warning
+          nil
+        end
+
+        def handle_stage_change(stage, status = nil)
+          return if stage.nil? || stage == NOT_STARTED_STAGE
+
+          complete_previous_stage(stage.to_s)
+          process_stage(stage, status, track_seen: true)
+        end
+
+        def track_seen_stage(stage_string)
+          @seen_stages << stage_string unless @seen_stages.include?(stage_string)
+        end
+
+        def complete_previous_stage(current_stage_string)
+          return unless @last_stage && @last_stage != current_stage_string
+          return if @last_stage.to_s == NOT_STARTED_STAGE
+
+          complete_stage(@last_stage)
+        end
+
+        def complete_missed_stages(current_stage_string)
+          stage_symbol = current_stage_string.to_sym
+
+          if STAGES.include?(stage_symbol)
+            stages_array = STAGES.map(&:to_s)
+            complete_missed_stages_from_array(stages_array, current_stage_string)
+          else
+            # Fallback to dynamic tracking for unknown stages
+            complete_missed_stages_from_array(@seen_stages, current_stage_string)
+          end
+        end
+
+        def complete_missed_stages_from_array(stages_array, current_stage_string)
+          current_index = stages_array.index(current_stage_string)
+          return unless current_index
+
+          stages_array[0...current_index].each do |prev_stage|
+            next if prev_stage == NOT_STARTED_STAGE
+            next if @completed_stages.include?(prev_stage)
+
+            complete_stage(prev_stage)
+          end
+        end
+
+        def process_stage(stage, status = nil, track_seen: false)
+          stage_string = stage.to_s
+          return if stage_string == NOT_STARTED_STAGE || @completed_stages.include?(stage_string)
+
+          track_seen_stage(stage_string) if track_seen
+          complete_missed_stages(stage_string)
+
+          if status && terminal_status?(status)
+            # Already complete, just show it
+            complete_stage(stage_string)
+          else
+            # In progress, show spinner
+            start_stage_spinner(stage_string) unless @spinners[stage_string]
+          end
+
+          @last_stage = stage
+        end
+
+        def start_stage_spinner(stage_string)
+          return if @spinners[stage_string] # Already started
+
+          stage_name = format_stage_name(stage_string)
+          spinner = create_spinner(stage_name,
+            message_color: :cyan,
+            spinner_color: :cyan,
+            format: :dots,
+            clear: false)
+          spinner.auto_spin
+          @spinners[stage_string] = spinner
+        end
+
+        def complete_stage(stage)
+          stage_string = stage.to_s
+          return if stage_string == NOT_STARTED_STAGE || @completed_stages.include?(stage_string)
+
+          mark_spinner_as_success(stage_string)
+          @completed_stages.add(stage_string)
+        end
+
+        def mark_spinner_as_success(stage_string)
+          if @spinners[stage_string]
+            stop_spinner(stage_string, :success)
+          else
+            # Stage completed before spinner started - show completion directly
+            # This ensures consistent [✔] format for all stages
+            stage_name = format_stage_name(stage_string)
+            spinner = create_spinner(stage_name, message_color: :cyan, spinner_color: :cyan)
+            spinner.success("")
+          end
+        end
+
+        def terminal_status?(status)
+          TERMINAL_STATUSES.include?(status)
+        end
+
+        def display_final_status(deployment)
+          status = deployment_value(deployment, "status")
+          stage = deployment_value(deployment, "stage")
+          error_messages = deployment_value(deployment, "error_messages")
+
+          complete_remaining_stages(stage)
+          mark_final_stage_status(status, stage)
+          display_status_summary(status, stage, error_messages)
+
+          # Display test results for successful deployments, same format as monitor
+          display_test_results_if_available(deployment) if status == "succeeded" && stage == "finished"
+        end
+
+        def complete_remaining_stages(final_stage)
+          final_stage_string = final_stage&.to_s
+          @spinners.each_key do |stage_string|
+            next if stage_string == TESTING_STAGE # Handle test spinner separately
+            complete_stage(stage_string) if stage_string != final_stage_string
+          end
+        end
+
+        def mark_final_stage_status(status, stage)
+          return unless stage
+
+          stage_string = stage.to_s
+
+          case status
+          when "succeeded"
+            complete_stage(stage_string)
+          when "failed"
+            mark_stage_as_failed(stage_string)
+          end
+        end
+
+        def mark_stage_as_failed(stage_string)
+          stop_spinner(stage_string, :error)
+          @completed_stages.add(stage_string)
+        end
+
+        def stop_spinner(stage_string, status = :success)
+          return unless @spinners[stage_string]
+
+          # Pass empty string to avoid duplicate stage name (format already includes it)
+          @spinners[stage_string].send(status, "")
+          @spinners.delete(stage_string)
+        end
+
+        def display_status_summary(status, stage, error_messages)
+          case status
+          when "succeeded"
+            say "\n Deployment completed successfully!", :success
+          when "failed"
+            say "\n Deployment failed!", :error
+            say "   Failed at stage: #{format_stage_name(stage)}", :info
+            display_error_details(error_messages) if error_messages && !error_messages.strip.empty?
+          end
+        end
+
+        def display_error_details(error_messages)
+          say "\n   Error details:", :error
+          error_messages.split("\n").each do |line|
+            say "   #{line}", :error
+          end
+        end
+
+        def display_test_results(test_results, skip_opening_divider: false)
+          require_relative "test_reporter"
+          reporter = Utils::TestReporter.new
+          reporter.display(test_results, skip_opening_divider: skip_opening_divider)
+        end
+
+        def format_stage_name(stage)
+          return "Not Started" unless stage
+
+          stage.to_s.tr("_", " ").split.map(&:capitalize).join(" ")
+        end
+
+        def stop_all_spinners
+          @spinners.each do |_stage_string, spinner|
+            spinner.stop
+          end
+          @spinners.clear
+          @tests_running = false
+        end
+
+        def validate_initialization_params(client, project_id, branch_id, deployment_id)
+          raise ArgumentError, "client cannot be nil" if client.nil?
+          raise ArgumentError, "project_id cannot be nil or empty" if project_id.nil? || project_id.to_s.strip.empty?
+          raise ArgumentError, "branch_id cannot be nil or empty" if branch_id.nil? || branch_id.to_s.strip.empty?
+          raise ArgumentError, "deployment_id cannot be nil or empty" if deployment_id.nil? || deployment_id.to_s.strip.empty?
+        end
+
+        def deployment_value(deployment, key)
+          return nil unless deployment.is_a?(Hash)
+          deployment[key] || deployment[key.to_sym]
+        end
+
+        def handle_deployment_completion(deployment, status, stage)
+          if status == "succeeded" && stage == "finished"
+            complete_remaining_stages(stage)
+            complete_stage(stage)
+
+            error_messages = deployment_value(deployment, "error_messages")
+            display_status_summary(status, stage, error_messages)
+
+            latest_test_run = deployment_value(deployment, "latest_test_run")
+
+            # If tests are expected but not yet available, return nil to continue monitoring
+            return nil if latest_test_run.nil? && @has_tests == true
+
+            display_test_results_if_available(deployment)
+            return deployment
+          else
+            display_final_status(deployment)
+            return deployment
+          end
+          nil
+        end
+
+        def display_test_results_if_available(deployment)
+          latest_test_run = deployment_value(deployment, "latest_test_run")
+          return unless latest_test_run
+
+          test_results = deployment_value(latest_test_run, "test_results")
+          if test_results
+            say "\n" + "=" * 60, :border
+            complete_stage(TESTING_STAGE)
+            display_test_results(test_results, skip_opening_divider: true)
+          else
+            complete_stage(TESTING_STAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/strata/cli/utils/git.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Strata
+  module CLI
+    module Utils
+      module Git
+        module_function
+
+        def validate_commit_hash(commit_hash)
+          return false unless commit_hash.is_a?(String)
+          return false unless commit_hash.match?(/\A[a-f0-9]{7,40}\z/i)
+          true
+        end
+
+        def current_branch
+          return "main" unless git_repo?
+
+          run_git_command("rev-parse", "--abbrev-ref", "HEAD")
+        end
+
+        def commit_info
+          sha = run_git_command("rev-parse", "HEAD")
+          message = run_git_command("log", "-1", "--pretty=%B")
+
+          {
+            sha: sha,
+            message: message || "Manual deployment"
+          }
+        end
+
+        def committer_info
+          name = run_git_command("config", "user.name")
+          email = run_git_command("config", "user.email")
+
+          {
+            name: name || "Unknown",
+            email: email || "unknown@example.com"
+          }
+        end
+
+        def file_modifications
+          diff_output = run_git_command("diff", "--name-status", "HEAD~1")
+          return [] unless diff_output
+
+          modifications = parse_diff_output(diff_output)
+          filter_yml_files(modifications)
+        end
+
+        def changed_files_since(commit_hash)
+          return [] unless git_repo?
+          return [] unless commit_hash
+
+          unless validate_commit_hash(commit_hash)
+            raise Strata::CommandError, "Invalid commit hash format: #{commit_hash.inspect}"
+          end
+
+          # Check if commit exists in repo
+          _, _, status = Open3.capture3("git", "rev-parse", "--verify", "#{commit_hash}^{commit}")
+          return [] unless status.success?
+
+          # Get all changed files since that commit (including added, modified, deleted, renamed)
+          diff_output = run_git_command("diff", "--name-status", commit_hash, "HEAD")
+          return [] unless diff_output
+
+          modifications = parse_diff_output(diff_output)
+          filter_yml_files(modifications)
+        end
+
+        def changed_file_paths_since(commit_hash)
+          return [] unless git_repo?
+          return [] unless commit_hash
+
+          unless validate_commit_hash(commit_hash)
+            raise Strata::CommandError, "Invalid commit hash format: #{commit_hash.inspect}"
+          end
+
+          # Check if commit exists in repo
+          _, _, status = Open3.capture3("git", "rev-parse", "--verify", "#{commit_hash}^{commit}")
+          return [] unless status.success?
+
+          # Get file paths that changed (for added and modified files only, exclude deleted)
+          # --diff-filter=ACMR: Added, Copied, Modified, Renamed (excludes Deleted)
+          diff_output = run_git_command("diff", "--name-status", "--diff-filter=ACMR", commit_hash, "HEAD")
+          return [] unless diff_output
+
+          paths = []
+          diff_output.lines.each do |line|
+            line = line.strip
+            next if line.empty?
+
+            parts = line.split(/\s+/)
+            next if parts.length < 2
+
+            status = parts[0]
+            # For renames (R), parts[1] is old path, parts[2] is new path
+            # For others, parts[1] is the path
+            if status.start_with?("R")
+              # Rename: use the new path
+              paths << parts[2] if parts.length >= 3 && parts[2]
+            elsif parts[1]
+              # Added, Copied, Modified: use the path
+              paths << parts[1]
+            end
+          end
+
+          # Filter to only yml files and return unique paths
+          paths.select { |path| path&.end_with?(".yml", ".yaml") }.uniq
+        end
+
+        def git_repo?
+          File.directory?(".git")
+        end
+
+        def git_remote_url(remote_name = "origin")
+          return nil unless git_repo?
+
+          url = run_git_command("remote", "get-url", remote_name)
+          return nil if url.nil? || url.strip.empty?
+
+          url.strip
+        rescue
+          nil
+        end
+
+        def run_git_command(*args)
+          stdout, _, _ = Open3.capture3("git", *args)
+          stdout&.strip
+        end
+
+        def parse_diff_output(output)
+          output.lines.map do |line|
+            parse_diff_status(line.strip)
+          end.compact
+        end
+
+        def parse_diff_status(line)
+          return nil if line.empty?
+
+          parts = line.split(/\s+/, 2)
+          return nil if parts.length < 2
+
+          status = parts[0]
+          path = parts[1]
+
+          format_file_modification(status, path)
+        end
+
+        def format_file_modification(status, path)
+          case status
+          when /^R(\d+)$/
+            similarity = Regexp.last_match(1)
+            old_path, new_path = path.split(/\s+/, 2)
+            ["R#{similarity}", old_path, new_path]
+          when "A"
+            ["A", path]
+          when "M"
+            ["M", path]
+          when "D"
+            ["D", path]
+          end
+        end
+
+        def filter_yml_files(modifications)
+          modifications.select do |mod|
+            path = mod.is_a?(Array) ? (mod[1] || "") : ""
+            path.end_with?(".yml", ".yaml")
+          end
+        end
+
+        def uncommitted_changes?
+          return false unless git_repo?
+
+          stdout, _, _ = Open3.capture3("git", "status", "--porcelain")
+          !stdout.strip.empty?
+        end
+
+        def fetch_branch(branch_name)
+          return unless git_repo?
+
+          run_git_command("fetch", "origin", branch_name)
+        end
+
+        def check_commit_status(branch_name)
+          return {status: :ok, message: "Not a git repository"} unless git_repo?
+
+          remote_branch = "origin/#{branch_name}"
+
+          # Check if remote branch exists
+          remote_sha, _, remote_status = Open3.capture3("git", "rev-parse", remote_branch)
+          unless remote_status.success?
+            return {status: :ok, message: "Remote branch not found, proceeding with local commit"}
+          end
+
+          remote_sha = remote_sha.strip
+          local_sha = run_git_command("rev-parse", "HEAD")
+
+          # If SHAs are the same, branches are in sync
+          return {status: :same, message: "Local branch is in sync with remote"} if local_sha == remote_sha
+
+          # Check if local is ahead, behind, or diverged
+          # rev-list --left-right shows: > = commits in local not in remote (ahead), < = commits in remote not in local (behind)
+          diff_output, _, _ = Open3.capture3("git", "rev-list", "--left-right", "#{remote_sha}...#{local_sha}")
+
+          ahead_count = diff_output.lines.count { |line| line.start_with?(">") }
+          behind_count = diff_output.lines.count { |line| line.start_with?("<") }
+
+          if ahead_count > 0 && behind_count == 0
+            {status: :ahead, message: "Local branch is #{ahead_count} commit(s) ahead of remote"}
+          elsif ahead_count == 0 && behind_count > 0
+            {status: :behind, message: "Local branch is #{behind_count} commit(s) behind remote"}
+          else
+            {status: :diverged, message: "Local branch has diverged from remote (#{ahead_count} ahead, #{behind_count} behind)"}
+          end
+        end
+
+        def commit_file(file_path, commit_message, project_path = Dir.pwd)
+          return false unless git_repo?
+
+          # Change to project directory for git operations
+          Dir.chdir(project_path) do
+            # Check if file exists
+            return false unless File.exist?(file_path)
+
+            # Check if file has changes (modified, added, or untracked)
+            stdout, _, status = Open3.capture3("git", "status", "--porcelain", file_path)
+            return false unless status.success?
+
+            # If no changes, nothing to commit
+            return false if stdout.strip.empty?
+
+            # Stage the file (handles both modified and untracked files)
+            _, _, add_status = Open3.capture3("git", "add", file_path)
+            return false unless add_status.success?
+
+            # Check if there are actually staged changes to commit
+            # git diff --cached --quiet returns 0 if no changes, 1 if changes exist
+            _, _, diff_status = Open3.capture3("git", "diff", "--cached", "--quiet", file_path)
+            # If success? is true (exitstatus == 0), there are no changes staged
+            return false if diff_status.success?
+
+            # Commit the file
+            _, _, commit_status = Open3.capture3("git", "commit", "-m", commit_message)
+            commit_status.success?
+          end
+        rescue
+          false
+        end
+      end
+    end
+  end
+end