makit 0.0.144 → 0.0.145

data/lib/makit/gitlab/pipeline.rb

@@ -0,0 +1,857 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "json"
+
+module Makit
+  module Gitlab
+    # Ruby wrapper for GitLab Pipeline operations
+    # Provides a convenient interface for working with GitLab CI pipelines
+    class Pipeline
+      attr_accessor :pipeline_data
+
+      def initialize(yaml_content = nil)
+        if yaml_content
+          @pipeline_data = parse_yaml(yaml_content)
+        else
+          @pipeline_data = create_empty_pipeline
+        end
+      end
+
+      # Parse GitLab CI YAML content
+      def self.parse_yaml(yaml_content)
+        new(yaml_content)
+      end
+
+      # Parse GitLab CI YAML from file
+      def self.parse_file(file_path)
+        content = File.read(file_path)
+        new(content)
+      end
+
+      # Convert pipeline to YAML
+      def to_yaml(pretty_format = true)
+        if defined?(Gitlab::Pipeline::PipelineService) && @grpc_available
+          # Use gRPC service if available
+          service = PipelineServiceImpl.new
+          request = Gitlab::Pipeline::ToYamlRequest.new(
+            pipeline: @pipeline_data,
+            pretty_format: pretty_format,
+            indent_size: 2
+          )
+          response = service.to_yaml(request, nil)
+          response.yaml_content
+        else
+          # Fallback implementation
+          convert_pipeline_to_yaml(@pipeline_data, pretty_format)
+        end
+      end
+
+      # Validate pipeline
+      def validate
+        if defined?(Gitlab::Pipeline::PipelineService) && @grpc_available
+          # Use gRPC service if available
+          service = PipelineServiceImpl.new
+          request = Gitlab::Pipeline::ValidatePipelineRequest.new(
+            pipeline: @pipeline_data,
+            check_gitlab_compatibility: true
+          )
+          response = service.validate_pipeline(request, nil)
+          {
+            is_valid: response.is_valid,
+            errors: response.errors.to_a,
+            warnings: response.warnings.to_a,
+            suggestions: response.suggestions.to_a
+          }
+        else
+          # Fallback implementation
+          validate_pipeline_fallback
+        end
+      end
+
+      # Get pipeline statistics
+      def stats
+        if defined?(Gitlab::Pipeline::PipelineService) && @grpc_available
+          # Use gRPC service if available
+          service = PipelineServiceImpl.new
+          request = Gitlab::Pipeline::GetPipelineStatsRequest.new(pipeline: @pipeline_data)
+          response = service.get_pipeline_stats(request, nil)
+          {
+            total_jobs: response.total_jobs,
+            total_stages: response.total_stages,
+            total_artifacts: response.total_artifacts,
+            total_services: response.total_services,
+            total_variables: response.total_variables,
+            stage_names: response.stage_names.to_a,
+            job_names: response.job_names.to_a
+          }
+        else
+          # Fallback implementation
+          calculate_stats_fallback
+        end
+      end
+
+      # Compare with another pipeline
+      def compare(other_pipeline)
+        if defined?(Gitlab::Pipeline::PipelineService) && @grpc_available
+          # Use gRPC service if available
+          service = PipelineServiceImpl.new
+          request = Gitlab::Pipeline::ComparePipelinesRequest.new(
+            pipeline1: @pipeline_data,
+            pipeline2: other_pipeline.pipeline_data
+          )
+          response = service.compare_pipelines(request, nil)
+          {
+            are_identical: response.are_identical,
+            differences: response.differences.to_a,
+            added_jobs: response.added_jobs.to_a,
+            removed_jobs: response.removed_jobs.to_a,
+            modified_jobs: response.modified_jobs.to_a,
+            added_stages: response.added_stages.to_a,
+            removed_stages: response.removed_stages.to_a
+          }
+        else
+          # Fallback implementation
+          compare_pipelines_fallback(other_pipeline)
+        end
+      end
+
+      # Merge with another pipeline
+      def merge(other_pipeline, preserve_base = true)
+        if defined?(Gitlab::Pipeline::PipelineService) && @grpc_available
+          # Use gRPC service if available
+          service = PipelineServiceImpl.new
+          request = Gitlab::Pipeline::MergePipelinesRequest.new(
+            base_pipeline: @pipeline_data,
+            override_pipeline: other_pipeline.pipeline_data,
+            preserve_base: preserve_base
+          )
+          response = service.merge_pipelines(request, nil)
+          merged_pipeline = Pipeline.new
+          merged_pipeline.pipeline_data = response.merged_pipeline
+          {
+            pipeline: merged_pipeline,
+            conflicts: response.conflicts.to_a,
+            warnings: response.warnings.to_a
+          }
+        else
+          # Fallback implementation
+          merge_pipelines_fallback(other_pipeline, preserve_base)
+        end
+      end
+
+      # Add a job to the pipeline
+      def add_job(name, job_data)
+        if @pipeline_data.jobs.key?(name)
+          raise ArgumentError, "Job '#{name}' already exists"
+        end
+
+        job = convert_hash_to_job(job_data)
+        @pipeline_data.jobs[name] = job
+      end
+
+      # Remove a job from the pipeline
+      def remove_job(name)
+        @pipeline_data.jobs.delete(name)
+      end
+
+      # Add a stage to the pipeline
+      def add_stage(name)
+        existing_stage = @pipeline_data.stages.find { |s| s.name == name }
+        unless existing_stage
+          if @grpc_available
+            stage = Gitlab::Pipeline::Stage.new
+            stage.name = name
+            @pipeline_data.stages << stage
+          else
+            stage = Object.new
+            def stage.name
+              @name
+            end
+            def stage.name=(value)
+              @name = value
+            end
+            stage.name = name
+            @pipeline_data.stages << stage
+          end
+        end
+      end
+
+      # Remove a stage from the pipeline
+      def remove_stage(name)
+        @pipeline_data.stages.reject! { |s| s.name == name }
+        # Also remove jobs in this stage
+        @pipeline_data.jobs.reject! { |_name, job| job.stage == name }
+      end
+
+      # Get all job names
+      def job_names
+        @pipeline_data.jobs.keys
+      end
+
+      # Get all stage names
+      def stage_names
+        @pipeline_data.stages.map(&:name)
+      end
+
+      # Check if pipeline is valid
+      def valid?
+        validation_result = validate
+        validation_result[:is_valid]
+      end
+
+      # Get validation errors
+      def errors
+        validation_result = validate
+        validation_result[:errors]
+      end
+
+      # Get validation warnings
+      def warnings
+        validation_result = validate
+        validation_result[:warnings]
+      end
+
+      # Execute pipeline using Podman
+      def execute_pipeline(variables: {}, working_directory: nil, podman_executable: "podman", dry_run: false)
+        if Makit::Gitlab::PipelineServiceImpl.grpc_available?
+          execute_pipeline_grpc(variables, working_directory, podman_executable, dry_run)
+        else
+          execute_pipeline_fallback(variables, working_directory, podman_executable, dry_run)
+        end
+      end
+
+      private
+
+      def initialize_grpc_availability
+        @grpc_available = defined?(Gitlab::Pipeline::PipelineService)
+      end
+
+      def execute_pipeline_grpc(variables, working_directory, podman_executable, dry_run)
+        service = Makit::Gitlab::PipelineServiceImpl.new
+        
+        request = Gitlab::Pipeline::ExecutePipelineRequest.new(
+          pipeline: @pipeline_data,
+          variables: variables,
+          working_directory: working_directory,
+          podman_executable: podman_executable,
+          dry_run: dry_run
+        )
+        
+        service.execute_pipeline(request)
+      end
+
+      def execute_pipeline_fallback(variables, working_directory, podman_executable, dry_run)
+        service = Makit::Gitlab::PipelineServiceImpl.new
+        
+        request = {
+          pipeline: @pipeline_data,
+          variables: variables,
+          working_directory: working_directory,
+          podman_executable: podman_executable,
+          dry_run: dry_run
+        }
+        
+        service.execute_pipeline(request)
+      end
+
+      def parse_yaml(yaml_content)
+        initialize_grpc_availability
+        
+        if @grpc_available
+          # Use gRPC service if available
+          service = PipelineServiceImpl.new
+          request = Gitlab::Pipeline::ParseYamlRequest.new(
+            yaml_content: yaml_content,
+            strict_mode: true
+          )
+          response = service.parse_yaml(request, nil)
+          response.pipeline
+        else
+          # Fallback implementation
+          parse_yaml_fallback(yaml_content)
+        end
+      end
+
+      def create_empty_pipeline
+        initialize_grpc_availability
+        
+        if @grpc_available
+          Gitlab::Pipeline::Pipeline.new
+        else
+          create_empty_pipeline_fallback
+        end
+      end
+
+      def create_empty_pipeline_fallback
+        pipeline = Object.new
+        
+        def pipeline.image
+          @image ||= ""
+        end
+        
+        def pipeline.image=(value)
+          @image = value
+        end
+        
+        def pipeline.jobs
+          @jobs ||= {}
+        end
+        
+        def pipeline.stages
+          @stages ||= []
+        end
+        
+        def pipeline.variables
+          @variables ||= {}
+        end
+        
+        def pipeline.cache
+          @cache ||= nil
+        end
+        
+        def pipeline.cache=(value)
+          @cache = value
+        end
+        
+        def pipeline.before_script
+          @before_script ||= []
+        end
+        
+        def pipeline.after_script
+          @after_script ||= []
+        end
+        
+        def pipeline.timeout
+          @timeout ||= 0
+        end
+        
+        def pipeline.timeout=(value)
+          @timeout = value
+        end
+        
+        pipeline
+      end
+
+      def parse_yaml_fallback(yaml_content)
+        # Simple fallback implementation
+        yaml_data = YAML.safe_load(yaml_content, permitted_classes: [Symbol], aliases: true)
+        convert_yaml_to_pipeline_fallback(yaml_data)
+      end
+
+      def convert_yaml_to_pipeline_fallback(yaml_data)
+        # Use the fallback pipeline object
+        pipeline = create_empty_pipeline_fallback
+        
+        # Set basic properties
+        pipeline.image = yaml_data["image"] || ""
+        pipeline.timeout = yaml_data["timeout"] || 0
+        
+        # Set variables
+        if yaml_data["variables"]
+          pipeline.variables.merge!(yaml_data["variables"])
+        end
+        
+        # Set scripts
+        pipeline.before_script.concat(yaml_data["before_script"] || [])
+        pipeline.after_script.concat(yaml_data["after_script"] || [])
+        
+        # Set stages
+        if yaml_data["stages"]
+          yaml_data["stages"].each do |stage_name|
+            stage = Object.new
+            def stage.name
+              @name
+            end
+            def stage.name=(value)
+              @name = value
+            end
+            stage.name = stage_name
+            pipeline.stages << stage
+          end
+        end
+        
+        # Set jobs
+        yaml_data.each do |key, value|
+          next if %w[image variables cache before_script after_script stages include extends services tags timeout].include?(key)
+          
+          if value.is_a?(Hash)
+            job = convert_hash_to_job_fallback(value)
+            pipeline.jobs[key] = job
+          end
+        end
+        
+        pipeline
+      end
+
+      def convert_hash_to_job_fallback(job_data)
+        job = Object.new
+        
+        def job.stage
+          @stage ||= ""
+        end
+        
+        def job.stage=(value)
+          @stage = value
+        end
+        
+        def job.script
+          @script ||= []
+        end
+        
+        def job.before_script
+          @before_script ||= []
+        end
+        
+        def job.after_script
+          @after_script ||= []
+        end
+        
+        def job.image
+          @image ||= ""
+        end
+        
+        def job.image=(value)
+          @image = value
+        end
+        
+        def job.variables
+          @variables ||= {}
+        end
+        
+        def job.services
+          @services ||= []
+        end
+        
+        def job.tags
+          @tags ||= []
+        end
+        
+        def job.artifacts_paths
+          @artifacts_paths ||= []
+        end
+        
+        def job.artifacts_when
+          @artifacts_when ||= ""
+        end
+        
+        def job.artifacts_when=(value)
+          @artifacts_when = value
+        end
+        
+        def job.coverage
+          @coverage ||= ""
+        end
+        
+        def job.coverage=(value)
+          @coverage = value
+        end
+        
+        def job.allow_failure
+          @allow_failure ||= false
+        end
+        
+        def job.allow_failure=(value)
+          @allow_failure = value
+        end
+        
+        def job.timeout
+          @timeout ||= 0
+        end
+        
+        def job.timeout=(value)
+          @timeout = value
+        end
+        
+        def job.dependencies
+          @dependencies ||= []
+        end
+        
+        def job.needs
+          @needs ||= []
+        end
+        
+        def job.when
+          @when ||= []
+        end
+        
+        def job.only
+          @only ||= []
+        end
+        
+        def job.except
+          @except ||= []
+        end
+        
+        def job.rules
+          @rules ||= []
+        end
+        
+        def job.artifacts_expire_in
+          @artifacts_expire_in ||= 0
+        end
+        
+        def job.artifacts_expire_in=(value)
+          @artifacts_expire_in = value
+        end
+        
+        def job.artifacts_name
+          @artifacts_name ||= []
+        end
+        
+        def job.artifacts_untracked
+          @artifacts_untracked ||= []
+        end
+        
+        def job.artifacts_reports
+          @artifacts_reports ||= []
+        end
+        
+        def job.artifacts_expose_as
+          @artifacts_expose_as ||= []
+        end
+        
+        # Set job properties
+        job.stage = job_data["stage"] || ""
+        job.image = job_data["image"] || ""
+        job.coverage = job_data["coverage"] || ""
+        job.allow_failure = job_data["allow_failure"] || false
+        job.timeout = job_data["timeout"] || 0
+        
+        # Set script arrays
+        job.script.concat(Array(job_data["script"] || []))
+        job.before_script.concat(Array(job_data["before_script"] || []))
+        job.after_script.concat(Array(job_data["after_script"] || []))
+        job.dependencies.concat(Array(job_data["dependencies"] || []))
+        job.services.concat(Array(job_data["services"] || []))
+        job.tags.concat(Array(job_data["tags"] || []))
+        job.needs.concat(Array(job_data["needs"] || []))
+        job.when.concat(Array(job_data["when"] || []))
+        job.only.concat(Array(job_data["only"] || []))
+        job.except.concat(Array(job_data["except"] || []))
+        job.rules.concat(Array(job_data["rules"] || []))
+        
+        # Set artifacts
+        if job_data["artifacts"]
+          artifacts = job_data["artifacts"]
+          job.artifacts_paths.concat(Array(artifacts["paths"] || []))
+          job.artifacts_when = artifacts["when"] || ""
+        end
+        
+        # Set variables
+        if job_data["variables"]
+          job.variables.merge!(job_data["variables"])
+        end
+        
+        job
+      end
+
+      def convert_hash_to_job(job_data)
+        if @grpc_available
+          # Use protobuf Job
+          job = Gitlab::Pipeline::Job.new
+          job.stage = job_data["stage"] || ""
+          job.image = job_data["image"] || ""
+          job.coverage = job_data["coverage"] || ""
+          job.allow_failure = job_data["allow_failure"] || false
+          job.timeout = job_data["timeout"] || 0
+          
+          job.script.concat(job_data["script"] || [])
+          job.before_script.concat(job_data["before_script"] || [])
+          job.after_script.concat(job_data["after_script"] || [])
+          job.dependencies.concat(job_data["dependencies"] || [])
+          job.services.concat(job_data["services"] || [])
+          job.tags.concat(job_data["tags"] || [])
+          job.needs.concat(job_data["needs"] || [])
+          job.when.concat(job_data["when"] || [])
+          job.only.concat(job_data["only"] || [])
+          job.except.concat(job_data["except"] || [])
+          job.rules.concat(job_data["rules"] || [])
+          
+          if job_data["artifacts"]
+            artifacts = job_data["artifacts"]
+            job.artifacts_paths.concat(artifacts["paths"] || [])
+            job.artifacts_when = artifacts["when"] || ""
+            job.artifacts_expire_in = artifacts["expire_in"] || 0
+          end
+          
+          if job_data["variables"]
+            job_data["variables"].each do |key, value|
+              job.variables[key] = value.to_s
+            end
+          end
+          
+          job
+        else
+          convert_hash_to_job_fallback(job_data)
+        end
+      end
+
+      def convert_pipeline_to_yaml(pipeline, pretty_format = true)
+        yaml_data = {}
+        
+        # Add basic fields
+        yaml_data["image"] = pipeline.image unless pipeline.image.empty?
+        yaml_data["timeout"] = pipeline.timeout unless pipeline.timeout == 0
+        
+        # Add variables
+        unless pipeline.variables.empty?
+          yaml_data["variables"] = pipeline.variables.to_h
+        end
+        
+        # Add scripts
+        yaml_data["before_script"] = pipeline.before_script.to_a unless pipeline.before_script.empty?
+        yaml_data["after_script"] = pipeline.after_script.to_a unless pipeline.after_script.empty?
+        
+        # Add stages
+        unless pipeline.stages.empty?
+          yaml_data["stages"] = pipeline.stages.map(&:name)
+        end
+        
+        # Add jobs
+        pipeline.jobs.each do |job_name, job|
+          yaml_data[job_name] = convert_job_to_yaml(job)
+        end
+        
+        if pretty_format
+          YAML.dump(yaml_data)
+        else
+          yaml_data.to_yaml
+        end
+      end
+
+      def convert_job_to_yaml(job)
+        job_data = {}
+        
+        # Add basic fields
+        job_data["stage"] = job.stage unless job.stage.empty?
+        job_data["image"] = job.image unless job.image.empty?
+        job_data["coverage"] = job.coverage unless job.coverage.empty?
+        job_data["allow_failure"] = job.allow_failure if job.allow_failure
+        job_data["timeout"] = job.timeout unless job.timeout == 0
+        
+        # Add script arrays
+        job_data["script"] = job.script.to_a unless job.script.empty?
+        job_data["before_script"] = job.before_script.to_a unless job.before_script.empty?
+        job_data["after_script"] = job.after_script.to_a unless job.after_script.empty?
+        job_data["dependencies"] = job.dependencies.to_a unless job.dependencies.empty?
+        job_data["services"] = job.services.to_a unless job.services.empty?
+        job_data["tags"] = job.tags.to_a unless job.tags.empty?
+        job_data["needs"] = job.needs.to_a unless job.needs.empty?
+        job_data["when"] = job.when.to_a unless job.when.empty?
+        job_data["only"] = job.only.to_a unless job.only.empty?
+        job_data["except"] = job.except.to_a unless job.except.empty?
+        job_data["rules"] = job.rules.to_a unless job.rules.empty?
+        
+        # Add artifacts
+        if !job.artifacts_paths.empty? || !job.artifacts_when.empty? || job.artifacts_expire_in != 0
+          artifacts_data = {}
+          artifacts_data["paths"] = job.artifacts_paths.to_a unless job.artifacts_paths.empty?
+          artifacts_data["when"] = job.artifacts_when unless job.artifacts_when.empty?
+          artifacts_data["expire_in"] = job.artifacts_expire_in unless job.artifacts_expire_in == 0
+          job_data["artifacts"] = artifacts_data
+        end
+        
+        # Add variables
+        unless job.variables.empty?
+          job_data["variables"] = job.variables.to_h
+        end
+        
+        job_data
+      end
+
+      def validate_pipeline_fallback
+        errors = []
+        warnings = []
+        
+        # Basic validation
+        if @pipeline_data.jobs.empty? && @pipeline_data.stages.empty?
+          errors << "Pipeline has no jobs or stages defined"
+        elsif @pipeline_data.jobs.empty?
+          warnings << "Pipeline has no jobs defined"
+        end
+        
+        if @pipeline_data.stages.empty?
+          warnings << "Pipeline has no stages defined"
+        end
+        
+        # Validate jobs
+        @pipeline_data.jobs.each do |job_name, job|
+          if job.stage && !@pipeline_data.stages.any? { |s| s.name == job.stage }
+            errors << "Job '#{job_name}' references non-existent stage '#{job.stage}'"
+          end
+          
+          if job.script.empty?
+            warnings << "Job '#{job_name}' has no script defined"
+          end
+        end
+        
+        {
+          is_valid: errors.empty?,
+          errors: errors,
+          warnings: warnings,
+          suggestions: []
+        }
+      end
+
+      def calculate_stats_fallback
+        total_artifacts = @pipeline_data.jobs.values.sum { |job| job.artifacts_paths.length }
+        total_services = @pipeline_data.jobs.values.sum { |job| job.services.length }
+        total_variables = @pipeline_data.variables.length + @pipeline_data.jobs.values.sum { |job| job.variables.length }
+        
+        {
+          total_jobs: @pipeline_data.jobs.length,
+          total_stages: @pipeline_data.stages.length,
+          total_artifacts: total_artifacts,
+          total_services: total_services,
+          total_variables: total_variables,
+          stage_names: @pipeline_data.stages.map(&:name),
+          job_names: @pipeline_data.jobs.keys
+        }
+      end
+
+      def compare_pipelines_fallback(other_pipeline)
+        differences = []
+        added_jobs = []
+        removed_jobs = []
+        modified_jobs = []
+        added_stages = []
+        removed_stages = []
+        
+        # Compare jobs
+        pipeline1_jobs = @pipeline_data.jobs.keys.to_set
+        pipeline2_jobs = other_pipeline.pipeline_data.jobs.keys.to_set
+        
+        added_jobs = (pipeline2_jobs - pipeline1_jobs).to_a
+        removed_jobs = (pipeline1_jobs - pipeline2_jobs).to_a
+        
+        # Add differences for added and removed jobs
+        added_jobs.each { |job| differences << "Job '#{job}' was added" }
+        removed_jobs.each { |job| differences << "Job '#{job}' was removed" }
+        
+        common_jobs = pipeline1_jobs & pipeline2_jobs
+        common_jobs.each do |job_name|
+          job1 = @pipeline_data.jobs[job_name]
+          job2 = other_pipeline.pipeline_data.jobs[job_name]
+          unless jobs_equal?(job1, job2)
+            modified_jobs << job_name
+            differences << "Job '#{job_name}' has been modified"
+          end
+        end
+        
+        # Compare stages
+        pipeline1_stages = @pipeline_data.stages.map(&:name).to_set
+        pipeline2_stages = other_pipeline.pipeline_data.stages.map(&:name).to_set
+        
+        added_stages = (pipeline2_stages - pipeline1_stages).to_a
+        removed_stages = (pipeline1_stages - pipeline2_stages).to_a
+        
+        # Add differences for added and removed stages
+        added_stages.each { |stage| differences << "Stage '#{stage}' was added" }
+        removed_stages.each { |stage| differences << "Stage '#{stage}' was removed" }
+        
+        {
+          are_identical: differences.empty? && added_jobs.empty? && removed_jobs.empty? && added_stages.empty? && removed_stages.empty?,
+          differences: differences,
+          added_jobs: added_jobs,
+          removed_jobs: removed_jobs,
+          modified_jobs: modified_jobs,
+          added_stages: added_stages,
+          removed_stages: removed_stages
+        }
+      end
+
+      def merge_pipelines_fallback(other_pipeline, preserve_base)
+        conflicts = []
+        warnings = []
+        
+        # Create merged pipeline
+        merged_pipeline = Pipeline.new
+        merged_pipeline.pipeline_data = create_empty_pipeline_fallback
+        
+        # Copy basic fields from base pipeline
+        merged_pipeline.pipeline_data.image = @pipeline_data.image
+        merged_pipeline.pipeline_data.timeout = @pipeline_data.timeout
+        
+        # Copy variables
+        @pipeline_data.variables.each do |key, value|
+          merged_pipeline.pipeline_data.variables[key] = value
+        end
+        
+        # Copy stages
+        @pipeline_data.stages.each do |stage|
+          new_stage = Object.new
+          def new_stage.name
+            @name
+          end
+          def new_stage.name=(value)
+            @name = value
+          end
+          new_stage.name = stage.name
+          merged_pipeline.pipeline_data.stages << new_stage
+        end
+        
+        # Copy jobs
+        @pipeline_data.jobs.each do |job_name, job|
+          merged_pipeline.pipeline_data.jobs[job_name] = job
+        end
+        
+        # Merge basic fields
+        if !other_pipeline.pipeline_data.image.empty?
+          merged_pipeline.pipeline_data.image = other_pipeline.pipeline_data.image
+        end
+        if other_pipeline.pipeline_data.timeout != 0
+          merged_pipeline.pipeline_data.timeout = other_pipeline.pipeline_data.timeout
+        end
+        
+        # Merge variables
+        other_pipeline.pipeline_data.variables.each do |key, value|
+          if merged_pipeline.pipeline_data.variables.key?(key) && merged_pipeline.pipeline_data.variables[key] != value
+            conflicts << "Variable '#{key}' has different values: '#{merged_pipeline.pipeline_data.variables[key]}' vs '#{value}'"
+          end
+          merged_pipeline.pipeline_data.variables[key] = value
+        end
+        
+        # Merge stages
+        other_pipeline.pipeline_data.stages.each do |override_stage|
+          existing_stage = merged_pipeline.pipeline_data.stages.find { |s| s.name == override_stage.name }
+          unless existing_stage
+            merged_pipeline.pipeline_data.stages << override_stage
+          end
+        end
+        
+        # Merge jobs
+        other_pipeline.pipeline_data.jobs.each do |job_name, job|
+          if merged_pipeline.pipeline_data.jobs.key?(job_name)
+            conflicts << "Job '#{job_name}' exists in both pipelines"
+          end
+          merged_pipeline.pipeline_data.jobs[job_name] = job
+        end
+        
+        {
+          pipeline: merged_pipeline,
+          conflicts: conflicts,
+          warnings: warnings
+        }
+      end
+
+      def jobs_equal?(job1, job2)
+        job1.stage == job2.stage &&
+          job1.script.to_a == job2.script.to_a &&
+          job1.before_script.to_a == job2.before_script.to_a &&
+          job1.after_script.to_a == job2.after_script.to_a &&
+          job1.dependencies.to_a == job2.dependencies.to_a &&
+          job1.artifacts_paths.to_a == job2.artifacts_paths.to_a &&
+          job1.artifacts_when == job2.artifacts_when &&
+          job1.coverage == job2.coverage &&
+          job1.variables.to_h == job2.variables.to_h &&
+          job1.image == job2.image &&
+          job1.services.to_a == job2.services.to_a &&
+          job1.tags.to_a == job2.tags.to_a &&
+          job1.allow_failure == job2.allow_failure &&
+          job1.timeout == job2.timeout &&
+          job1.needs.to_a == job2.needs.to_a
+      end
+    end
+  end
+end