language-operator 0.0.1 → 0.1.31

data/lib/language_operator/kubernetes/client.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require 'k8s-ruby'
+require 'yaml'
+
+module LanguageOperator
+  module Kubernetes
+    # Kubernetes client wrapper for interacting with language-operator resources
+    class Client
+      attr_reader :client
+
+      # Get singleton K8s client instance with automatic config detection
+      # @return [LanguageOperator::Kubernetes::Client] Client instance
+      # @raise [RuntimeError] if client initialization fails
+      def self.instance
+        @instance ||= build_singleton
+      end
+
+      # Reset the singleton (useful for testing)
+      # @return [nil]
+      def self.reset!
+        @instance = nil
+      end
+
+      # Check if running inside a Kubernetes cluster
+      # @return [Boolean] True if in-cluster, false otherwise
+      def self.in_cluster?
+        File.exist?('/var/run/secrets/kubernetes.io/serviceaccount/token')
+      end
+
+      def initialize(kubeconfig: nil, context: nil, in_cluster: false)
+        @in_cluster = in_cluster
+        @kubeconfig = kubeconfig || ENV.fetch('KUBECONFIG', File.expand_path('~/.kube/config'))
+        @context = context
+        @client = build_client
+      end
+
+      # Get the current Kubernetes context name
+      def current_context
+        return nil if @in_cluster
+
+        config = K8s::Config.load_file(@kubeconfig)
+        @context || config.current_context
+      rescue Errno::ENOENT
+        nil
+      end
+
+      # Get the current namespace from the context
+      def current_namespace
+        if @in_cluster
+          # In-cluster: read from service account namespace
+          File.read('/var/run/secrets/kubernetes.io/serviceaccount/namespace').strip
+        else
+          config = K8s::Config.load_file(@kubeconfig)
+          context_name = current_context
+          context_obj = config.context(context_name)
+          context_obj&.namespace
+        end
+      rescue Errno::ENOENT
+        nil
+      end
+
+      # Create or update a Kubernetes resource
+      def apply_resource(resource)
+        namespace = resource.dig('metadata', 'namespace')
+        name = resource.dig('metadata', 'name')
+        kind = resource['kind']
+        api_version = resource['apiVersion']
+
+        begin
+          # Try to get existing resource
+          existing = get_resource(kind, name, namespace, api_version)
+          if existing
+            # Merge existing metadata (especially resourceVersion) with new resource
+            merged_resource = if resource.is_a?(Hash)
+                                resource.dup
+                              else
+                                resource.to_h
+                              end
+            merged_resource['metadata'] ||= {}
+            merged_resource['metadata']['resourceVersion'] = existing.metadata.resourceVersion
+            merged_resource['metadata']['uid'] = existing.metadata.uid if existing.metadata.uid
+
+            # Update existing resource
+            update_resource(kind, name, namespace, merged_resource, api_version)
+          else
+            # Create new resource
+            create_resource(resource)
+          end
+        rescue K8s::Error::NotFound
+          # Resource doesn't exist, create it
+          create_resource(resource)
+        end
+      end
+
+      # Create a resource
+      def create_resource(resource)
+        resource_client = resource_client_for_resource(resource)
+        # Convert hash to K8s::Resource if needed
+        k8s_resource = resource.is_a?(K8s::Resource) ? resource : K8s::Resource.new(resource)
+        resource_client.create_resource(k8s_resource)
+      end
+
+      # Update a resource
+      def update_resource(kind, _name, namespace, resource, api_version)
+        resource_client = resource_client_for(kind, namespace, api_version)
+        # Convert hash to K8s::Resource if needed
+        k8s_resource = resource.is_a?(K8s::Resource) ? resource : K8s::Resource.new(resource)
+        resource_client.update_resource(k8s_resource)
+      end
+
+      # Get a resource
+      def get_resource(kind, name, namespace = nil, api_version = nil)
+        resource_client = resource_client_for(kind, namespace, api_version || default_api_version(kind))
+        resource_client.get(name)
+      end
+
+      # List resources
+      def list_resources(kind, namespace: nil, api_version: nil, label_selector: nil)
+        resource_client = resource_client_for(kind, namespace, api_version || default_api_version(kind))
+        opts = {}
+        opts[:labelSelector] = label_selector if label_selector
+
+        resource_client.list(**opts)
+      end
+
+      # Delete a resource
+      def delete_resource(kind, name, namespace = nil, api_version = nil)
+        resource_client = resource_client_for(kind, namespace, api_version || default_api_version(kind))
+        resource_client.delete(name)
+      end
+
+      # Check if namespace exists
+      def namespace_exists?(name)
+        @client.api('v1').resource('namespaces').get(name)
+        true
+      rescue K8s::Error::NotFound
+        false
+      end
+
+      # Create namespace
+      def create_namespace(name, labels: {})
+        resource = {
+          'apiVersion' => 'v1',
+          'kind' => 'Namespace',
+          'metadata' => {
+            'name' => name,
+            'labels' => labels
+          }
+        }
+        create_resource(resource)
+      end
+
+      # Check if operator is installed
+      def operator_installed?
+        # Check if LanguageCluster CRD exists
+        @client.apis(prefetch_resources: true)
+               .find { |api| api.api_version == 'langop.io/v1alpha1' }
+      rescue StandardError
+        false
+      end
+
+      # Get operator version
+      def operator_version
+        deployment = @client.api('apps/v1')
+                            .resource('deployments', namespace: 'kube-system')
+                            .get('language-operator')
+        deployment.dig('metadata', 'labels', 'app.kubernetes.io/version') || 'unknown'
+      rescue K8s::Error::NotFound
+        nil
+      end
+
+      private
+
+      # Build singleton instance with automatic config detection
+      def self.build_singleton
+        if in_cluster?
+          new(in_cluster: true)
+        else
+          new
+        end
+      rescue StandardError => e
+        raise "Failed to initialize Kubernetes client: #{e.message}"
+      end
+      private_class_method :build_singleton
+
+      def build_client
+        if @in_cluster
+          K8s::Client.in_cluster_config
+        else
+          config = K8s::Config.load_file(@kubeconfig)
+          if @context
+            # Set the current-context to the specified context
+            config_hash = config.to_h
+            config_hash['current-context'] = @context
+            config = K8s::Config.new(**config_hash)
+          end
+          K8s::Client.config(config)
+        end
+      end
+
+      def resource_client_for_resource(resource)
+        kind = resource['kind']
+        namespace = resource.dig('metadata', 'namespace')
+        api_version = resource['apiVersion']
+        resource_client_for(kind, namespace, api_version)
+      end
+
+      def resource_client_for(kind, namespace, api_version)
+        api_client = api_for_version(api_version)
+        resource_name = kind_to_resource_name(kind)
+        if namespace
+          api_client.resource(resource_name, namespace: namespace)
+        else
+          api_client.resource(resource_name)
+        end
+      end
+
+      def api_for_version(api_version)
+        if api_version.include?('/')
+          group, version = api_version.split('/', 2)
+          @client.api("#{group}/#{version}")
+        else
+          @client.api(api_version)
+        end
+      end
+
+      def kind_to_resource_name(kind)
+        # Convert Kind (singular, capitalized) to resource name (plural, lowercase)
+        case kind.downcase
+        when 'languagecluster'
+          'languageclusters'
+        when 'languageagent'
+          'languageagents'
+        when 'languagetool'
+          'languagetools'
+        when 'languagemodel'
+          'languagemodels'
+        when 'languageclient'
+          'languageclients'
+        when 'languagepersona'
+          'languagepersonas'
+        when 'namespace'
+          'namespaces'
+        when 'configmap'
+          'configmaps'
+        when 'secret'
+          'secrets'
+        when 'service'
+          'services'
+        when 'deployment'
+          'deployments'
+        when 'statefulset'
+          'statefulsets'
+        when 'cronjob'
+          'cronjobs'
+        else
+          # Generic pluralization - add 's'
+          "#{kind.downcase}s"
+        end
+      end
+
+      def default_api_version(kind)
+        case kind.downcase
+        when 'languagecluster', 'languageagent', 'languagetool', 'languagemodel', 'languageclient', 'languagepersona'
+          'langop.io/v1alpha1'
+        when 'namespace', 'configmap', 'secret', 'service'
+          'v1'
+        when 'deployment', 'statefulset'
+          'apps/v1'
+        when 'cronjob'
+          'batch/v1'
+        else
+          'v1'
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/kubernetes/resource_builder.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module Kubernetes
+    # Builds Kubernetes resource manifests for language-operator
+    class ResourceBuilder
+      class << self
+        # Build a LanguageCluster resource
+        def language_cluster(name, namespace: nil, labels: {})
+          {
+            'apiVersion' => 'langop.io/v1alpha1',
+            'kind' => 'LanguageCluster',
+            'metadata' => {
+              'name' => name,
+              'namespace' => namespace || 'default',
+              'labels' => default_labels.merge(labels)
+            },
+            'spec' => {
+              'namespace' => namespace || name,
+              'resourceQuota' => default_resource_quota,
+              'networkPolicy' => default_network_policy
+            }
+          }
+        end
+
+        # Build a LanguageAgent resource
+        def language_agent(name, instructions:, cluster: nil, schedule: nil, persona: nil, tools: [], models: [],
+                           mode: nil, labels: {})
+          # Determine mode: reactive, scheduled, or autonomous
+          spec_mode = mode || (schedule ? 'scheduled' : 'autonomous')
+
+          spec = {
+            'instructions' => instructions,
+            'mode' => spec_mode,
+            'image' => 'ghcr.io/language-operator/agent:latest'
+          }
+
+          spec['schedule'] = schedule if schedule
+          spec['persona'] = persona if persona
+          spec['tools'] = tools unless tools.empty?
+          # Convert model names to modelRef objects
+          spec['modelRefs'] = models.map { |m| { 'name' => m } } unless models.empty?
+
+          {
+            'apiVersion' => 'langop.io/v1alpha1',
+            'kind' => 'LanguageAgent',
+            'metadata' => {
+              'name' => name,
+              'namespace' => cluster || 'default',
+              'labels' => default_labels.merge(labels)
+            },
+            'spec' => spec
+          }
+        end
+
+        # Build a LanguageTool resource
+        def language_tool(name, type:, config: {}, cluster: nil, labels: {})
+          {
+            'apiVersion' => 'langop.io/v1alpha1',
+            'kind' => 'LanguageTool',
+            'metadata' => {
+              'name' => name,
+              'namespace' => cluster || 'default',
+              'labels' => default_labels.merge(labels)
+            },
+            'spec' => {
+              'type' => type,
+              'config' => config
+            }
+          }
+        end
+
+        # Build a LanguageModel resource
+        def language_model(name, provider:, model:, endpoint: nil, cluster: nil, labels: {})
+          spec = {
+            'provider' => provider,
+            'modelName' => model
+          }
+          spec['endpoint'] = endpoint if endpoint
+
+          {
+            'apiVersion' => 'langop.io/v1alpha1',
+            'kind' => 'LanguageModel',
+            'metadata' => {
+              'name' => name,
+              'namespace' => cluster || 'default',
+              'labels' => default_labels.merge(labels)
+            },
+            'spec' => spec
+          }
+        end
+
+        # Build a LanguagePersona resource
+        def language_persona(name, description:, tone:, system_prompt:, cluster: nil, labels: {})
+          {
+            'apiVersion' => 'langop.io/v1alpha1',
+            'kind' => 'LanguagePersona',
+            'metadata' => {
+              'name' => name,
+              'namespace' => cluster || 'default',
+              'labels' => default_labels.merge(labels)
+            },
+            'spec' => {
+              'displayName' => name.split('-').map(&:capitalize).join(' '),
+              'description' => description,
+              'tone' => tone,
+              'systemPrompt' => system_prompt
+            }
+          }
+        end
+
+        # Build a LanguagePersona resource with full spec control
+        def build_persona(name:, spec:, namespace: nil, labels: {})
+          {
+            'apiVersion' => 'langop.io/v1alpha1',
+            'kind' => 'LanguagePersona',
+            'metadata' => {
+              'name' => name,
+              'namespace' => namespace || 'default',
+              'labels' => default_labels.merge(labels)
+            },
+            'spec' => spec
+          }
+        end
+
+        # Build a Kubernetes Service resource for a reactive agent
+        #
+        # @param agent_name [String] Name of the agent
+        # @param namespace [String] Kubernetes namespace
+        # @param port [Integer] Service port (default: 8080)
+        # @param labels [Hash] Additional labels
+        # @return [Hash] Service manifest
+        def agent_service(agent_name, namespace: nil, port: 8080, labels: {})
+          {
+            'apiVersion' => 'v1',
+            'kind' => 'Service',
+            'metadata' => {
+              'name' => agent_name,
+              'namespace' => namespace || 'default',
+              'labels' => default_labels.merge(
+                'app.kubernetes.io/name' => agent_name,
+                'app.kubernetes.io/component' => 'agent'
+              ).merge(labels)
+            },
+            'spec' => {
+              'type' => 'ClusterIP',
+              'selector' => {
+                'app.kubernetes.io/name' => agent_name,
+                'app.kubernetes.io/component' => 'agent'
+              },
+              'ports' => [
+                {
+                  'name' => 'http',
+                  'protocol' => 'TCP',
+                  'port' => port,
+                  'targetPort' => port
+                }
+              ]
+            }
+          }
+        end
+
+        private
+
+        def default_labels
+          {
+            'app.kubernetes.io/managed-by' => 'aictl',
+            'app.kubernetes.io/part-of' => 'language-operator'
+          }
+        end
+
+        def default_resource_quota
+          {
+            'hard' => {
+              'requests.cpu' => '4',
+              'requests.memory' => '8Gi',
+              'limits.cpu' => '8',
+              'limits.memory' => '16Gi'
+            }
+          }
+        end
+
+        def default_network_policy
+          {
+            'egress' => {
+              'allowDNS' => ['8.8.8.8/32', '8.8.4.4/32'],
+              'allowHTTPS' => ['0.0.0.0/0']
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/loggable.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  # Mixin module to provide automatic logger initialization for classes
+  # that need logging capabilities.
+  #
+  # @example
+  #   class MyClass
+  #     include LanguageOperator::Loggable
+  #
+  #     def process
+  #       logger.info("Processing started")
+  #       # ...
+  #     end
+  #   end
+  #
+  # The logger component name is automatically derived from the class name.
+  # You can override the component name by defining a `logger_component` method.
+  #
+  # @example Custom component name
+  #   class MyClass
+  #     include LanguageOperator::Loggable
+  #
+  #     def logger_component
+  #       'CustomName'
+  #     end
+  #   end
+  module Loggable
+    # Returns a logger instance for this class.
+    # Lazily initializes the logger on first access.
+    #
+    # @return [LanguageOperator::Logger] Logger instance
+    def logger
+      @logger ||= LanguageOperator::Logger.new(component: logger_component)
+    end
+
+    private
+
+    # Returns the component name to use for the logger.
+    # Defaults to the class name, but can be overridden.
+    #
+    # @return [String] Component name for the logger
+    def logger_component
+      self.class.name
+    end
+  end
+end

data/lib/language_operator/logger.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module LanguageOperator
+  # Structured logger with configurable output formats and levels
+  #
+  # Supports multiple output formats:
+  # - :pretty (default): Human-readable with emojis and colors
+  # - :text: Plain text with timestamps
+  # - :json: Structured JSON output
+  #
+  # Environment variables:
+  # - LOG_LEVEL: DEBUG, INFO, WARN, ERROR (default: INFO)
+  # - LOG_FORMAT: pretty, text, json (default: pretty)
+  # - LOG_TIMING: true/false - Include operation timing (default: true)
+  class Logger
+    LEVELS = {
+      'DEBUG' => ::Logger::DEBUG,
+      'INFO' => ::Logger::INFO,
+      'WARN' => ::Logger::WARN,
+      'ERROR' => ::Logger::ERROR
+    }.freeze
+
+    LEVEL_EMOJI = {
+      'DEBUG' => '', # 🔍
+      'INFO' => '', # ℹ️
+      'WARN' => '', # ⚠️
+      'ERROR' => '' # ❌
+    }.freeze
+
+    attr_reader :logger, :format, :show_timing
+
+    def initialize(component: 'Langop', format: nil, level: nil)
+      @component = component
+      @format = format || ENV.fetch('LOG_FORMAT', 'pretty').to_sym
+      @show_timing = ENV.fetch('LOG_TIMING', 'true') == 'true'
+
+      log_level_name = level || ENV.fetch('LOG_LEVEL', 'INFO')
+      log_level = LEVELS[log_level_name.upcase] || ::Logger::INFO
+
+      @logger = ::Logger.new($stdout)
+      @logger.level = log_level
+      @logger.formatter = method(:format_message)
+    end
+
+    def debug(message, **metadata)
+      log(:debug, message, **metadata)
+    end
+
+    def info(message, **metadata)
+      log(:info, message, **metadata)
+    end
+
+    def warn(message, **metadata)
+      log(:warn, message, **metadata)
+    end
+
+    def error(message, **metadata)
+      log(:error, message, **metadata)
+    end
+
+    # Log with timing information
+    def timed(message, **metadata)
+      start_time = Time.now
+      result = yield if block_given?
+      duration = Time.now - start_time
+
+      info(message, **metadata, duration_s: duration.round(3))
+      result
+    end
+
+    private
+
+    def log(severity, message, **metadata)
+      @logger.send(severity) do
+        case @format
+        when :json
+          format_json(severity, message, **metadata)
+        when :text
+          format_text(severity, message, **metadata)
+        else
+          format_pretty(severity, message, **metadata)
+        end
+      end
+    end
+
+    def format_message(_severity, _timestamp, _progname, msg)
+      "#{msg}\n" # Already formatted by log method, add newline
+    end
+
+    def format_json(severity, message, **metadata)
+      require 'json'
+      JSON.generate({
+                      timestamp: Time.now.iso8601,
+                      level: severity.to_s.upcase,
+                      component: @component,
+                      message: message,
+                      **metadata
+                    })
+    end
+
+    def format_text(severity, message, **metadata)
+      parts = [
+        Time.now.strftime('%Y-%m-%d %H:%M:%S'),
+        severity.to_s.upcase.ljust(5),
+        "[#{@component}]",
+        message
+      ]
+
+      metadata_str = format_metadata(**metadata)
+      parts << metadata_str unless metadata_str.empty?
+
+      parts.join(' ')
+    end
+
+    def format_pretty(severity, message, **metadata)
+      emoji = LEVEL_EMOJI[severity.to_s.upcase] || '•'
+      parts = [emoji, message]
+
+      metadata_str = format_metadata(**metadata)
+      parts << "(#{metadata_str})" unless metadata_str.empty?
+
+      parts.join(' ')
+    end
+
+    def format_metadata(**metadata)
+      return '' if metadata.empty?
+
+      metadata.map do |key, value|
+        if key == :duration_s && @show_timing
+          "#{value}s"
+        elsif value.is_a?(String) && value.length > 100
+          "#{key}=#{value[0..97]}..."
+        else
+          "#{key}=#{value}"
+        end
+      end.join(', ')
+    end
+  end
+end