makit 0.0.144 → 0.0.145

data/lib/makit/cli/main.rb

@@ -1,69 +1,78 @@
-# frozen_string_literal: true
-
-require "clamp"
-require_relative "repository_commands"
-require_relative "project_commands"
-require_relative "build_commands"
-require_relative "utility_commands"
-require_relative "strategy_commands"
-require_relative "../rake/cli"
-
-module Makit
-  module Cli
-    # Define the main command which includes the consolidated subcommands
-    class MainCommand < Clamp::Command
-      # Add description with overview and examples
-      self.description = <<~DESC
-        Makit - A CI/CD tool for managing development workflows and project setup.
-
-        Available command groups:
-          repository  - Manage git repositories (add, clone, pull, list, remove, import)
-          project     - Manage project creation and setup (new, init, setup, work)
-          build       - Build operations and cleanup (make, clean)
-          utility     - System utilities and maintenance (nuget-cache, system-info)
-          strategy    - Manage execution strategies (show, test)
-          trace       - Manage trace functionality (show, enable, disable, test)
-          timeout     - Manage timeout configuration (show, set, reset, test)
-          rake        - Manage rake tasks
-
-        Common usage examples:
-          # Repository management
-          makit repository clone https://github.com/user/repo
-          makit repository add https://github.com/user/repo
-          makit repository list --details
-          makit repository remove clamp.git
-          makit repository import
-        #{"  "}
-          # Project operations
-          makit project new my-app --type ruby
-          makit project init /path/to/existing/project
-          makit project setup
-          makit project work --editor code
-        #{"  "}
-          # Build operations
-          makit build make                           # Show all repositories and commit IDs
-          makit build make https://github.com/user/repo  # Build specific repository
-          makit build make --target release         # Build current project
-          makit build clean --deep
-        #{"  "}
-          # Utilities
-          makit utility nuget-cache --clear
-          makit utility system-info --tools-only
-      DESC
-
-      option ["-v", "--version"], :flag, "Show version" do
-        puts "makit version #{Makit::VERSION}"
-        exit(0)
-      end
-
-      subcommand "repository", "Manage git repositories", RepositoryCommand
-      subcommand "project", "Manage project creation and setup", ProjectCommand
-      subcommand "build", "Build operations and cleanup", BuildCommand
-      subcommand "utility", "System utilities and maintenance", UtilityCommand
-      subcommand "strategy", "Manage execution strategies", StrategyCommands
-      subcommand "trace", "Manage trace functionality", TraceCommands
-      subcommand "timeout", "Manage timeout configuration", TimeoutCommands
-      subcommand "rake", "Manage rake tasks", Makit::Rake::CliCommand
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "clamp"
+require_relative "repository_commands"
+require_relative "project_commands"
+require_relative "build_commands"
+require_relative "utility_commands"
+require_relative "strategy_commands"
+require_relative "pipeline_commands"
+require_relative "../rake/cli"
+
+module Makit
+  module Cli
+    # Define the main command which includes the consolidated subcommands
+    class MainCommand < Clamp::Command
+      # Add description with overview and examples
+      self.description = <<~DESC
+        Makit - A CI/CD tool for managing development workflows and project setup.
+
+        Available command groups:
+          repository  - Manage git repositories (add, clone, pull, list, remove, import)
+          project     - Manage project creation and setup (new, init, setup, work)
+          build       - Build operations and cleanup (make, clean)
+          pipeline    - GitLab CI pipeline operations (run)
+          utility     - System utilities and maintenance (nuget-cache, system-info)
+          strategy    - Manage execution strategies (show, test)
+          trace       - Manage trace functionality (show, enable, disable, test)
+          timeout     - Manage timeout configuration (show, set, reset, test)
+          rake        - Manage rake tasks
+
+        Common usage examples:
+          # Repository management
+          makit repository clone https://github.com/user/repo
+          makit repository add https://github.com/user/repo
+          makit repository list --details
+          makit repository remove clamp.git
+          makit repository import
+        #{"  "}
+          # Project operations
+          makit project new my-app --type ruby
+          makit project init /path/to/existing/project
+          makit project setup
+          makit project work --editor code
+        #{"  "}
+          # Build operations
+          makit build make                           # Show all repositories and commit IDs
+          makit build make https://github.com/user/repo  # Build specific repository
+          makit build make --target release         # Build current project
+          makit build clean --deep
+        #{"  "}
+          # Pipeline operations
+          makit pipeline run                         # Run .gitlab-ci.yml in current directory
+          makit pipeline run --file custom-ci.yml   # Run custom pipeline file
+          makit pipeline run --dry-run              # Simulate execution
+          makit pipeline run --variables KEY=value  # Pass variables to pipeline
+        #{"  "}
+          # Utilities
+          makit utility nuget-cache --clear
+          makit utility system-info --tools-only
+      DESC
+
+      option ["-v", "--version"], :flag, "Show version" do
+        puts "makit version #{Makit::VERSION}"
+        exit(0)
+      end
+
+      subcommand "repository", "Manage git repositories", RepositoryCommand
+      subcommand "project", "Manage project creation and setup", ProjectCommand
+      subcommand "build", "Build operations and cleanup", BuildCommand
+      subcommand "pipeline", "GitLab CI pipeline operations", PipelineCommand
+      subcommand "utility", "System utilities and maintenance", UtilityCommand
+      subcommand "strategy", "Manage execution strategies", StrategyCommands
+      subcommand "trace", "Manage trace functionality", TraceCommands
+      subcommand "timeout", "Manage timeout configuration", TimeoutCommands
+      subcommand "rake", "Manage rake tasks", Makit::Rake::CliCommand
+    end
+  end
+end

data/lib/makit/cli/pipeline_commands.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require "clamp"
+require "colorize"
+require_relative "../gitlab/pipeline"
+require_relative "../humanize"
+
+module Makit
+  module Cli
+    # Command to run GitLab CI pipelines
+    class PipelineRunCommand < Clamp::Command
+      self.description = <<~DESC
+        Execute a GitLab CI pipeline using Podman containers.
+
+        By default, looks for .gitlab-ci.yml in the current directory.
+        Each job in the pipeline will be executed in a separate Podman container.
+      DESC
+
+      option ["-f", "--file"], "FILE", "Pipeline file to execute", default: ".gitlab-ci.yml"
+      option ["-v", "--variables"], "VARS", "Variables to pass to the pipeline (format: KEY=value,KEY2=value2)"
+      option ["-w", "--working-directory"], "DIR", "Working directory for execution", default: Dir.pwd
+      option ["-p", "--podman-executable"], "EXECUTABLE", "Podman executable path", default: "podman"
+      option ["-d", "--dry-run"], :flag, "Simulate execution without actually running"
+      option ["--verbose"], :flag, "Show detailed output"
+      option ["--no-color"], :flag, "Disable colored output"
+
+      def execute
+        # Disable color if requested
+        String.disable_colorization = true if no_color?
+
+        # Check if pipeline file exists
+        unless File.exist?(file)
+          error "Pipeline file '#{file}' not found"
+          exit(1)
+        end
+
+        # Parse variables
+        variables = parse_variables
+
+        # Load and parse pipeline
+        puts "Loading pipeline from #{file}..." if verbose?
+        begin
+          pipeline_content = File.read(file)
+          pipeline = Makit::Gitlab::Pipeline.parse_yaml(pipeline_content)
+        rescue StandardError => e
+          error "Failed to parse pipeline file: #{e.message}"
+          exit(1)
+        end
+
+        # Validate pipeline
+        validation_result = pipeline.validate
+        unless validation_result[:is_valid]
+          error "Pipeline validation failed:"
+          validation_result[:errors].each { |err| error "  - #{err}" }
+          exit(1)
+        end
+
+        # Show warnings if any
+        if validation_result[:warnings].any?
+          warning "Pipeline warnings:"
+          validation_result[:warnings].each { |warn| warning "  - #{warn}" }
+          puts
+        end
+
+        # Show pipeline info
+        show_pipeline_info(pipeline)
+
+        # Execute pipeline
+        puts "\nExecuting pipeline..." unless dry_run?
+        puts "Dry run mode - no actual execution will occur" if dry_run?
+
+        start_time = Time.now
+        result = pipeline.execute_pipeline(
+          variables: variables,
+          working_directory: working_directory,
+          podman_executable: podman_executable,
+          dry_run: dry_run?
+        )
+        end_time = Time.now
+
+        # Display results
+        display_execution_result(result, start_time, end_time)
+
+        # Exit with appropriate code
+        success = if result.is_a?(Hash)
+          result[:success]
+        else
+          result.success
+        end
+        exit(success ? 0 : 1)
+      end
+
+      private
+
+      def parse_variables
+        return {} unless variables
+
+        vars = {}
+        variables.split(",").each do |var|
+          key, value = var.split("=", 2)
+          if key && value
+            vars[key.strip] = value.strip
+          else
+            error "Invalid variable format: #{var}. Use KEY=value format."
+            exit(1)
+          end
+        end
+        vars
+      end
+
+      def show_pipeline_info(pipeline)
+        puts "Pipeline Information:"
+        puts "  Image: #{pipeline.pipeline_data.image}" unless pipeline.pipeline_data.image.empty?
+        puts "  Stages: #{pipeline.pipeline_data.stages.map(&:name).join(', ')}"
+        puts "  Jobs: #{pipeline.pipeline_data.jobs.keys.join(', ')}"
+        puts "  Variables: #{pipeline.pipeline_data.variables.keys.join(', ')}" unless pipeline.pipeline_data.variables.empty?
+        puts
+      end
+
+      def display_execution_result(result, start_time, end_time)
+        puts "\n" + "="*60
+        puts "PIPELINE EXECUTION RESULT".center(60)
+        puts "="*60
+
+        # Extract result data based on mode
+        if result.is_a?(Hash)
+          # Fallback mode
+          execution_result = result[:result]
+          success = result[:success]
+          errors = result[:errors] || []
+          warnings = result[:warnings] || []
+        else
+          # gRPC mode
+          execution_result = result.result
+          success = result.success
+          errors = result.errors || []
+          warnings = result.warnings || []
+        end
+
+        # Overall status
+        status_color = success ? :green : :red
+        status_icon = success ? "✓" : "✗"
+        puts "#{status_icon} Status: #{success ? 'SUCCESS' : 'FAILED'}".colorize(status_color)
+        
+        # Access execution result fields safely
+        execution_id = if execution_result.respond_to?(:execution_id)
+          execution_result.execution_id
+        else
+          execution_result[:execution_id]
+        end
+        
+        started_at = if execution_result.respond_to?(:started_at)
+          execution_result.started_at
+        else
+          execution_result[:started_at]
+        end
+        
+        finished_at = if execution_result.respond_to?(:finished_at)
+          execution_result.finished_at
+        else
+          execution_result[:finished_at]
+        end
+        
+        puts "  Execution ID: #{execution_id}"
+        puts "  Started: #{started_at}"
+        puts "  Finished: #{finished_at}" if finished_at
+        puts "  Duration: #{Makit::Humanize.get_humanized_duration(end_time - start_time)}"
+
+        # Podman info
+        podman_version = if execution_result.respond_to?(:podman_version)
+          execution_result.podman_version
+        else
+          execution_result[:podman_version]
+        end
+        
+        execution_host = if execution_result.respond_to?(:execution_host)
+          execution_result.execution_host
+        else
+          execution_result[:execution_host]
+        end
+        
+        puts "  Podman Version: #{podman_version}" if podman_version
+        puts "  Host: #{execution_host}" if execution_host
+
+        # Job results
+        job_results = if execution_result.respond_to?(:job_results)
+          execution_result.job_results
+        else
+          execution_result[:job_results]
+        end
+        
+        if job_results && job_results.any?
+          puts "\nJob Results:"
+          job_results.each do |job_result|
+            display_job_result(job_result)
+          end
+        end
+
+        # Errors
+        if errors.any?
+          puts "\nErrors:".colorize(:red)
+          errors.each { |err| puts "  ✗ #{err}".colorize(:red) }
+        end
+
+        # Warnings
+        if warnings.any?
+          puts "\nWarnings:".colorize(:yellow)
+          warnings.each { |warn| puts "  ⚠ #{warn}".colorize(:yellow) }
+        end
+
+        # Logs
+        logs = if execution_result.respond_to?(:logs)
+          execution_result.logs
+        else
+          execution_result[:logs]
+        end
+        
+        if logs && logs.any? && verbose?
+          puts "\nExecution Logs:"
+          logs.each { |log| puts "  #{log}" }
+        end
+
+        puts "="*60
+      end
+
+      def display_job_result(job_result)
+        # Extract job data based on mode
+        if job_result.is_a?(Hash)
+          job_name = job_result[:job_name]
+          status = job_result[:status]
+          exit_code = job_result[:exit_code]
+          started_at = job_result[:started_at]
+          finished_at = job_result[:finished_at]
+          logs = job_result[:logs] || []
+          errors = job_result[:errors] || []
+          stdout = job_result[:stdout] || ""
+          stderr = job_result[:stderr] || ""
+        else
+          job_name = job_result.job_name
+          status = job_result.status
+          exit_code = job_result.exit_code
+          started_at = job_result.started_at
+          finished_at = job_result.finished_at
+          logs = job_result.logs || []
+          errors = job_result.errors || []
+          stdout = job_result.respond_to?(:stdout) ? job_result.stdout : ""
+          stderr = job_result.respond_to?(:stderr) ? job_result.stderr : ""
+        end
+
+        # Job status
+        status_color = (status == :success || status.to_s.include?('SUCCESS')) ? :green : :red
+        status_icon = (status == :success || status.to_s.include?('SUCCESS')) ? "✓" : "✗"
+        
+        puts "  #{status_icon} #{job_name}: #{status.to_s.upcase}".colorize(status_color)
+        puts "    Exit Code: #{exit_code}" if exit_code
+        puts "    Started: #{started_at}"
+        puts "    Finished: #{finished_at}" if finished_at
+
+        # Job errors
+        if errors.any?
+          puts "    Errors:".colorize(:red)
+          errors.each { |err| puts "      ✗ #{err}".colorize(:red) }
+        end
+
+        # Job logs (if verbose)
+        if logs.any? && verbose?
+          puts "    Logs:"
+          logs.each { |log| puts "      #{log}" }
+        end
+
+        # Job stdout (if verbose and not empty)
+        if stdout && !stdout.empty? && verbose?
+          puts "    Stdout:".colorize(:green)
+          stdout.split("\n").each { |line| puts "      #{line}".colorize(:green) }
+        end
+
+        # Job stderr (if verbose and not empty)
+        if stderr && !stderr.empty? && verbose?
+          puts "    Stderr:".colorize(:red)
+          stderr.split("\n").each { |line| puts "      #{line}".colorize(:red) }
+        end
+      end
+
+      def error(message)
+        puts "Error: #{message}".colorize(:red)
+      end
+
+      def warning(message)
+        puts "Warning: #{message}".colorize(:yellow)
+      end
+    end
+
+    # Pipeline command group for GitLab CI pipeline operations
+    class PipelineCommand < Clamp::Command
+      self.description = <<~DESC
+        GitLab CI Pipeline operations.
+
+        Available commands:
+          run  - Execute a GitLab CI pipeline using Podman
+
+        Examples:
+          makit pipeline run                           # Run .gitlab-ci.yml in current directory
+          makit pipeline run --file custom-ci.yml     # Run custom pipeline file
+          makit pipeline run --dry-run                # Simulate execution without running
+          makit pipeline run --variables KEY=value    # Pass variables to pipeline
+      DESC
+
+      subcommand "run", "Execute a GitLab CI pipeline", PipelineRunCommand
+    end
+  end
+end