language-operator 0.1.63 → 0.1.65

data/lib/language_operator/cli/commands/agent/learning.rb

@@ -81,7 +81,8 @@ module LanguageOperator
                 agent = ctx.client.get_resource(RESOURCE_AGENT, name, ctx.namespace)
 
                 # Check current status
-                annotations = agent.dig('metadata', 'annotations') || {}
+                annotations = agent.dig('metadata', 'annotations')
+                annotations = annotations.respond_to?(:to_h) ? annotations.to_h : (annotations || {})
                 disabled_annotation = Constants::KubernetesLabels::LEARNING_DISABLED_LABEL
 
                 unless annotations.key?(disabled_annotation)
@@ -117,7 +118,8 @@ module LanguageOperator
                 agent = ctx.client.get_resource(RESOURCE_AGENT, name, ctx.namespace)
 
                 # Check current status
-                annotations = agent.dig('metadata', 'annotations') || {}
+                annotations = agent.dig('metadata', 'annotations')
+                annotations = annotations.respond_to?(:to_h) ? annotations.to_h : (annotations || {})
                 disabled_annotation = Constants::KubernetesLabels::LEARNING_DISABLED_LABEL
 
                 if annotations.key?(disabled_annotation)
@@ -147,45 +149,27 @@ module LanguageOperator
             end
 
             def display_learning_status(agent, learning_status, cluster_name)
-              agent_name = agent.dig('metadata', 'name')
-              annotations = agent.dig('metadata', 'annotations') || {}
+              agent.dig('metadata', 'name')
+              annotations = agent.dig('metadata', 'annotations')
+              annotations = annotations.respond_to?(:to_h) ? annotations.to_h : (annotations || {})
 
               puts
 
-              # Learning enablement status
-              learning_enabled = !annotations.key?(Constants::KubernetesLabels::LEARNING_DISABLED_LABEL)
-              status_color = learning_enabled ? :green : :yellow
-              status_text = learning_enabled ? 'Enabled' : 'Disabled'
+              # Display Agent Status box
+              display_agent_status_box(agent, cluster_name)
+              puts
 
-              highlighted_box(
-                title: 'Learning Status',
-                rows: {
-                  'Agent' => pastel.white.bold(agent_name),
-                  'Cluster' => cluster_name,
-                  'Learning' => pastel.send(status_color).bold(status_text),
-                  'Last Updated' => agent.dig('metadata', 'resourceVersion') || 'Unknown'
-                }
-              )
+              # Display Learning Status box
+              display_learning_status_box(agent, learning_status, annotations)
               puts
 
               # If learning status ConfigMap exists, show detailed information
               if learning_status
                 display_detailed_learning_status(learning_status)
               else
-                puts pastel.dim('No learning status data available yet.')
-                puts pastel.dim('Learning data will appear after the agent has run and the operator has analyzed its behavior.')
-                puts
+                learning_enabled = !annotations.key?(Constants::KubernetesLabels::LEARNING_DISABLED_LABEL)
+                display_learning_explanation(learning_enabled)
               end
-
-              # Show next steps
-              puts pastel.white.bold('Available Commands:')
-              if learning_enabled
-                puts pastel.dim("  aictl agent learning disable #{agent_name}")
-              else
-                puts pastel.dim("  aictl agent learning enable #{agent_name}")
-              end
-              puts pastel.dim("  aictl agent versions #{agent_name}")
-              puts pastel.dim("  aictl agent inspect #{agent_name}")
             end
 
             def display_detailed_learning_status(learning_status)
@@ -206,11 +190,7 @@ module LanguageOperator
                     executions = task_info['executions'] || 0
                     status = task_info['status'] || 'neural'
 
-                    confidence_color = if confidence >= 85
-                                         :green
-                                       else
-                                         confidence >= 70 ? :yellow : :red
-                                       end
+                    confidence_color = determine_confidence_color(confidence)
 
                     puts "  #{pastel.cyan(task_name)}"
                     puts "    Status: #{format_task_status(status)}"
@@ -261,7 +241,8 @@ module LanguageOperator
               agent = client.get_resource(RESOURCE_AGENT, name, namespace)
 
               # Add annotation
-              annotations = agent.dig('metadata', 'annotations') || {}
+              annotations = agent.dig('metadata', 'annotations')
+              annotations = annotations.respond_to?(:to_h) ? annotations.to_h : (annotations || {})
               annotations[annotation_key] = annotation_value
               agent['metadata']['annotations'] = annotations
 
@@ -274,13 +255,151 @@ module LanguageOperator
               agent = client.get_resource(RESOURCE_AGENT, name, namespace)
 
               # Remove annotation
-              annotations = agent.dig('metadata', 'annotations') || {}
+              annotations = agent.dig('metadata', 'annotations')
+              annotations = annotations.respond_to?(:to_h) ? annotations.to_h : (annotations || {})
               annotations.delete(annotation_key)
               agent['metadata']['annotations'] = annotations
 
               # Update the agent
               client.update_resource(agent)
             end
+
+            def format_agent_timestamp(agent)
+              created_time = agent.dig('metadata', 'creationTimestamp')
+              return 'Unknown' unless created_time
+
+              begin
+                Time.parse(created_time).strftime('%Y-%m-%d %H:%M:%S UTC')
+              rescue StandardError
+                'Unknown'
+              end
+            end
+
+            def display_agent_status_box(agent, cluster_name)
+              agent_name = agent.dig('metadata', 'name')
+              timestamp = format_agent_timestamp(agent)
+
+              # Get agent operational status
+              status = agent['status']
+              if status && status['conditions']
+                ready_condition = status['conditions'].find { |c| c['type'] == 'Ready' }
+                if ready_condition
+                  begin
+                    last_activity = Time.parse(ready_condition['lastTransitionTime']).strftime('%Y-%m-%d %H:%M:%S UTC')
+                    status_text = ready_condition['status'] == 'True' ? 'Ready' : 'Not Ready'
+                    status_colored = ready_condition['status'] == 'True' ? pastel.green(status_text) : pastel.yellow(status_text)
+                  rescue StandardError
+                    last_activity = 'Unknown'
+                    status_colored = pastel.dim('Unknown')
+                  end
+                else
+                  last_activity = 'Unknown'
+                  status_colored = pastel.dim('Unknown')
+                end
+              else
+                last_activity = 'Unknown'
+                status_colored = pastel.dim('Unknown')
+              end
+
+              highlighted_box(
+                title: 'Agent Status',
+                color: :yellow,
+                rows: {
+                  'Name' => pastel.white.bold(agent_name),
+                  'Cluster' => cluster_name,
+                  'Created' => timestamp,
+                  'Last Activity' => last_activity,
+                  'Status' => status_colored
+                }
+              )
+            end
+
+            def display_learning_status_box(_agent, learning_status, annotations)
+              learning_enabled = !annotations.key?(Constants::KubernetesLabels::LEARNING_DISABLED_LABEL)
+              status_color = learning_enabled ? :green : :yellow
+              status_text = learning_enabled ? 'Enabled' : 'Disabled'
+
+              # Parse execution summary from ConfigMap if available
+              execution_summary = parse_execution_summary(learning_status)
+
+              if execution_summary
+                total_executions = execution_summary['totalExecutions'] || 0
+                learning_threshold = execution_summary['learningThreshold'] || 10
+                execution_summary['successRate'] || 0.0
+                last_execution = execution_summary['lastExecution']
+
+                runs_processed = "#{total_executions}/#{learning_threshold}"
+                progress_percent = [(total_executions.to_f / learning_threshold * 100).round, 100].min
+                progress = "#{progress_percent}% toward learning threshold"
+
+                last_run = if last_execution && !last_execution.empty?
+                             begin
+                               Time.parse(last_execution).strftime('%Y-%m-%d %H:%M:%S UTC')
+                             rescue StandardError
+                               'Unknown'
+                             end
+                           else
+                             'No executions yet'
+                           end
+              else
+                runs_processed = 'No data'
+                progress = 'Waiting for agent executions'
+                last_run = 'No executions yet'
+              end
+
+              highlighted_box(
+                title: 'Learning Status',
+                color: :cyan,
+                rows: {
+                  'Learning' => pastel.send(status_color).bold(status_text),
+                  'Threshold' => "#{pastel.cyan('10 successful runs')} (auto-learning trigger)",
+                  'Confidence Target' => "#{pastel.cyan('85%')} (pattern detection)",
+                  'Runs Processed' => runs_processed,
+                  'Progress' => progress,
+                  'Last Execution' => last_run
+                }
+              )
+            end
+
+            def display_learning_explanation(learning_enabled)
+              if learning_enabled
+                puts pastel.dim('Learning is enabled and will begin automatically after the agent completes 10 successful runs.')
+                puts pastel.dim('Neural tasks will be analyzed for patterns and converted to symbolic implementations.')
+              else
+                puts pastel.yellow('Learning is disabled for this agent.')
+                puts pastel.dim('Enable learning to allow automatic task optimization after sufficient executions.')
+              end
+              puts
+              puts pastel.dim('Note: Execution metrics will be available once the agent starts running and')
+              puts pastel.dim('the operator begins collecting telemetry data.')
+              puts
+            end
+
+            def determine_confidence_color(confidence)
+              if confidence >= 85
+                :green
+              elsif confidence >= 70
+                :yellow
+              else
+                :red
+              end
+            end
+
+            def parse_execution_summary(learning_status)
+              return nil unless learning_status
+
+              data = learning_status['data']
+              return nil unless data
+
+              execution_summary_json = data['execution-summary']
+              return nil unless execution_summary_json
+
+              begin
+                JSON.parse(execution_summary_json)
+              rescue StandardError
+                nil
+              end
+            end
           end
         end
       end

data/lib/language_operator/cli/commands/cluster.rb

@@ -58,8 +58,8 @@ module LanguageOperator
             unless k8s.namespace_exists?(namespace)
               Formatters::ProgressFormatter.with_spinner("Creating namespace '#{namespace}'") do
                 k8s.create_namespace(namespace, labels: Constants::KubernetesLabels.cluster_management_labels.merge(
-                                       Constants::KubernetesLabels::CLUSTER_LABEL => name
-                                     ))
+                  Constants::KubernetesLabels::CLUSTER_LABEL => name
+                ))
               end
             end
 

data/lib/language_operator/cli/commands/status.rb

@@ -35,13 +35,13 @@ module LanguageOperator
 
               # Format cluster info using UxHelper
               logo(title: 'cluster status')
-              
+
               if cluster_resource
                 # Use actual cluster resource data
                 status = cluster_resource.dig('status', 'phase') || 'Unknown'
                 domain = cluster_resource.dig('spec', 'domain')
                 created = cluster_resource.dig('metadata', 'creationTimestamp')
-                
+
                 format_cluster_details(
                   name: current_cluster,
                   namespace: cluster_config[:namespace],

data/lib/language_operator/cli/commands/system/synthesize.rb

@@ -55,7 +55,7 @@ module LanguageOperator
               option :model, type: :string, desc: 'Model to use for synthesis (defaults to first available in cluster)'
               option :dry_run, type: :boolean, default: false, desc: 'Show prompt without calling LLM'
               option :raw, type: :boolean, default: false, desc: 'Output only the raw code without formatting'
-              
+
               def synthesize(instructions = nil)
                 handle_command_error('synthesize agent') do
                   # Read instructions from STDIN if not provided as argument

data/lib/language_operator/cli/formatters/value_formatter.rb

@@ -51,7 +51,7 @@ module LanguageOperator
         #   ValueFormatter.time_ago(Time.now - 300) # => "5m ago"
         def self.time_ago(past_time)
           diff = Time.now - past_time
-          
+
           if diff < 0
             'in the future' # Edge case for clock skew
           elsif diff < SECONDS_PER_MINUTE

data/lib/language_operator/cli/helpers/ux_helper.rb

@@ -139,8 +139,7 @@ module LanguageOperator
         # @example
         #   puts highlight_ruby_code("puts 'Hello, world!'")
         def highlight_ruby_code(code_content)
-          highlighted = rouge_formatter.format(rouge_lexer.lex(code_content))
-          highlighted
+          rouge_formatter.format(rouge_lexer.lex(code_content))
         end
 
         def logo(title: nil, sparkle: false)
@@ -409,7 +408,7 @@ module LanguageOperator
         def format_resource_details(type:, name:, common_fields: {}, optional_fields: {})
           rows = { 'Name' => pastel.white.bold(name) }
           rows.merge!(common_fields)
-          
+
           optional_fields.each do |key, value|
             case key
             when 'Domain'
@@ -418,7 +417,7 @@ module LanguageOperator
               rows[key] = value if value
             end
           end
-          
+
           highlighted_box(
             title: "Language#{type}",
             rows: rows.compact

data/lib/language_operator/config.rb

@@ -191,7 +191,7 @@ module LanguageOperator
     #   Config.get_int('MAX_WORKERS', default: 4)
     def self.get_int(*keys, default: nil)
       keys.each do |key|
-        value = ENV[key.to_s]
+        value = ENV.fetch(key.to_s, nil)
         next unless value
 
         begin
@@ -220,7 +220,7 @@ module LanguageOperator
     #   Config.get_bool('USE_TLS', 'ENABLE_TLS', default: true)
     def self.get_bool(*keys, default: false)
       keys.each do |key|
-        value = ENV[key.to_s]
+        value = ENV.fetch(key.to_s, nil)
         next unless value
 
         return %w[true 1 yes on].include?(value.to_s.downcase)
@@ -240,7 +240,7 @@ module LanguageOperator
     #   Config.get_array('ALLOWED_HOSTS', separator: ',')
     def self.get_array(*keys, default: [], separator: ',')
       keys.each do |key|
-        value = ENV[key.to_s]
+        value = ENV.fetch(key.to_s, nil)
         next unless value
         next if value.empty?
 

data/lib/language_operator/constants/kubernetes_labels.rb

@@ -61,7 +61,7 @@ module LanguageOperator
         # Build a label selector string for finding tool pods
         #
         # @param tool_name [String] The tool name
-        # @return [String] Label selector string for kubectl commands  
+        # @return [String] Label selector string for kubectl commands
         def tool_selector(tool_name)
           "#{TOOL_LABEL}=#{tool_name}"
         end
@@ -77,4 +77,4 @@ module LanguageOperator
       end
     end
   end
-end
+end

data/lib/language_operator/dsl/task_definition.rb

@@ -2,6 +2,7 @@
 
 require_relative '../loggable'
 require_relative '../type_coercion'
+require_relative '../agent/task_executor'
 
 module LanguageOperator
   module Dsl
@@ -148,7 +149,7 @@ module LanguageOperator
       #
       # @param params [Hash] Input parameters
       # @return [Hash] Validated and coerced parameters
-      # @raise [ArgumentError] If validation fails
+      # @raise [LanguageOperator::Agent::TaskValidationError] If validation fails
       def validate_inputs(params)
         params = params.transform_keys(&:to_sym)
         validated = {}
@@ -157,7 +158,12 @@ module LanguageOperator
           key_sym = key.to_sym
           value = params[key_sym]
 
-          raise ArgumentError, "Missing required input parameter: #{key}" if value.nil?
+          if value.nil?
+            original_error = ArgumentError.new("Missing required input parameter: #{key}")
+            raise LanguageOperator::Agent::TaskValidationError.new(@name,
+                                                                    "Missing required input parameter: #{key}",
+                                                                    original_error)
+          end
 
           validated[key_sym] = coerce_value(value, type, "input parameter '#{key}'")
         end
@@ -173,7 +179,7 @@ module LanguageOperator
       #
       # @param result [Hash] Output values
       # @return [Hash] Validated and coerced outputs
-      # @raise [ArgumentError] If validation fails
+      # @raise [LanguageOperator::Agent::TaskValidationError] If validation fails
       def validate_outputs(result)
         return result if @outputs_schema.empty? # No schema = no validation
 
@@ -184,7 +190,12 @@ module LanguageOperator
           key_sym = key.to_sym
           value = result[key_sym]
 
-          raise ArgumentError, "Missing required output field: #{key}" if value.nil?
+          if value.nil?
+            original_error = ArgumentError.new("Missing required output field: #{key}")
+            raise LanguageOperator::Agent::TaskValidationError.new(@name,
+                                                                    "Missing required output field: #{key}",
+                                                                    original_error)
+          end
 
           validated[key_sym] = coerce_value(value, type, "output field '#{key}'")
         end
@@ -275,12 +286,12 @@ module LanguageOperator
       # @param type [String] Target type
       # @param context [String] Context for error messages
       # @return [Object] Coerced value
-      # @raise [ArgumentError] If coercion fails
+      # @raise [LanguageOperator::Agent::TaskValidationError] If coercion fails
       def coerce_value(value, type, context)
         TypeCoercion.coerce(value, type)
       rescue ArgumentError => e
-        # Re-raise with context added
-        raise ArgumentError, "#{e.message} for #{context}"
+        # Re-raise as TaskValidationError with context added
+        raise LanguageOperator::Agent::TaskValidationError.new(@name, "#{e.message} for #{context}", e)
       end
 
       # Convert schema hash to JSON Schema format

data/lib/language_operator/instrumentation/task_tracer.rb

@@ -87,13 +87,19 @@ module LanguageOperator
       # @param prompt [String] The generated prompt
       # @param validated_inputs [Hash] Validated input parameters
       # @return [Hash] Span attributes
-      def neural_task_attributes(_task, prompt, validated_inputs)
+      def neural_task_attributes(task, prompt, validated_inputs)
         attributes = {
           'gen_ai.operation.name' => 'chat',
           'gen_ai.system' => determine_genai_system,
           'gen_ai.prompt.size' => prompt.bytesize
         }
 
+        # Add agent context (CRITICAL for learning system)
+        add_agent_context_attributes(attributes)
+
+        # Add task identification
+        attributes['task.name'] = task.name.to_s if task.respond_to?(:name) && task.name
+
         # Add model if available
         if @agent.respond_to?(:config) && @agent.config
           model = @agent.config.dig('llm', 'model') || @agent.config['model']
@@ -130,10 +136,19 @@ module LanguageOperator
       # @param task [TaskDefinition] The task definition
       # @return [Hash] Span attributes
       def symbolic_task_attributes(task)
-        {
+        attributes = {
           'task.execution.type' => 'symbolic',
-          'task.execution.has_block' => task.execute_block ? 'true' : 'false'
+          'task.execution.has_block' => task.execute_block ? 'true' : 'false',
+          'gen_ai.operation.name' => 'execute_task'
         }
+
+        # Add agent context (CRITICAL for learning system)
+        add_agent_context_attributes(attributes)
+
+        # Add task identification
+        attributes['task.name'] = task.name.to_s if task.respond_to?(:name) && task.name
+
+        attributes
       end
 
       # Record token usage from LLM response on span
@@ -265,6 +280,9 @@ module LanguageOperator
           'gen_ai.tool.name' => extract_tool_name(tool_call)
         }
 
+        # Add agent context (CRITICAL for learning system)
+        add_agent_context_attributes(attributes)
+
         # Add tool call ID if available
         attributes['gen_ai.tool.call.id'] = tool_call.id.to_s if tool_call.respond_to?(:id) && tool_call.id
 
@@ -341,6 +359,29 @@ module LanguageOperator
       rescue StandardError => e
         logger&.warn('Failed to record output metadata', error: e.message)
       end
+
+      # Add agent context attributes to span attributes hash
+      #
+      # Ensures all spans include agent identification required for learning system.
+      # This is redundant with resource attributes but provides explicit visibility.
+      #
+      # @param attributes [Hash] Span attributes hash to modify
+      def add_agent_context_attributes(attributes)
+        # Agent name is CRITICAL for learning controller to track executions
+        if (agent_name = ENV.fetch('AGENT_NAME', nil))
+          attributes['agent.name'] = agent_name
+        end
+
+        # Add agent mode for better traceability
+        if (agent_mode = ENV.fetch('AGENT_MODE', nil))
+          attributes['agent.mode'] = agent_mode
+        end
+
+        # Add cluster context if available
+        if (cluster_name = ENV.fetch('AGENT_CLUSTER', nil))
+          attributes['agent.cluster'] = cluster_name
+        end
+      end
     end
     # rubocop:enable Metrics/ModuleLength
   end

data/lib/language_operator/kubernetes/client.rb

@@ -3,6 +3,7 @@
 require 'k8s-ruby'
 require 'yaml'
 require_relative '../utils/secure_path'
+require_relative '../agent/event_config'
 
 module LanguageOperator
   module Kubernetes
@@ -163,6 +164,72 @@ module LanguageOperator
         create_resource(resource)
       end
 
+      # Create a Kubernetes Event
+      # @param event [Hash] Event resource hash
+      # @return [K8s::Resource] Created event resource
+      def create_event(event)
+        # Ensure proper apiVersion and kind for events
+        event = event.merge({
+                              'apiVersion' => 'v1',
+                              'kind' => 'Event'
+                            })
+        create_resource(event)
+      end
+
+      # Emit an execution event for agent task completion
+      # @param task_name [String] Name of the executed task
+      # @param success [Boolean] Whether task succeeded
+      # @param duration_ms [Float] Execution duration in milliseconds
+      # @param metadata [Hash] Additional metadata to include
+      # @return [K8s::Resource, nil] Created event resource or nil if disabled
+      def emit_execution_event(task_name, success:, duration_ms:, metadata: {})
+        # Check if events are enabled based on configuration
+        event_config = Agent::EventConfig.load
+        event_type = success ? :success : :failure
+        return nil unless Agent::EventConfig.should_emit?(event_type, event_config)
+
+        agent_name = ENV.fetch('AGENT_NAME', nil)
+        agent_namespace = ENV.fetch('AGENT_NAMESPACE', current_namespace)
+
+        return nil unless agent_name && agent_namespace
+
+        timestamp = Time.now.to_i
+        event_name = "#{agent_name}-task-#{task_name}-#{timestamp}"
+
+        event = {
+          'metadata' => {
+            'name' => event_name,
+            'namespace' => agent_namespace,
+            'labels' => {
+              'app.kubernetes.io/name' => 'language-operator',
+              'app.kubernetes.io/component' => 'agent',
+              'langop.io/agent-name' => agent_name,
+              'langop.io/task-name' => task_name.to_s
+            }
+          },
+          'involvedObject' => {
+            'kind' => 'LanguageAgent',
+            'name' => agent_name,
+            'namespace' => agent_namespace,
+            'apiVersion' => 'langop.io/v1alpha1'
+          },
+          'reason' => success ? 'TaskCompleted' : 'TaskFailed',
+          'message' => build_event_message(task_name, success, duration_ms, metadata, event_config),
+          'type' => success ? 'Normal' : 'Warning',
+          'firstTimestamp' => Time.now.utc.iso8601,
+          'lastTimestamp' => Time.now.utc.iso8601,
+          'source' => {
+            'component' => 'language-operator-agent'
+          }
+        }
+
+        create_event(event)
+      rescue StandardError => e
+        # Log error but don't fail task execution
+        warn "Failed to emit execution event: #{e.message}"
+        nil
+      end
+
       # Check if operator is installed
       def operator_installed?
         # Check if LanguageCluster CRD exists
@@ -184,6 +251,48 @@ module LanguageOperator
 
       private
 
+      # Build event message for task execution
+      # @param task_name [String] Task name
+      # @param success [Boolean] Whether task succeeded
+      # @param duration_ms [Float] Execution duration in milliseconds
+      # @param metadata [Hash] Additional metadata
+      # @param event_config [Hash] Event configuration
+      # @return [String] Formatted event message
+      def build_event_message(task_name, success, duration_ms, metadata = {}, event_config = nil)
+        event_config ||= Agent::EventConfig.load
+        content_config = Agent::EventConfig.content_config(event_config)
+
+        status = success ? 'completed successfully' : 'failed'
+        message = "Task '#{task_name}' #{status} in #{duration_ms.round(2)}ms"
+
+        # Include metadata if configured
+        if content_config[:include_task_metadata] && metadata.any?
+          # Filter metadata based on configuration
+          filtered_metadata = metadata.dup
+
+          # Remove error details if not configured to include them
+          unless content_config[:include_error_details]
+            filtered_metadata.delete('error_type')
+            filtered_metadata.delete('error_category')
+          end
+
+          if filtered_metadata.any?
+            details = filtered_metadata.map { |k, v| "#{k}: #{v}" }.join(', ')
+            message += " (#{details})"
+          end
+        end
+
+        # Truncate if configured and message is too long
+        if content_config[:truncate_long_messages] &&
+           message.length > content_config[:max_message_length]
+          max_length = content_config[:max_message_length]
+          truncated_length = message.length - max_length
+          message = message[0...max_length] + "... (truncated #{truncated_length} chars)"
+        end
+
+        message
+      end
+
       # Build singleton instance with automatic config detection
       def self.build_singleton
         if in_cluster?
@@ -266,6 +375,8 @@ module LanguageOperator
           'statefulsets'
         when 'cronjob'
           'cronjobs'
+        when 'event'
+          'events'
         else
           # Generic pluralization - add 's'
           "#{kind.downcase}s"