language-operator 0.1.31 → 0.1.35

data/lib/language_operator/agent.rb

@@ -2,6 +2,7 @@
 
 require_relative 'agent/base'
 require_relative 'agent/executor'
+require_relative 'agent/task_executor'
 require_relative 'agent/scheduler'
 require_relative 'agent/web_server'
 require_relative 'dsl'
@@ -23,6 +24,13 @@ module LanguageOperator
   #   agent = LanguageOperator::Agent::Base.new(config)
   #   agent.execute_goal("Summarize daily news")
   module Agent
+    # Module-level logger for Agent framework
+    @logger = LanguageOperator::Logger.new(component: 'Agent')
+
+    def self.logger
+      @logger
+    end
+
     # Run the default agent based on environment configuration
     #
     # @param config_path [String] Path to configuration file
@@ -53,9 +61,8 @@ module LanguageOperator
       if agent_code_path && File.exist?(agent_code_path)
         load_synthesized_agent(agent, agent_code_path, agent_name)
       else
-        LanguageOperator::Logger.info('No synthesized code found, running in standard mode',
-                                      component: 'Agent',
-                                      agent_code_path: agent_code_path)
+        logger.info('No synthesized code found, running in standard mode',
+                    agent_code_path: agent_code_path)
         agent.run
       end
     end
@@ -67,10 +74,9 @@ module LanguageOperator
     # @param agent_name [String] Name of agent definition
     # @return [void]
     def self.load_synthesized_agent(agent, code_path, agent_name)
-      LanguageOperator::Logger.info('DSL code loading',
-                                    component: 'Agent',
-                                    path: code_path,
-                                    agent_name: agent_name)
+      logger.info('DSL code loading',
+                  path: code_path,
+                  agent_name: agent_name)
 
       # Load synthesized DSL code
       LanguageOperator::Dsl.load_agent_file(code_path)
@@ -79,10 +85,9 @@ module LanguageOperator
       agent_def = LanguageOperator::Dsl.agent_registry.get(agent_name) if agent_name
 
       if agent_def
-        LanguageOperator::Logger.info('Agent definition loaded',
-                                      component: 'Agent',
-                                      agent_name: agent_name,
-                                      has_workflow: !agent_def.workflow.nil?)
+        logger.info('Agent definition loaded',
+                    agent_name: agent_name,
+                    has_workflow: !agent_def.workflow.nil?)
         run_with_definition(agent, agent_def)
       else
         log_definition_not_found(agent_name)
@@ -98,11 +103,10 @@ module LanguageOperator
     # @param agent_name [String] Name of agent
     # @return [void]
     def self.log_definition_not_found(agent_name)
-      LanguageOperator::Logger.warn('Agent definition not found in registry',
-                                    component: 'Agent',
-                                    agent_name: agent_name,
-                                    available: LanguageOperator::Dsl.agent_registry.all.map(&:name))
-      LanguageOperator::Logger.info('Falling back to autonomous mode', component: 'Agent')
+      logger.warn('Agent definition not found in registry',
+                  agent_name: agent_name,
+                  available: LanguageOperator::Dsl.agent_registry.all.map(&:name))
+      logger.info('Falling back to autonomous mode')
     end
 
     # Log agent code loading error
@@ -110,11 +114,10 @@ module LanguageOperator
     # @param error [StandardError] The error
     # @return [void]
     def self.log_load_error(error)
-      LanguageOperator::Logger.error('Failed to load agent code',
-                                     component: 'Agent',
-                                     error: error.message,
-                                     backtrace: error.backtrace[0..3])
-      LanguageOperator::Logger.info('Falling back to autonomous mode', component: 'Agent')
+      logger.error('Failed to load agent code',
+                   error: error.message,
+                   backtrace: error.backtrace[0..3])
+      logger.info('Falling back to autonomous mode')
     end
 
     # Run agent with a loaded definition
@@ -125,15 +128,34 @@ module LanguageOperator
     def self.run_with_definition(agent, agent_def)
       agent.connect!
 
+      # Check if agent uses DSL v1 (task/main) or v0 (workflow/step)
+      uses_dsl_v1 = agent_def.main&.defined?
+      uses_dsl_v0 = agent_def.workflow
+
       case agent.mode
       when 'autonomous', 'interactive'
-        # Execute workflow in autonomous mode
-        executor = LanguageOperator::Agent::Executor.new(agent)
-        executor.execute_workflow(agent_def)
+        if uses_dsl_v1
+          # DSL v1: Execute main block with task executor
+          execute_main_block(agent, agent_def)
+        elsif uses_dsl_v0
+          # DSL v0: Execute workflow in autonomous mode
+          executor = LanguageOperator::Agent::Executor.new(agent)
+          executor.execute_workflow(agent_def)
+        else
+          raise 'Agent definition must have either main block (DSL v1) or workflow (DSL v0)'
+        end
       when 'scheduled', 'event-driven'
-        # Schedule workflow execution
-        scheduler = LanguageOperator::Agent::Scheduler.new(agent)
-        scheduler.start_with_workflow(agent_def)
+        if uses_dsl_v1
+          # DSL v1: Schedule main block execution
+          scheduler = LanguageOperator::Agent::Scheduler.new(agent)
+          scheduler.start_with_main(agent_def)
+        elsif uses_dsl_v0
+          # DSL v0: Schedule workflow execution
+          scheduler = LanguageOperator::Agent::Scheduler.new(agent)
+          scheduler.start_with_workflow(agent_def)
+        else
+          raise 'Agent definition must have either main block (DSL v1) or workflow (DSL v0)'
+        end
       when 'reactive', 'http', 'webhook'
         # Start web server with webhooks, MCP tools, and chat endpoint
         web_server = LanguageOperator::Agent::WebServer.new(agent)
@@ -145,5 +167,46 @@ module LanguageOperator
         raise "Unknown agent mode: #{agent.mode}"
       end
     end
+
+    # Execute main block (DSL v1) in autonomous mode
+    #
+    # @param agent [LanguageOperator::Agent::Base] The agent instance
+    # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
+    # @return [void]
+    def self.execute_main_block(agent, agent_def)
+      # Build executor config from agent constraints
+      config = build_executor_config(agent_def)
+      task_executor = LanguageOperator::Agent::TaskExecutor.new(agent, agent_def.tasks, config)
+
+      logger.info('Executing main block',
+                  agent: agent_def.name,
+                  task_count: agent_def.tasks.size)
+
+      # Get inputs from environment or default to empty hash
+      inputs = {}
+
+      # Execute main block with task executor as context
+      result = agent_def.main.call(inputs, task_executor)
+
+      logger.info('Main block execution completed',
+                  result: result)
+
+      result
+    end
+
+    # Build executor configuration from agent definition constraints
+    #
+    # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
+    # @return [Hash] Executor configuration
+    def self.build_executor_config(agent_def)
+      config = {}
+
+      if agent_def.constraints
+        config[:timeout] = agent_def.constraints[:timeout] if agent_def.constraints[:timeout]
+        config[:max_retries] = agent_def.constraints[:max_retries] if agent_def.constraints[:max_retries]
+      end
+
+      config
+    end
   end
 end

data/lib/language_operator/cli/base_command.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module LanguageOperator
+  module CLI
+    # Base class for all CLI commands providing shared functionality
+    class BaseCommand < Thor
+      no_commands do
+        # Lazy-initialized cluster context from options
+        # @return [Helpers::ClusterContext]
+        def ctx
+          @ctx ||= Helpers::ClusterContext.from_options(options)
+        end
+
+        # Handle command errors with consistent formatting
+        # @param operation [String] Description of the operation for error message
+        # @yield Block to execute with error handling
+        def handle_command_error(operation)
+          yield
+        rescue StandardError => e
+          Formatters::ProgressFormatter.error("Failed to #{operation}: #{e.message}")
+          raise if ENV['DEBUG']
+
+          exit 1
+        end
+
+        # Get a Kubernetes resource or exit with helpful error message
+        # @param type [String] Resource type (e.g., 'LanguageAgent')
+        # @param name [String] Resource name
+        # @param error_message [String, nil] Custom error message (optional)
+        # @return [Hash] The Kubernetes resource
+        def get_resource_or_exit(type, name, error_message: nil)
+          ctx.client.get_resource(type, name, ctx.namespace)
+        rescue K8s::Error::NotFound => e
+          # Try to provide helpful fuzzy matching suggestions
+          resources = ctx.client.list_resources(type, namespace: ctx.namespace)
+          available_names = resources.map { |r| r.dig('metadata', 'name') }
+
+          msg = error_message || "#{type} '#{name}' not found in cluster '#{ctx.name}'"
+          Errors::Handler.handle_not_found(
+            e,
+            resource_type: type,
+            resource_name: name,
+            available_names: available_names,
+            cluster_name: ctx.name,
+            custom_message: msg
+          )
+          exit 1
+        end
+
+        # Confirm resource deletion with user
+        # @param resource_type [String] Type of resource being deleted
+        # @param name [String] Resource name
+        # @param cluster [String] Cluster name
+        # @param details [Hash] Additional details to display
+        # @param force [Boolean] Skip confirmation if true
+        # @return [Boolean] True if deletion should proceed
+        def confirm_deletion(resource_type, name, cluster, details: {}, force: false)
+          return true if force
+
+          puts "This will delete #{resource_type} '#{name}' from cluster '#{cluster}':"
+          details.each { |key, value| puts "  #{key}: #{value}" }
+          puts
+
+          Helpers::UserPrompts.confirm('Are you sure?')
+        end
+
+        # Check if resource has dependencies and confirm deletion
+        # @param resource_type [String] Type of resource (e.g., 'persona', 'model', 'tool')
+        # @param resource_name [String] Name of the resource
+        # @param force [Boolean] Skip dependency check if true
+        # @return [Boolean] True if deletion should proceed
+        def check_dependencies_and_confirm(resource_type, resource_name, force: false)
+          agents = ctx.client.list_resources('LanguageAgent', namespace: ctx.namespace)
+
+          checker_method = "agents_using_#{resource_type}"
+          agents_using = Helpers::ResourceDependencyChecker.send(checker_method, agents, resource_name)
+
+          if agents_using.any? && !force
+            Formatters::ProgressFormatter.warn(
+              "#{resource_type.capitalize} '#{resource_name}' is in use by #{agents_using.count} agent(s)"
+            )
+            puts
+            puts "Agents using this #{resource_type}:"
+            agents_using.each { |agent| puts "  - #{agent.dig('metadata', 'name')}" }
+            puts
+            puts 'Delete these agents first, or use --force to delete anyway.'
+            puts
+
+            return Helpers::UserPrompts.confirm('Are you sure?')
+          end
+
+          true
+        end
+
+        # List resources or handle empty state
+        # @param type [String] Resource type (e.g., 'LanguageModel')
+        # @param empty_message [String, nil] Custom message when no resources found
+        # @yield Optional block to execute when list is empty (for guidance)
+        # @return [Array<Hash>] List of resources (empty array if none found)
+        def list_resources_or_empty(type, empty_message: nil)
+          resources = ctx.client.list_resources(type, namespace: ctx.namespace)
+
+          if resources.empty?
+            msg = empty_message || "No #{type} resources found in cluster '#{ctx.name}'"
+            Formatters::ProgressFormatter.info(msg)
+            yield if block_given?
+          end
+
+          resources
+        end
+      end
+      # rubocop:enable Metrics/BlockLength
+    end
+  end
+end