language-operator 0.1.81 → 0.1.82

data/lib/language_operator/kubernetes/client.rb

@@ -3,13 +3,13 @@
 require 'k8s-ruby'
 require 'yaml'
 require_relative '../utils/secure_path'
-require_relative '../agent/event_config'
+require_relative '../utils/org_context'
 
 module LanguageOperator
   module Kubernetes
     # Kubernetes client wrapper for interacting with language-operator resources
     class Client
-      attr_reader :client
+      attr_reader :client, :context
 
       # Get singleton K8s client instance with automatic config detection
       # @return [LanguageOperator::Kubernetes::Client] Client instance
@@ -164,72 +164,6 @@ 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
@@ -242,57 +176,67 @@ module LanguageOperator
       # Get operator version
       def operator_version
         deployment = @client.api('apps/v1')
-                            .resource('deployments', namespace: 'kube-system')
+                            .resource('deployments', namespace: 'language-operator')
                             .get(Constants::KubernetesLabels::PROJECT_NAME)
-        deployment.dig('metadata', 'labels', Constants::KubernetesLabels::VERSION) || 'unknown'
+        
+        # Try to get version from Helm chart label first, then fallback to app version
+        version = deployment.dig('metadata', 'labels', 'helm.sh/chart')&.split('-')&.last ||
+                  deployment.dig('metadata', 'labels', Constants::KubernetesLabels::VERSION)
+        
+        return version if version && version != 'latest'
+        
+        'unknown'
       rescue K8s::Error::NotFound
         nil
       end
 
-      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
+      # Get the current organization ID from cluster resources
+      #
+      # @return [String, nil] Organization ID or nil if not found/legacy mode
+      def current_org_id
+        Utils::OrgContext.current_org_id(self)
+      end
 
-          if filtered_metadata.any?
-            details = filtered_metadata.map { |k, v| "#{k}: #{v}" }.join(', ')
-            message += " (#{details})"
-          end
-        end
+      # Check if the current cluster has organization context
+      #
+      # @return [Boolean] True if organization context is available
+      def org_context?
+        !current_org_id.nil?
+      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
+      # Get organization information for cluster listing
+      #
+      # @return [Hash] Organization info with id, namespace, and display name
+      def org_info
+        org_id = current_org_id
+        return { id: nil, display: 'legacy' } unless org_id
+
+        {
+          id: org_id,
+          display: org_id[0..7] # Show first 8 chars for readability
+        }
+      end
 
-        message
+      # List namespaces with optional label selector
+      #
+      # @param label_selector [String, nil] Label selector for filtering
+      # @return [Array<Hash>] Array of namespace resources
+      def list_namespaces(label_selector: nil)
+        namespaces_api = @client.api('v1').resource('namespaces')
+        result = if label_selector
+                   namespaces_api.list(labelSelector: label_selector)
+                 else
+                   namespaces_api.list
+                 end
+        # k8s-ruby returns an Array directly, not an object with .items
+        Array(result)
+      rescue StandardError => e
+        warn "Warning: Could not list namespaces: #{e.message}" if ENV['DEBUG']
+        []
       end
 
+      private
+
       # Build singleton instance with automatic config detection
       def self.build_singleton
         if in_cluster?

data/lib/language_operator/kubernetes/resource_builder.rb

@@ -8,7 +8,7 @@ module LanguageOperator
     class ResourceBuilder
       class << self
         # Build a LanguageCluster resource
-        def language_cluster(name, namespace: nil, domain: nil, labels: {})
+        def language_cluster(name, namespace: nil, domain: nil, labels: {}, k8s_client: nil)
           spec = {
             'namespace' => namespace || name,
             'resourceQuota' => default_resource_quota,
@@ -16,12 +16,12 @@ module LanguageOperator
           }
           spec['domain'] = domain if domain && !domain.empty?
 
-          build_resource('LanguageCluster', name, spec, namespace: namespace, labels: labels)
+          build_resource('LanguageCluster', name, spec, namespace: namespace, labels: labels, k8s_client: k8s_client)
         end
 
         # Build a LanguageAgent resource
         def language_agent(name, instructions:, cluster: nil, cluster_ref: nil, schedule: nil, persona: nil, tools: [], models: [],
-                           mode: nil, workspace: true, labels: {})
+                           mode: nil, workspace: true, labels: {}, k8s_client: nil)
           # Determine mode: reactive, scheduled, or autonomous
           spec_mode = mode || (schedule ? 'scheduled' : 'autonomous')
 
@@ -40,41 +40,41 @@ module LanguageOperator
           # Enable workspace by default for state persistence
           spec['workspace'] = { 'enabled' => workspace } if workspace
 
-          build_resource('LanguageAgent', name, spec, namespace: cluster, cluster_ref: cluster_ref, labels: labels)
+          build_resource('LanguageAgent', name, spec, namespace: cluster, cluster_ref: cluster_ref, labels: labels, k8s_client: k8s_client)
         end
 
         # Build a LanguageTool resource
-        def language_tool(name, type:, config: {}, cluster: nil, cluster_ref: nil, labels: {})
+        def language_tool(name, type:, config: {}, cluster: nil, cluster_ref: nil, labels: {}, k8s_client: nil)
           build_resource('LanguageTool', name, {
                            'type' => type,
                            'config' => config
-                         }, namespace: cluster, cluster_ref: cluster_ref, labels: labels)
+                         }, namespace: cluster, cluster_ref: cluster_ref, labels: labels, k8s_client: k8s_client)
         end
 
         # Build a LanguageModel resource
-        def language_model(name, provider:, model:, endpoint: nil, cluster: nil, cluster_ref: nil, labels: {})
+        def language_model(name, provider:, model:, endpoint: nil, cluster: nil, cluster_ref: nil, labels: {}, k8s_client: nil)
           spec = {
             'provider' => provider,
             'modelName' => model
           }
           spec['endpoint'] = endpoint if endpoint
 
-          build_resource('LanguageModel', name, spec, namespace: cluster, cluster_ref: cluster_ref, labels: labels)
+          build_resource('LanguageModel', name, spec, namespace: cluster, cluster_ref: cluster_ref, labels: labels, k8s_client: k8s_client)
         end
 
         # Build a LanguagePersona resource
-        def language_persona(name, description:, tone:, system_prompt:, cluster: nil, labels: {})
+        def language_persona(name, description:, tone:, system_prompt:, cluster: nil, cluster_ref: nil, labels: {}, k8s_client: nil)
           build_resource('LanguagePersona', name, {
                            'displayName' => name.split('-').map(&:capitalize).join(' '),
                            'description' => description,
                            'tone' => tone,
                            'systemPrompt' => system_prompt
-                         }, namespace: cluster, labels: labels)
+                         }, namespace: cluster, cluster_ref: cluster_ref, labels: labels, k8s_client: k8s_client)
         end
 
         # Build a LanguagePersona resource with full spec control
-        def build_persona(name:, spec:, namespace: nil, labels: {})
-          build_resource('LanguagePersona', name, spec, namespace: namespace, labels: labels)
+        def build_persona(name:, spec:, namespace: nil, cluster_ref: nil, labels: {}, k8s_client: nil)
+          build_resource('LanguagePersona', name, spec, namespace: namespace, cluster_ref: cluster_ref, labels: labels, k8s_client: k8s_client)
         end
 
         # Build a Kubernetes Service resource for a reactive agent
@@ -123,11 +123,14 @@ module LanguageOperator
         # @param namespace [String, nil] The namespace (defaults to 'default')
         # @param cluster_ref [String, nil] The cluster reference for lifecycle management
         # @param labels [Hash] Additional labels to merge with defaults
+        # @param k8s_client [Client, nil] Kubernetes client for org context detection
         # @return [Hash] Complete Kubernetes resource manifest
-        def build_resource(kind, name, spec, namespace: nil, cluster_ref: nil, labels: {})
+        def build_resource(kind, name, spec, namespace: nil, cluster_ref: nil, labels: {}, k8s_client: nil)
           # Add clusterRef to spec if provided for proper lifecycle management
           spec = spec.merge('clusterRef' => cluster_ref) if cluster_ref
-          {
+
+          # Build base resource
+          resource = {
             'apiVersion' => 'langop.io/v1alpha1',
             'kind' => kind,
             'metadata' => {
@@ -137,6 +140,35 @@ module LanguageOperator
             },
             'spec' => spec
           }
+
+          # Add organization context if available
+          add_org_context(resource, k8s_client)
+
+          resource
+        end
+
+        # Add organization context to a resource
+        #
+        # @param resource [Hash] Kubernetes resource manifest
+        # @param k8s_client [Client, nil] Kubernetes client for org context detection
+        # @return [Hash] Resource with organization labels/annotations added
+        def add_org_context(resource, k8s_client = nil)
+          return resource unless k8s_client
+
+          org_id = k8s_client.current_org_id
+          return resource unless org_id
+
+          # Add organization labels
+          resource['metadata']['labels'] ||= {}
+          resource['metadata']['labels']['langop.io/organization-id'] = org_id
+
+          # Add creation annotations
+          resource['metadata']['annotations'] ||= {}
+          # NOTE: We could add user email here if we had dashboard integration
+          # For now, just mark as CLI-created
+          resource['metadata']['annotations']['langop.io/created-by'] = 'langop'
+
+          resource
         end
 
         def default_labels

data/lib/language_operator/templates/schema/agent_dsl_openapi.yaml

@@ -2,7 +2,7 @@
 :openapi: 3.0.3
 :info:
   :title: Language Operator Agent API
-  :version: 0.1.73
+  :version: 0.1.82
   :description: HTTP API endpoints exposed by Language Operator reactive agents
   :contact:
     :name: Language Operator

data/lib/language_operator/templates/schema/agent_dsl_schema.json

@@ -3,7 +3,7 @@
   "$id": "https://github.com/language-operator/language-operator-gem/schema/agent-dsl.json",
   "title": "Language Operator Agent DSL",
   "description": "Schema for defining autonomous AI agents using the Language Operator DSL",
-  "version": "0.1.73",
+  "version": "0.1.82",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/utils/org_context.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module Utils
+    # Utility for detecting organization context from cluster resources
+    class OrgContext
+      ORG_ID_LABEL = 'langop.io/organization-id'
+
+      # Cache organization ID to avoid repeated API calls
+      @cache = {}
+      @cache_mutex = Mutex.new
+
+      class << self
+        # Get the current organization ID from cluster resources
+        #
+        # @param k8s_client [LanguageOperator::Kubernetes::Client] Kubernetes client
+        # @return [String, nil] Organization ID or nil if not found
+        def current_org_id(k8s_client)
+          return nil unless k8s_client
+
+          cache_key = "#{k8s_client.context}:#{k8s_client.current_namespace}"
+
+          @cache_mutex.synchronize do
+            # Return cached result if available and not expired
+            cached = @cache[cache_key]
+            return cached[:org_id] if cached && Time.now - cached[:timestamp] < cache_ttl
+
+            # Detect org ID from cluster resources
+            org_id = detect_org_id(k8s_client)
+
+            # Cache the result
+            @cache[cache_key] = {
+              org_id: org_id,
+              timestamp: Time.now
+            }
+
+            org_id
+          end
+        rescue StandardError => e
+          # Log error but don't fail - return nil for legacy mode
+          warn "Warning: Could not detect organization context: #{e.message}" if ENV['DEBUG']
+          nil
+        end
+
+        # Clear the organization context cache
+        def clear_cache!
+          @cache_mutex.synchronize { @cache.clear }
+        end
+
+        # Get organization ID from a specific resource
+        #
+        # @param resource [Hash] Kubernetes resource manifest
+        # @return [String, nil] Organization ID from labels
+        def org_id_from_resource(resource)
+          resource.dig('metadata', 'labels', ORG_ID_LABEL)
+        end
+
+        # Check if a resource has organization context
+        #
+        # @param resource [Hash] Kubernetes resource manifest
+        # @return [Boolean] True if resource has org ID label
+        def org_context?(resource)
+          !org_id_from_resource(resource).nil?
+        end
+
+        private
+
+        # Detect organization ID by examining cluster resources
+        #
+        # @param k8s_client [LanguageOperator::Kubernetes::Client] Kubernetes client
+        # @return [String, nil] Organization ID or nil if not found
+        def detect_org_id(k8s_client)
+          # Try to find organization ID from any language operator resource
+          # Check in order of likelihood: LanguageCluster, LanguageAgent, LanguageModel
+
+          %w[LanguageCluster LanguageAgent LanguageModel LanguagePersona].each do |kind|
+            resources = k8s_client.list_resources(kind)
+            next if resources.empty?
+
+            # Look for org ID in any resource of this type
+            resources.each do |resource|
+              org_id = org_id_from_resource(resource)
+              return org_id if org_id
+            end
+          end
+
+          nil
+        rescue StandardError
+          # If we can't query resources, assume legacy mode
+          nil
+        end
+
+        # Cache TTL in seconds (5 minutes)
+        def cache_ttl
+          300
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LanguageOperator
-  VERSION = '0.1.81'
+  VERSION = '0.1.82'
 end

data/synth/001/Makefile

@@ -1,7 +1,7 @@
 .PHONY: create code logs clean
 
 AGENT := s001
-AICTL := bundle exec ../../bin/aictl agent
+AICTL := bundle exec ../../bin/langop agent
 TOOLS := workspace
 
 create:

data/synth/002/Makefile

@@ -1,7 +1,7 @@
 .PHONY: create code logs clean
 
 AGENT := s002
-AICTL := bundle exec ../../bin/aictl agent
+AICTL := bundle exec ../../bin/langop agent
 TOOLS := workspace
 
 create:

data/synth/003/Makefile

@@ -1,7 +1,7 @@
 .PHONY: create code logs clean
 
 AGENT := s003
-AICTL := bundle exec ../../bin/aictl agent
+AICTL := bundle exec ../../bin/langop agent
 TOOLS := workspace
 
 create:

data/synth/004/Makefile

@@ -1,7 +1,7 @@
 .PHONY: create code logs clean events validate run
 
 AGENT := s004
-AICTL := bundle exec ../../bin/aictl agent
+AICTL := bundle exec ../../bin/langop agent
 TOOLS := workspace
 
 create: