language-operator 0.1.31 → 0.1.35

data/lib/language_operator/ux/concerns/input_validation.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module Ux
+    module Concerns
+      # Mixin for common input validation and prompting patterns
+      #
+      # Provides helpers for common validation scenarios like URLs, emails,
+      # Kubernetes resource names, and other frequently validated inputs.
+      #
+      # @example
+      #   class MyFlow < Base
+      #     include Concerns::InputValidation
+      #
+      #     def execute
+      #       url = ask_url('Enter endpoint URL:')
+      #       name = ask_k8s_name('Resource name:')
+      #     end
+      #   end
+      module InputValidation
+        # Ask for a URL with validation
+        #
+        # @param question [String] The prompt question
+        # @param default [String, nil] Default value
+        # @param required [Boolean] Whether input is required
+        # @return [String, nil] The validated URL or nil if cancelled
+        def ask_url(question, default: nil, required: true)
+          prompt.ask(question, default: default) do |q|
+            q.required required
+            q.validate(%r{^https?://})
+            q.messages[:valid?] = 'Must be a valid HTTP(S) URL'
+          end
+        rescue TTY::Reader::InputInterrupt
+          nil
+        end
+
+        # Ask for a Kubernetes-compatible resource name
+        #
+        # @param question [String] The prompt question
+        # @param default [String, nil] Default value
+        # @return [String, nil] The validated name or nil if cancelled
+        def ask_k8s_name(question, default: nil)
+          prompt.ask(question, default: default) do |q|
+            q.required true
+            q.validate(/^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/, 'Must be lowercase alphanumeric with hyphens')
+            q.modify :strip, :down
+          end
+        rescue TTY::Reader::InputInterrupt
+          nil
+        end
+
+        # Ask for an email address with validation
+        #
+        # @param question [String] The prompt question
+        # @param default [String, nil] Default value
+        # @return [String, nil] The validated email or nil if cancelled
+        def ask_email(question, default: nil)
+          prompt.ask(question, default: default) do |q|
+            q.required true
+            q.validate(/\A[\w+\-.]+@[a-z\d-]+(\.[a-z\d-]+)*\.[a-z]+\z/i)
+            q.messages[:valid?] = 'Please enter a valid email address'
+          end
+        rescue TTY::Reader::InputInterrupt
+          nil
+        end
+
+        # Ask for a masked input (like API keys or passwords)
+        #
+        # @param question [String] The prompt question
+        # @param required [Boolean] Whether input is required
+        # @return [String, nil] The input value or nil if cancelled
+        def ask_secret(question, required: true)
+          prompt.mask(question) do |q|
+            q.required required
+          end
+        rescue TTY::Reader::InputInterrupt
+          nil
+        end
+
+        # Ask for a port number with validation
+        #
+        # @param question [String] The prompt question
+        # @param default [Integer, nil] Default value
+        # @return [Integer, nil] The validated port or nil if cancelled
+        def ask_port(question, default: nil)
+          prompt.ask(question, default: default, convert: :int) do |q|
+            q.required true
+            q.validate(->(v) { v.to_i.between?(1, 65_535) })
+            q.messages[:valid?] = 'Must be a valid port number (1-65535)'
+          end
+        rescue TTY::Reader::InputInterrupt
+          nil
+        end
+
+        # Ask a yes/no question
+        #
+        # @param question [String] The prompt question
+        # @param default [Boolean] Default value
+        # @return [Boolean, nil] The response or nil if cancelled
+        def ask_yes_no(question, default: false)
+          prompt.yes?(question, default: default)
+        rescue TTY::Reader::InputInterrupt
+          nil
+        end
+
+        # Ask for selection from a list
+        #
+        # @param question [String] The prompt question
+        # @param choices [Array] Array of choices
+        # @param per_page [Integer] Items per page for pagination
+        # @return [Object, nil] The selected choice or nil if cancelled
+        def ask_select(question, choices, per_page: 10)
+          prompt.select(question, choices, per_page: per_page)
+        rescue TTY::Reader::InputInterrupt
+          nil
+        end
+
+        # Validate and coerce a Kubernetes resource name
+        #
+        # @param name [String] The name to validate
+        # @return [String] The validated and normalized name
+        # @raise [ArgumentError] If name is invalid
+        def validate_k8s_name(name)
+          normalized = name.to_s.downcase.strip
+          raise ArgumentError, "Invalid Kubernetes name: #{name}" unless normalized.match?(/^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/)
+
+          normalized
+        end
+
+        # Validate a URL
+        #
+        # @param url [String] The URL to validate
+        # @return [String] The validated URL
+        # @raise [ArgumentError] If URL is invalid
+        def validate_url(url)
+          uri = URI.parse(url)
+          raise ArgumentError, "Invalid URL: #{url}" unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+
+          url
+        rescue URI::InvalidURIError => e
+          raise ArgumentError, "Invalid URL: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/ux/concerns/provider_helpers.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module LanguageOperator
+  module Ux
+    module Concerns
+      # Mixin for common LLM provider operations
+      #
+      # Provides helpers for testing provider connections, fetching available models,
+      # and handling provider-specific configuration.
+      #
+      # @example
+      #   class MyFlow < Base
+      #     include Concerns::ProviderHelpers
+      #
+      #     def setup
+      #       result = test_provider_connection(:anthropic, api_key: 'sk-...')
+      #       models = fetch_provider_models(:openai, api_key: 'sk-...')
+      #     end
+      #   end
+      module ProviderHelpers
+        # Test connection to an LLM provider
+        #
+        # @param provider [Symbol] Provider type (:anthropic, :openai, :openai_compatible)
+        # @param api_key [String, nil] API key for authentication
+        # @param endpoint [String, nil] Custom endpoint URL (for openai_compatible)
+        # @return [Hash] Result with :success and optional :error keys
+        def test_provider_connection(provider, api_key: nil, endpoint: nil)
+          require 'ruby_llm'
+
+          case provider
+          when :anthropic
+            test_anthropic(api_key)
+          when :openai
+            test_openai(api_key)
+          when :openai_compatible
+            test_openai_compatible(endpoint, api_key)
+          else
+            { success: false, error: "Unknown provider: #{provider}" }
+          end
+        end
+
+        # Fetch available models from a provider
+        #
+        # @param provider [Symbol] Provider type
+        # @param api_key [String, nil] API key for authentication
+        # @param endpoint [String, nil] Custom endpoint URL
+        # @return [Array<String>, nil] List of model IDs or nil if unavailable
+        def fetch_provider_models(provider, api_key: nil, endpoint: nil)
+          case provider
+          when :anthropic
+            # Anthropic doesn't have a public /v1/models endpoint
+            [
+              'claude-3-5-sonnet-20241022',
+              'claude-3-opus-20240229',
+              'claude-3-sonnet-20240229',
+              'claude-3-haiku-20240307'
+            ]
+          when :openai
+            fetch_openai_models(api_key)
+          when :openai_compatible
+            fetch_openai_compatible_models(endpoint, api_key)
+          end
+        rescue StandardError => e
+          CLI::Formatters::ProgressFormatter.warn("Could not fetch models: #{e.message}")
+          nil
+        end
+
+        # Get provider display information
+        #
+        # @param provider [Symbol] Provider type
+        # @return [Hash] Hash with :name, :docs_url keys
+        def provider_info(provider)
+          case provider
+          when :anthropic
+            { name: 'Anthropic', docs_url: 'https://console.anthropic.com' }
+          when :openai
+            { name: 'OpenAI', docs_url: 'https://platform.openai.com/api-keys' }
+          when :openai_compatible
+            { name: 'OpenAI-Compatible', docs_url: nil }
+          else
+            { name: provider.to_s.capitalize, docs_url: nil }
+          end
+        end
+
+        private
+
+        def test_anthropic(api_key)
+          client = RubyLLM.new(provider: :anthropic, api_key: api_key)
+          client.chat(
+            [{ role: 'user', content: 'Test' }],
+            model: 'claude-3-5-sonnet-20241022',
+            max_tokens: 10
+          )
+          { success: true }
+        rescue StandardError => e
+          { success: false, error: e.message }
+        end
+
+        def test_openai(api_key)
+          client = RubyLLM.new(provider: :openai, api_key: api_key)
+          client.chat(
+            [{ role: 'user', content: 'Test' }],
+            model: 'gpt-4-turbo',
+            max_tokens: 10
+          )
+          { success: true }
+        rescue StandardError => e
+          { success: false, error: e.message }
+        end
+
+        def test_openai_compatible(endpoint, api_key = nil)
+          # For OpenAI-compatible endpoints, we don't make a test request
+          # as we can't know what model to use. Just verify the endpoint is reachable.
+          fetch_openai_compatible_models(endpoint, api_key)
+          { success: true }
+        rescue StandardError => e
+          { success: false, error: e.message }
+        end
+
+        def fetch_openai_models(api_key)
+          fetch_models_from_endpoint('https://api.openai.com', api_key)
+        end
+
+        def fetch_openai_compatible_models(endpoint, api_key)
+          return nil unless endpoint
+
+          fetch_models_from_endpoint(endpoint, api_key)
+        end
+
+        def fetch_models_from_endpoint(base_url, api_key)
+          models_url = URI.join(
+            base_url.end_with?('/') ? base_url : "#{base_url}/",
+            'v1/models'
+          ).to_s
+
+          uri = URI(models_url)
+          request = Net::HTTP::Get.new(uri)
+          request['Authorization'] = "Bearer #{api_key}" if api_key
+          request['Content-Type'] = 'application/json'
+
+          response = Net::HTTP.start(
+            uri.hostname,
+            uri.port,
+            use_ssl: uri.scheme == 'https',
+            read_timeout: 10
+          ) do |http|
+            http.request(request)
+          end
+
+          return nil unless response.is_a?(Net::HTTPSuccess)
+
+          data = JSON.parse(response.body)
+          models = data['data']&.map { |m| m['id'] } || []
+
+          # Filter out fine-tuned/snapshot models for better UX
+          models.reject { |m| m.include?('ft-') || m.include?(':') }
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/ux/create_agent.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../cli/helpers/schedule_builder'
+
+module LanguageOperator
+  module Ux
+    # Interactive flow for creating agents
+    #
+    # Guides users through task description, scheduling, and tool configuration.
+    #
+    # @example
+    #   description = Ux::CreateAgent.execute(ctx)
+    #
+    # rubocop:disable Metrics/ClassLength, Metrics/AbcSize
+    class CreateAgent < Base
+      # Execute the agent creation flow
+      #
+      # @return [String, nil] Generated description or nil if cancelled
+      def execute
+        show_welcome
+
+        # Step 1: Get task description
+        task = ask_task_description
+        return nil unless task
+
+        # Step 2: Determine schedule
+        schedule_info = ask_schedule
+        return nil unless schedule_info
+
+        # Step 3: Tool detection and configuration
+        tools_config = configure_tools(task)
+
+        # Step 4: Preview and confirm
+        description = build_description(task, schedule_info, tools_config)
+
+        show_preview(description, schedule_info, tools_config)
+
+        return nil unless confirm_creation?
+
+        description
+      end
+
+      private
+
+      def show_welcome
+        heading('Model quick start')
+      end
+
+      def ask_task_description
+        prompt.ask('What should your agent do?') do |q|
+          q.required true
+          q.validate(/\w+/)
+          q.messages[:valid?] = 'Please describe a task (cannot be empty)'
+        end
+      rescue TTY::Reader::InputInterrupt
+        CLI::Formatters::ProgressFormatter.error('Cancelled')
+        nil
+      end
+
+      def ask_schedule
+        puts
+        schedule_type = prompt.select('How often should it run?') do |menu|
+          menu.choice 'Every day at a specific time', :daily
+          menu.choice 'Every few minutes/hours', :interval
+          menu.choice 'Continuously (whenever something changes)', :continuous
+          menu.choice 'Only when I trigger it manually', :manual
+        end
+
+        case schedule_type
+        when :daily
+          ask_daily_schedule
+        when :interval
+          ask_interval_schedule
+        when :continuous
+          { type: :continuous, description: 'continuously' }
+        when :manual
+          { type: :manual, description: 'on manual trigger' }
+        end
+      rescue TTY::Reader::InputInterrupt
+        CLI::Formatters::ProgressFormatter.error('Cancelled')
+        nil
+      end
+
+      def ask_daily_schedule
+        puts
+        time_input = prompt.ask('What time each day? (e.g., 4pm, 9:30am, 16:00):') do |q|
+          q.required true
+          q.validate(lambda do |input|
+            CLI::Helpers::ScheduleBuilder.parse_time(input)
+            true
+          rescue ArgumentError
+            false
+          end)
+          q.messages[:valid?] = 'Invalid time format. Try: 4pm, 9:30am, or 16:00'
+        end
+
+        time_24h = CLI::Helpers::ScheduleBuilder.parse_time(time_input)
+        cron = CLI::Helpers::ScheduleBuilder.daily_cron(time_24h)
+
+        {
+          type: :daily,
+          time: time_24h,
+          cron: cron,
+          description: "daily at #{time_input}"
+        }
+      end
+
+      def ask_interval_schedule
+        puts
+        interval = prompt.ask('How often?', convert: :int) do |q|
+          q.required true
+          q.validate(->(v) { v.to_i.positive? })
+          q.messages[:valid?] = 'Please enter a positive number'
+        end
+
+        unit = prompt.select('Minutes, hours, or days?', %w[minutes hours days])
+
+        cron = CLI::Helpers::ScheduleBuilder.interval_cron(interval, unit)
+
+        {
+          type: :interval,
+          interval: interval,
+          unit: unit,
+          cron: cron,
+          description: "every #{interval} #{unit}"
+        }
+      end
+
+      def configure_tools(task_description)
+        detected = detect_tools(task_description)
+        config = {}
+
+        return config if detected.empty?
+
+        puts
+        puts "I detected these tools: #{pastel.yellow(detected.join(', '))}"
+        puts
+
+        detected.each do |tool|
+          case tool
+          when 'email'
+            config[:email] = ask_email_config
+          when 'google-sheets', 'spreadsheet'
+            config[:spreadsheet] = ask_spreadsheet_config
+          when 'slack'
+            config[:slack] = ask_slack_config
+          end
+        end
+
+        config[:tools] = detected
+        config
+      end
+
+      def detect_tools(description)
+        tools = []
+        text = description.downcase
+
+        tools << 'email' if text.match?(/email|mail|send.*message/i)
+        tools << 'google-sheets' if text.match?(/spreadsheet|sheet|excel|csv/i)
+        tools << 'slack' if text.match?(/slack/i)
+        tools << 'github' if text.match?(/github|git|repo/i)
+
+        tools
+      end
+
+      def ask_email_config
+        email = prompt.ask('Your email for notifications:') do |q|
+          q.required true
+          q.validate(/\A[\w+\-.]+@[a-z\d-]+(\.[a-z\d-]+)*\.[a-z]+\z/i)
+          q.messages[:valid?] = 'Please enter a valid email address'
+        end
+        { address: email }
+      end
+
+      def ask_spreadsheet_config
+        url = prompt.ask('Spreadsheet URL:') do |q|
+          q.required true
+          q.validate(%r{^https?://}i)
+          q.messages[:valid?] = 'Please enter a valid URL'
+        end
+        { url: url }
+      end
+
+      def ask_slack_config
+        channel = prompt.ask('Slack channel (e.g., #general):') do |q|
+          q.required true
+        end
+        { channel: channel }
+      end
+
+      def build_description(task, schedule_info, tools_config)
+        parts = [task]
+
+        # Add schedule information
+        case schedule_info[:type]
+        when :daily
+          parts << schedule_info[:description]
+        when :interval
+          parts << schedule_info[:description]
+        when :continuous
+          # "continuously" might already be implied in task
+          parts << 'continuously' unless task.downcase.include?('continuous')
+        when :manual
+          # Manual trigger doesn't need to be in description
+        end
+
+        # Add tool-specific details
+        parts << "and email me at #{tools_config[:email][:address]}" if tools_config[:email]
+
+        if tools_config[:spreadsheet] && !task.include?('http')
+          # Replace generic "spreadsheet" with specific URL if not already present
+          parts << "using spreadsheet at #{tools_config[:spreadsheet][:url]}"
+        end
+
+        parts << "and send results to #{tools_config[:slack][:channel]}" if tools_config[:slack]
+
+        parts.join(' ')
+      end
+
+      def show_preview(description, schedule_info, tools_config)
+        puts
+        puts pastel.cyan('╭─ Preview ──────────────────────────────╮')
+        puts '│'
+        puts "│  #{pastel.bold('Task:')} #{description}"
+
+        if schedule_info[:type] == :manual
+          puts "│  #{pastel.bold('Mode:')} Manual trigger"
+        else
+          schedule_text = schedule_info[:description] || 'on demand'
+          puts "│  #{pastel.bold('Schedule:')} #{schedule_text}"
+        end
+
+        puts "│  #{pastel.bold('Cron:')} #{pastel.dim(schedule_info[:cron])}" if schedule_info[:cron]
+
+        puts "│  #{pastel.bold('Tools:')} #{tools_config[:tools].join(', ')}" if tools_config[:tools]&.any?
+
+        puts '│'
+        puts pastel.cyan('╰────────────────────────────────────────╯')
+        puts
+      end
+
+      def confirm_creation?
+        puts
+        prompt.yes?('Create this agent?')
+      rescue TTY::Reader::InputInterrupt
+        false
+      end
+    end
+    # rubocop:enable Metrics/ClassLength, Metrics/AbcSize
+  end
+end