language-operator 0.1.31 → 0.1.35

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'thor'
+require_relative '../base_command'
 require_relative '../formatters/progress_formatter'
 require_relative '../formatters/table_formatter'
 require_relative '../formatters/status_formatter'
@@ -13,26 +13,26 @@ module LanguageOperator
   module CLI
     module Commands
       # System status and overview command
-      class Status < Thor
+      class Status < BaseCommand
         include Helpers::PastelHelper
 
         desc 'overview', 'Show system status and overview'
         def overview
-          current_cluster = Config::ClusterConfig.current_cluster
-          clusters = Config::ClusterConfig.list_clusters
-
-          # Current cluster context
-          if current_cluster
-            cluster_config = Config::ClusterConfig.get_cluster(current_cluster)
-
-            puts "\nCluster Details"
-            puts '----------------'
-            puts "Name: #{pastel.bold.white(current_cluster)}"
-            puts "Namespace: #{pastel.bold.white(cluster_config[:namespace])}"
-            puts
+          handle_command_error('retrieve cluster status') do
+            current_cluster = Config::ClusterConfig.current_cluster
+            clusters = Config::ClusterConfig.list_clusters
+
+            # Current cluster context
+            if current_cluster
+              cluster_config = Config::ClusterConfig.get_cluster(current_cluster)
+
+              puts "\nCluster Details"
+              puts '----------------'
+              puts "Name: #{pastel.bold.white(current_cluster)}"
+              puts "Namespace: #{pastel.bold.white(cluster_config[:namespace])}"
+              puts
 
-            # Check cluster health
-            begin
+              # Check cluster health
               k8s = Helpers::ClusterValidator.kubernetes_client(current_cluster)
 
               # Operator status
@@ -96,29 +96,25 @@ module LanguageOperator
               else
                 puts '  (none)'
               end
-            rescue StandardError => e
-              Formatters::ProgressFormatter.error("Connection failed: #{e.message}")
+            else
+              Formatters::ProgressFormatter.warn('No cluster selected')
               puts
-              puts 'Check your cluster connection and try again'
-            end
-          else
-            Formatters::ProgressFormatter.warn('No cluster selected')
-            puts
-            if clusters.any?
-              puts 'Available clusters:'
-              clusters.each do |cluster|
-                puts "  - #{cluster[:name]}"
+              if clusters.any?
+                puts 'Available clusters:'
+                clusters.each do |cluster|
+                  puts "  - #{cluster[:name]}"
+                end
+                puts
+                puts 'Select a cluster with:'
+                puts '  aictl use <cluster>'
+              else
+                puts 'No clusters found. Create one with:'
+                puts '  aictl cluster create <name>'
               end
-              puts
-              puts 'Select a cluster with:'
-              puts '  aictl use <cluster>'
-            else
-              puts 'No clusters found. Create one with:'
-              puts '  aictl cluster create <name>'
             end
-          end
 
-          puts
+            puts
+          end
         end
 
         default_task :overview

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'thor'
 require 'json'
 require 'yaml'
+require_relative '../base_command'
 require_relative '../formatters/progress_formatter'
 require_relative '../../dsl/schema'
 
@@ -10,7 +10,7 @@ module LanguageOperator
   module CLI
     module Commands
       # System commands for schema introspection and metadata
-      class System < Thor
+      class System < BaseCommand
         desc 'schema', 'Export the DSL schema in various formats'
         long_desc <<-DESC
           Export the Language Operator Agent DSL schema in various formats.
@@ -39,30 +39,29 @@ module LanguageOperator
         option :format, type: :string, default: 'json', desc: 'Output format (json, yaml, openapi)'
         option :version, type: :boolean, default: false, desc: 'Show schema version only'
         def schema
-          # Handle version flag
-          if options[:version]
-            puts Dsl::Schema.version
-            return
-          end
+          handle_command_error('generate schema') do
+            # Handle version flag
+            if options[:version]
+              puts Dsl::Schema.version
+              return
+            end
 
-          # Generate schema based on format
-          format = options[:format].downcase
-          case format
-          when 'json'
-            output_json_schema
-          when 'yaml'
-            output_yaml_schema
-          when 'openapi'
-            output_openapi_schema
-          else
-            Formatters::ProgressFormatter.error("Invalid format: #{format}")
-            puts
-            puts 'Supported formats: json, yaml, openapi'
-            exit 1
+            # Generate schema based on format
+            format = options[:format].downcase
+            case format
+            when 'json'
+              output_json_schema
+            when 'yaml'
+              output_yaml_schema
+            when 'openapi'
+              output_openapi_schema
+            else
+              Formatters::ProgressFormatter.error("Invalid format: #{format}")
+              puts
+              puts 'Supported formats: json, yaml, openapi'
+              exit 1
+            end
           end
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to generate schema: #{e.message}")
-          exit 1
         end
 
         no_commands do
@@ -110,95 +109,93 @@ module LanguageOperator
         option :type, type: :string, default: 'agent', desc: 'Template type if using bundled template (agent, persona)'
         option :verbose, type: :boolean, default: false, desc: 'Show detailed violation information'
         def validate_template
-          # Determine template source
-          if options[:template]
-            # Load custom template from file
-            unless File.exist?(options[:template])
-              Formatters::ProgressFormatter.error("Template file not found: #{options[:template]}")
-              exit 1
+          handle_command_error('validate template') do
+            # Determine template source
+            if options[:template]
+              # Load custom template from file
+              unless File.exist?(options[:template])
+                Formatters::ProgressFormatter.error("Template file not found: #{options[:template]}")
+                exit 1
+              end
+              template_content = File.read(options[:template])
+              template_name = File.basename(options[:template])
+            else
+              # Load bundled template
+              template_type = options[:type].downcase
+              unless %w[agent persona].include?(template_type)
+                Formatters::ProgressFormatter.error("Invalid template type: #{template_type}")
+                puts
+                puts 'Supported types: agent, persona'
+                exit 1
+              end
+              template_content = load_bundled_template(template_type)
+              template_name = "bundled #{template_type} template"
             end
-            template_content = File.read(options[:template])
-            template_name = File.basename(options[:template])
-          else
-            # Load bundled template
-            template_type = options[:type].downcase
-            unless %w[agent persona].include?(template_type)
-              Formatters::ProgressFormatter.error("Invalid template type: #{template_type}")
+
+            # Display header
+            puts "Validating template: #{template_name}"
+            puts '=' * 60
+            puts
+
+            # Extract code examples
+            code_examples = extract_code_examples(template_content)
+
+            if code_examples.empty?
+              Formatters::ProgressFormatter.warn('No Ruby code examples found in template')
               puts
-              puts 'Supported types: agent, persona'
+              puts 'Templates should contain Ruby code blocks like:'
+              puts '```ruby'
+              puts 'agent "my-agent" do'
+              puts '  # ...'
+              puts 'end'
+              puts '```'
               exit 1
             end
-            template_content = load_bundled_template(template_type)
-            template_name = "bundled #{template_type} template"
-          end
 
-          # Display header
-          puts "Validating template: #{template_name}"
-          puts '=' * 60
-          puts
-
-          # Extract code examples
-          code_examples = extract_code_examples(template_content)
-
-          if code_examples.empty?
-            Formatters::ProgressFormatter.warn('No Ruby code examples found in template')
+            puts "Found #{code_examples.size} code example(s)"
             puts
-            puts 'Templates should contain Ruby code blocks like:'
-            puts '```ruby'
-            puts 'agent "my-agent" do'
-            puts '  # ...'
-            puts 'end'
-            puts '```'
-            exit 1
-          end
 
-          puts "Found #{code_examples.size} code example(s)"
-          puts
-
-          # Validate each example
-          all_valid = true
-          code_examples.each_with_index do |example, idx|
-            puts "Example #{idx + 1} (starting at line #{example[:start_line]}):"
-            puts '-' * 40
+            # Validate each example
+            all_valid = true
+            code_examples.each_with_index do |example, idx|
+              puts "Example #{idx + 1} (starting at line #{example[:start_line]}):"
+              puts '-' * 40
+
+              result = validate_code_against_schema(example[:code])
+
+              if result[:valid] && result[:warnings].empty?
+                Formatters::ProgressFormatter.success('Valid - No issues found')
+              elsif result[:valid]
+                Formatters::ProgressFormatter.success('Valid - With warnings')
+                result[:warnings].each do |warn|
+                  line = example[:start_line] + (warn[:location] || 0)
+                  puts "  ⚠  Line #{line}: #{warn[:message]}"
+                end
+              else
+                Formatters::ProgressFormatter.error('Invalid - Violations detected')
+                result[:errors].each do |err|
+                  line = example[:start_line] + (err[:location] || 0)
+                  puts "  ✗ Line #{line}: #{err[:message]}"
+                  puts "    Type: #{err[:type]}" if options[:verbose]
+                end
+                all_valid = false
+              end
 
-            result = validate_code_against_schema(example[:code])
+              puts
+            end
 
-            if result[:valid] && result[:warnings].empty?
-              Formatters::ProgressFormatter.success('Valid - No issues found')
-            elsif result[:valid]
-              Formatters::ProgressFormatter.success('Valid - With warnings')
-              result[:warnings].each do |warn|
-                line = example[:start_line] + (warn[:location] || 0)
-                puts "  ⚠  Line #{line}: #{warn[:message]}"
-              end
+            # Final summary
+            puts '=' * 60
+            if all_valid
+              Formatters::ProgressFormatter.success('All examples are valid')
+              exit 0
             else
-              Formatters::ProgressFormatter.error('Invalid - Violations detected')
-              result[:errors].each do |err|
-                line = example[:start_line] + (err[:location] || 0)
-                puts "  ✗ Line #{line}: #{err[:message]}"
-                puts "    Type: #{err[:type]}" if options[:verbose]
-              end
-              all_valid = false
+              Formatters::ProgressFormatter.error('Validation failed')
+              puts
+              puts 'Fix the violations above and run validation again.'
+              exit 1
             end
-
-            puts
-          end
-
-          # Final summary
-          puts '=' * 60
-          if all_valid
-            Formatters::ProgressFormatter.success('All examples are valid')
-            exit 0
-          else
-            Formatters::ProgressFormatter.error('Validation failed')
-            puts
-            puts 'Fix the violations above and run validation again.'
-            exit 1
           end
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Validation error: #{e.message}")
-          puts e.backtrace.first(5).join("\n") if options[:verbose]
-          exit 1
         end
 
         desc 'test-synthesis', 'Test agent synthesis from natural language instructions'
@@ -234,90 +231,88 @@ module LanguageOperator
         option :models, type: :string, desc: 'Comma-separated list of available models'
         option :dry_run, type: :boolean, default: false, desc: 'Show prompt without calling LLM'
         def test_synthesis
-          # Load synthesis template
-          template_content = load_bundled_template('agent')
-
-          # Detect temporal intent from instructions
-          temporal_intent = detect_temporal_intent(options[:instructions])
-
-          # Prepare template data
-          template_data = {
-            'Instructions' => options[:instructions],
-            'AgentName' => options[:agent_name],
-            'ToolsList' => format_tools_list(options[:tools]),
-            'ModelsList' => format_models_list(options[:models]),
-            'TemporalIntent' => temporal_intent,
-            'PersonaSection' => '',
-            'ScheduleSection' => temporal_intent == 'scheduled' ? '  schedule "0 */1 * * *"  # Example hourly schedule' : '',
-            'ScheduleRules' => temporal_intent == 'scheduled' ? "\n2. Include schedule with cron expression\n3. Set mode to :scheduled\n4. " : "\n2. ",
-            'ConstraintsSection' => '',
-            'ErrorContext' => nil
-          }
-
-          # Render template (Go-style template syntax)
-          rendered_prompt = render_go_template(template_content, template_data)
+          handle_command_error('test synthesis') do
+            # Load synthesis template
+            template_content = load_bundled_template('agent')
+
+            # Detect temporal intent from instructions
+            temporal_intent = detect_temporal_intent(options[:instructions])
+
+            # Prepare template data
+            template_data = {
+              'Instructions' => options[:instructions],
+              'AgentName' => options[:agent_name],
+              'ToolsList' => format_tools_list(options[:tools]),
+              'ModelsList' => format_models_list(options[:models]),
+              'TemporalIntent' => temporal_intent,
+              'PersonaSection' => '',
+              'ScheduleSection' => temporal_intent == 'scheduled' ? '  schedule "0 */1 * * *"  # Example hourly schedule' : '',
+              'ScheduleRules' => temporal_intent == 'scheduled' ? "\n2. Include schedule with cron expression\n3. Set mode to :scheduled\n4. " : "\n2. ",
+              'ConstraintsSection' => '',
+              'ErrorContext' => nil
+            }
+
+            # Render template (Go-style template syntax)
+            rendered_prompt = render_go_template(template_content, template_data)
+
+            if options[:dry_run]
+              # Show the prompt that would be sent
+              puts 'Synthesis Prompt Preview'
+              puts '=' * 80
+              puts
+              puts rendered_prompt
+              puts
+              puts '=' * 80
+              Formatters::ProgressFormatter.success('Dry-run complete - prompt displayed above')
+              return
+            end
 
-          if options[:dry_run]
-            # Show the prompt that would be sent
-            puts 'Synthesis Prompt Preview'
-            puts '=' * 80
+            # Call LLM to generate code
+            puts 'Generating agent code from instructions...'
             puts
-            puts rendered_prompt
-            puts
-            puts '=' * 80
-            Formatters::ProgressFormatter.success('Dry-run complete - prompt displayed above')
-            return
-          end
 
-          # Call LLM to generate code
-          puts 'Generating agent code from instructions...'
-          puts
+            llm_response = call_llm_for_synthesis(rendered_prompt)
 
-          llm_response = call_llm_for_synthesis(rendered_prompt)
+            # Extract Ruby code from response
+            generated_code = extract_ruby_code(llm_response)
 
-          # Extract Ruby code from response
-          generated_code = extract_ruby_code(llm_response)
+            if generated_code.nil?
+              Formatters::ProgressFormatter.error('Failed to extract Ruby code from LLM response')
+              puts
+              puts 'LLM Response:'
+              puts llm_response
+              exit 1
+            end
 
-          if generated_code.nil?
-            Formatters::ProgressFormatter.error('Failed to extract Ruby code from LLM response')
+            # Display generated code
+            puts 'Generated Code:'
+            puts '=' * 80
+            puts generated_code
+            puts '=' * 80
             puts
-            puts 'LLM Response:'
-            puts llm_response
-            exit 1
-          end
 
-          # Display generated code
-          puts 'Generated Code:'
-          puts '=' * 80
-          puts generated_code
-          puts '=' * 80
-          puts
-
-          # Validate generated code
-          puts 'Validating generated code...'
-          validation_result = validate_code_against_schema(generated_code)
-
-          if validation_result[:valid] && validation_result[:warnings].empty?
-            Formatters::ProgressFormatter.success('✅ Code is valid - No issues found')
-          elsif validation_result[:valid]
-            Formatters::ProgressFormatter.success('✅ Code is valid - With warnings')
-            puts
-            validation_result[:warnings].each do |warn|
-              puts "  ⚠  #{warn[:message]}"
+            # Validate generated code
+            puts 'Validating generated code...'
+            validation_result = validate_code_against_schema(generated_code)
+
+            if validation_result[:valid] && validation_result[:warnings].empty?
+              Formatters::ProgressFormatter.success('✅ Code is valid - No issues found')
+            elsif validation_result[:valid]
+              Formatters::ProgressFormatter.success('✅ Code is valid - With warnings')
+              puts
+              validation_result[:warnings].each do |warn|
+                puts "  ⚠  #{warn[:message]}"
+              end
+            else
+              Formatters::ProgressFormatter.error('❌ Code validation failed')
+              puts
+              validation_result[:errors].each do |err|
+                puts "  ✗ #{err[:message]}"
+              end
             end
-          else
-            Formatters::ProgressFormatter.error('❌ Code validation failed')
+
             puts
-            validation_result[:errors].each do |err|
-              puts "  ✗ #{err[:message]}"
-            end
           end
-
-          puts
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Test synthesis failed: #{e.message}")
-          puts e.backtrace.first(5).join("\n") if options[:verbose]
-          exit 1
         end
 
         desc 'synthesis-template', 'Export synthesis templates for agent code generation'
@@ -352,62 +347,61 @@ module LanguageOperator
         option :with_schema, type: :boolean, default: false, desc: 'Include DSL schema in output'
         option :validate, type: :boolean, default: false, desc: 'Validate template syntax'
         def synthesis_template
-          # Validate type
-          template_type = options[:type].downcase
-          unless %w[agent persona].include?(template_type)
-            Formatters::ProgressFormatter.error("Invalid template type: #{template_type}")
-            puts
-            puts 'Supported types: agent, persona'
-            exit 1
-          end
+          handle_command_error('load template') do
+            # Validate type
+            template_type = options[:type].downcase
+            unless %w[agent persona].include?(template_type)
+              Formatters::ProgressFormatter.error("Invalid template type: #{template_type}")
+              puts
+              puts 'Supported types: agent, persona'
+              exit 1
+            end
 
-          # Load template
-          template_content = load_template(template_type)
+            # Load template
+            template_content = load_template(template_type)
 
-          # Validate if requested
-          if options[:validate]
-            validation_result = validate_template_content(template_content, template_type)
+            # Validate if requested
+            if options[:validate]
+              validation_result = validate_template_content(template_content, template_type)
 
-            # Display warnings if any
-            unless validation_result[:warnings].empty?
-              Formatters::ProgressFormatter.warn('Template validation warnings:')
-              validation_result[:warnings].each do |warning|
-                puts "  ⚠  #{warning}"
+              # Display warnings if any
+              unless validation_result[:warnings].empty?
+                Formatters::ProgressFormatter.warn('Template validation warnings:')
+                validation_result[:warnings].each do |warning|
+                  puts "  ⚠  #{warning}"
+                end
+                puts
+              end
+
+              # Display errors and exit if validation failed
+              if validation_result[:valid]
+                Formatters::ProgressFormatter.success('Template validation passed')
+                return
+              else
+                Formatters::ProgressFormatter.error('Template validation failed:')
+                validation_result[:errors].each do |error|
+                  puts "  ✗ #{error}"
+                end
+                exit 1
               end
-              puts
             end
 
-            # Display errors and exit if validation failed
-            if validation_result[:valid]
-              Formatters::ProgressFormatter.success('Template validation passed')
-              return
+            # Generate output based on format
+            format = options[:format].downcase
+            case format
+            when 'template'
+              output_template_format(template_content)
+            when 'json'
+              output_json_format(template_content, template_type)
+            when 'yaml'
+              output_yaml_format(template_content, template_type)
             else
-              Formatters::ProgressFormatter.error('Template validation failed:')
-              validation_result[:errors].each do |error|
-                puts "  ✗ #{error}"
-              end
+              Formatters::ProgressFormatter.error("Invalid format: #{format}")
+              puts
+              puts 'Supported formats: template, json, yaml'
               exit 1
             end
           end
-
-          # Generate output based on format
-          format = options[:format].downcase
-          case format
-          when 'template'
-            output_template_format(template_content)
-          when 'json'
-            output_json_format(template_content, template_type)
-          when 'yaml'
-            output_yaml_format(template_content, template_type)
-          else
-            Formatters::ProgressFormatter.error("Invalid format: #{format}")
-            puts
-            puts 'Supported formats: template, json, yaml'
-            exit 1
-          end
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to load template: #{e.message}")
-          exit 1
         end
 
         private
@@ -649,21 +643,18 @@ module LanguageOperator
         # Extract method calls from template code
         # Returns array of method name strings
         def extract_method_calls(template)
-          require 'parser/current'
+          require 'prism'
 
           method_calls = []
           code_examples = extract_code_examples(template)
 
           code_examples.each do |example|
             # Parse the code to find method calls
-            buffer = Parser::Source::Buffer.new('(template)')
-            buffer.source = example[:code]
-            parser = Parser::CurrentRuby.new
-            ast = parser.parse(buffer)
+            result = Prism.parse(example[:code])
 
             # Walk the AST to find method calls
-            extract_methods_from_ast(ast, method_calls)
-          rescue Parser::SyntaxError
+            extract_methods_from_ast(result.value, method_calls) if result.success?
+          rescue Prism::ParseError
             # Skip code with syntax errors - they'll be caught by validate_code_against_schema
             next
           end
@@ -673,14 +664,11 @@ module LanguageOperator
 
         # Recursively extract method names from AST
         def extract_methods_from_ast(node, methods)
-          return unless node.is_a?(Parser::AST::Node)
+          return unless node
 
-          if node.type == :send
-            _, method_name, * = node.children
-            methods << method_name.to_s if method_name
-          end
+          methods << node.name.to_s if node.is_a?(Prism::CallNode)
 
-          node.children.each do |child|
+          node.compact_child_nodes.each do |child|
             extract_methods_from_ast(child, methods)
           end
         end