language-operator 0.0.1 → 0.1.30

data/lib/language_operator/dsl.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+require_relative 'dsl/tool_definition'
+require_relative 'dsl/parameter_definition'
+require_relative 'dsl/registry'
+require_relative 'dsl/adapter'
+require_relative 'dsl/config'
+require_relative 'dsl/helpers'
+require_relative 'dsl/http'
+require_relative 'dsl/shell'
+require_relative 'dsl/context'
+require_relative 'dsl/execution_context'
+require_relative 'dsl/agent_definition'
+require_relative 'dsl/agent_context'
+require_relative 'dsl/workflow_definition'
+require_relative 'agent/safety/ast_validator'
+require_relative 'agent/safety/safe_executor'
+
+module LanguageOperator
+  # DSL for defining MCP tools and autonomous agents
+  #
+  # Provides a clean, Ruby-like DSL for defining tools that can be served
+  # via the Model Context Protocol (MCP) and agents that can execute autonomously.
+  #
+  # @example Define a tool
+  #   LanguageOperator::Dsl.define do
+  #     tool "greet" do
+  #       description "Greet a user by name"
+  #
+  #       parameter :name do
+  #         type :string
+  #         required true
+  #         description "Name to greet"
+  #       end
+  #
+  #       execute do |params|
+  #         "Hello, #{params['name']}!"
+  #       end
+  #     end
+  #   end
+  #
+  # @example Access tools
+  #   registry = LanguageOperator::Dsl.registry
+  #   tool = registry.get("greet")
+  #   result = tool.call({"name" => "Alice"})
+  module Dsl
+    class << self
+      # Global registry for tools
+      #
+      # @return [Registry] The global tool registry
+      def registry
+        @registry ||= Registry.new
+      end
+
+      # Global registry for agents
+      #
+      # @return [AgentRegistry] The global agent registry
+      def agent_registry
+        @agent_registry ||= AgentRegistry.new
+      end
+
+      # Define tools using the DSL
+      #
+      # @yield Block containing tool definitions
+      # @return [Registry] The global registry with defined tools
+      #
+      # @example
+      #   LanguageOperator::Dsl.define do
+      #     tool "example" do
+      #       # ...
+      #     end
+      #   end
+      def define(&)
+        context = Context.new(registry)
+        context.instance_eval(&)
+        registry
+      end
+
+      # Define agents using the DSL
+      #
+      # @yield Block containing agent definitions
+      # @return [AgentRegistry] The global agent registry
+      #
+      # @example
+      #   LanguageOperator::Dsl.define_agents do
+      #     agent "news-summarizer" do
+      #       # ...
+      #     end
+      #   end
+      def define_agents(&)
+        context = AgentContext.new(agent_registry)
+        context.instance_eval(&)
+        agent_registry
+      end
+
+      # Load tools from a file
+      #
+      # @param file_path [String] Path to the tool definition file
+      # @return [Registry] The global registry with loaded tools
+      #
+      # @example
+      #   LanguageOperator::Dsl.load_file("mcp/tools.rb")
+      def load_file(file_path)
+        code = File.read(file_path)
+        context = Context.new(registry)
+
+        # Execute in sandbox with validation
+        executor = Agent::Safety::SafeExecutor.new(context)
+        executor.eval(code, file_path)
+
+        registry
+      end
+
+      # Load agents from a file
+      #
+      # @param file_path [String] Path to the agent definition file
+      # @return [AgentRegistry] The global agent registry
+      #
+      # @example
+      #   LanguageOperator::Dsl.load_agent_file("agents/news-summarizer.rb")
+      def load_agent_file(file_path)
+        code = File.read(file_path)
+        context = AgentContext.new(agent_registry)
+
+        # Execute in sandbox with validation
+        executor = Agent::Safety::SafeExecutor.new(context)
+        executor.eval(code, file_path)
+
+        agent_registry
+      end
+
+      # Clear all defined tools
+      #
+      # @return [void]
+      def clear!
+        registry.clear
+      end
+
+      # Clear all defined agents
+      #
+      # @return [void]
+      def clear_agents!
+        agent_registry.clear
+      end
+
+      # Create an MCP server from the defined tools
+      #
+      # @param server_name [String] Name of the MCP server
+      # @param server_context [Hash] Additional context for the server
+      # @return [MCP::Server] The MCP server instance
+      #
+      # @example
+      #   server = LanguageOperator::Dsl.create_server(server_name: "my-tools")
+      def create_server(server_name: 'langop-tools', server_context: {})
+        Adapter.create_mcp_server(registry, server_name: server_name, server_context: server_context)
+      end
+    end
+  end
+end

data/lib/language_operator/errors.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  # Standardized error formatting module for consistent error messages across tools
+  module Errors
+    # Resource not found error
+    # @param resource_type [String] Type of resource (e.g., "Pod", "LanguageAgent")
+    # @param identifier [String] Resource identifier (name, ID, etc.)
+    # @return [String] Formatted error message
+    def self.not_found(resource_type, identifier)
+      "Error: #{resource_type} not found - #{identifier}"
+    end
+
+    # Access denied error
+    # @param context [String] Additional context (default: "check RBAC permissions")
+    # @return [String] Formatted error message
+    def self.access_denied(context = 'check RBAC permissions')
+      "Error: Access denied - #{context}"
+    end
+
+    # Invalid JSON parameter error
+    # @param param_name [String] Name of the parameter
+    # @return [String] Formatted error message
+    def self.invalid_json(param_name)
+      "Error: Invalid JSON in #{param_name} parameter"
+    end
+
+    # Missing configuration error
+    # @param missing_vars [String, Array<String>] Missing variable(s)
+    # @return [String] Formatted error message
+    def self.missing_config(missing_vars)
+      vars = Array(missing_vars).join(', ')
+      "Error: Missing configuration: #{vars}"
+    end
+
+    # Invalid parameter value error
+    # @param param_name [String] Parameter name
+    # @param value [String] Invalid value
+    # @param expected [String] Expected format/value
+    # @return [String] Formatted error message
+    def self.invalid_parameter(param_name, value, expected)
+      "Error: Invalid #{param_name} '#{value}'. Expected: #{expected}"
+    end
+
+    # Generic operation failed error
+    # @param operation [String] Operation that failed
+    # @param reason [String] Reason for failure
+    # @return [String] Formatted error message
+    def self.operation_failed(operation, reason)
+      "Error: #{operation} failed - #{reason}"
+    end
+
+    # Empty/missing required field error
+    # @param field_name [String] Name of the field
+    # @return [String] Formatted error message
+    def self.empty_field(field_name)
+      "Error: #{field_name} cannot be empty"
+    end
+  end
+end

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